RxSwift 文档：操作符

发表于 分类于 Disqus：

just 、 from 和 of

just 和 from 都能够将元素转化为 Observable 但是他们有本质的区别：

just

创建 Observable 发出唯一的一个元素。 just 操作符将某一个元素转换为 Observable。

示例：

1
2
3
4
5
6
7
let oJust = Observable.just([1, 2, 3, 4, 5])
oJust.subscribe(onNext: {
    print($0)
})
.dispose()

// [1, 2, 3, 4, 5]

相当于

1
2
3
4
5
let oJust = Observable<Array<Int>>.create { (observer) -> Disposable in
    observer.onNext([1, 2, 3, 4, 5])
    observer.onCompleted()
    return Disposables.create()
}

from

将其他类型或者数据结构转换为 Observable 。当你在使用 Observable 时，如果能够直接将其他类型转换为 Observable，这将是非常省事的。from 操作符就提供了这种功能。

示例：

1
2
3
4
5
6
7
8
9
10
11
let oFrom = Observable.from([1, 2, 3, 4, 5])
oFrom.subscribe(onNext: {
    print($0)
})
.dispose()

// 1
// 2
// 3
// 4
// 5

相当于

1
2
3
4
5
6
7
8
9
let oFrom = Observable<Int>.create { (observer) -> Disposable in
    observer.onNext(1)
    observer.onNext(2)
    observer.onNext(3)
    observer.onNext(4)
    observer.onNext(5)
    observer.onCompleted()
    return Disposables.create()
}

将一个值转化为 Observable 可以用 Observable.from(optional: <_?>) 方法。

1
2
let optional: Int? = 1
let value = Observable.from(optional: optional)

相当于

1
2
3
4
5
6
7
8
let optional: Int? = 1
let value = Observable<Int>.create { observer in
    if let element = optional {
        observer.onNext(element)
    }
    observer.onCompleted()
    return Disposables.create()
}

of

能将多个元素转化为 Observable 。

1
2
3
4
5
6
7
8
9
10
Observable.of(1, 2, 3, 4, 5).subscribe(onNext: {
    print($0)
})
.dispose()

// 1
// 2
// 3
// 4
// 5

concat、combineLatest 和 zip

concat

让两个或多个 Observables 按顺序串连起来。

concat 操作符将多个 Observables 按顺序串联起来，当前一个 Observable 元素发送完毕后，后一个 Observable 才可以开始发出元素。

concat 将等待前一个 Observable 产生完成事件后，才对后一个 Observable 进行订阅。如果后一个是“热” Observable ，在它前一个 Observable 产生完成事件前，所产生的元素将不会被发送出来。

startWith 和它十分相似。但是 startWith 不是在后面添加元素，而是在前面插入元素。

merge 和它也是十分相似。**merge 并不是将多个 Observables 按顺序串联起来，而是将他们合并到一起，不需要 Observables 按先后顺序发出元素。**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
let disposeBag = DisposeBag()

let subject1 = BehaviorSubject(value: "🍎")
let subject2 = BehaviorSubject(value: "🐶")

let variable = Variable(subject1)

variable.asObservable()
    .concat()
    .subscribe { print($0) }
    .disposed(by: disposeBag)

subject1.onNext("🍐")
subject1.onNext("🍊")

variable.value = subject2

subject2.onNext("I would be ignored")
subject2.onNext("🐱")

subject1.onCompleted()

subject2.onNext("🐭")

// next(🍎)
// next(🍐)
// next(🍊)
// next(🐱)
// next(🐭)

zip

通过一个函数将多个 Observables 的元素组合起来，然后将每一个组合的结果发出来。

zip 操作符将多个(最多不超过8个) Observables 的元素通过一个函数组合起来，然后将这个组合的结果发出来。它会严格的按照序列的索引数进行组合。例如，返回的 Observable 的第一个元素，是由每一个源 Observables 的第一个元素组合出来的。它的第二个元素 ，是由每一个源 Observables 的第二个元素组合出来的。它的第三个元素 ，是由每一个源 Observables 的第三个元素组合出来的，以此类推。它的元素数量等于源 Observables 中元素数量最少的那个。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
let disposeBag = DisposeBag()
let first = PublishSubject<String>()
let second = PublishSubject<String>()

Observable.zip(first, second) { $0 + $1 }
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

first.onNext("1")
second.onNext("A")
first.onNext("2")
second.onNext("B")
second.onNext("C")
second.onNext("D")
first.onNext("3")
first.onNext("4")
first.onNext("5") // 并没有输出

// 1A
// 2B
// 3C
// 4D

combineLatest（可与 zip 比较学习）

当多个 Observables 中任何一个发出一个元素，就发出一个元素。这个元素是由这些 Observables 中最新的元素，通过一个函数组合起来的。

combineLatest 操作符将多个 Observables 中最新的元素通过一个函数组合起来，然后将这个组合的结果发出来。这些源 Observables 中任何一个发出一个元素，他都会发出一个元素（前提是，这些 Observables 曾经发出过元素）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
let disposeBag = DisposeBag()

let first = PublishSubject<String>()
let second = PublishSubject<String>()

Observable.combineLatest(first, second) { $0 + $1 }
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

first.onNext("1")
second.onNext("A")
first.onNext("2")
second.onNext("B")
second.onNext("C")
second.onNext("D")
first.onNext("3")
first.onNext("4")

// 1A
// 2A
// 2B
// 2C
// 2D
// 3D
// 4D

flatMap 和 flatMapLatest

flatMap

将 Observable 的元素转换成其他的 Observable，然后将这些 Observables 合并。

flatMap 操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。 然后将这些 Observables 的元素合并之后再发送出来。

这个操作符是非常有用的，例如，当 Observable 的元素本生拥有其他的 Observable 时，你可以将所有子 Observables 的元素发送出来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
let disposeBag = DisposeBag()
let first = BehaviorSubject(value: "👦🏻")
let second = BehaviorSubject(value: "🅰️")
let variable = Variable(first)

variable.asObservable()
    .flatMap { $0 }
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

first.onNext("🐱")
variable.value = second
second.onNext("🅱️")
first.onNext("🐶")

// 👦🏻
// 🐱
// 🅰️
// 🅱️
// 🐶

flatMapLatest

将 Observable 的元素转换成其他的 Observable，然后取这些 Observables 中最新的一个。

flatMapLatest 操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。一旦转换出一个新的 Observable，就只发出它的元素，旧的 Observables 的元素将被忽略掉。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
let disposeBag = DisposeBag()
let first = BehaviorSubject(value: "👦🏻")
let second = BehaviorSubject(value: "🅰️")
let variable = Variable(first)

variable.asObservable()
    .flatMapLatest { $0 }
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

first.onNext("🐱")
variable.value = second
second.onNext("🅱️")
first.onNext("🐶")



// 👦🏻
// 🐱
// 🅰️
// 🅱️

scan

持续的将 Observable 的每一个元素应用一个函数，然后发出每一次函数返回的结果。

scan 操作符将对第一个元素应用一个函数，将结果作为第一个元素发出。然后，将结果作为参数填入到第二个元素的应用函数中，创建第二个元素。以此类推，直到遍历完全部的元素。

这种操作符在其他地方有时候被称作是 accumulator。

1
2
3
4
5
6
7
8
9
10
11
12
let disposeBag = DisposeBag()

Observable.of(10, 100, 1000)
    .scan(1) { aggregateValue, newValue in
        aggregateValue + newValue
    }
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

// 11
// 111
// 1111

materialize 和 dematerialize

materialize

将任何 Observable 转换为其事件的可观察者。

1
2
3
4
5
6
7
8
9
10
11
12
Observable
    .range(start: 1, count: 3)
    .materialize()
    .subscribe(onNext: {
        print($0)
    })
    .disposed(by: bag)

// next(1)
// next(2)
// next(3)
// completed

作为对比

1
2
3
4
5
6
7
8
9
10
Observable
    .range(start: 1, count: 3)
    .subscribe(onNext: {
        print($0)
    })
    .disposed(by: bag)

// 1
// 2
// 3

dematerialize

dematerialize 操作符将 materialize 转换后的元素还原

take 、 takeLast 和 elementAt

take

仅仅从 Observable 中发出头 n 个元素。通过 take 操作符你可以只发出头 n 个元素。并且忽略掉后面的元素，直接结束序列。

1
2
3
4
5
6
7
8
9
10
let disposeBag = DisposeBag()

Observable.of("🐱", "🐰", "🐶", "🐸", "🐷", "🐵")
    .take(3)
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

// 🐱
// 🐰
// 🐶

takeLast

仅仅从 Observable 中发出尾部 n 个元素，通过 takeLast 操作符你可以只发出尾部 n 个元素。并且忽略掉前面的元素。

1
2
3
4
5
6
7
8
9
10
let disposeBag = DisposeBag()

Observable.of("🐱", "🐰", "🐶", "🐸", "🐷", "🐵")
    .takeLast(3)
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

// 🐸
// 🐷
// 🐵

elementAt

只发出 Observable 中的第 n 个元素，elementAt 操作符将拉取 Observable 序列中指定索引数的元素，然后将它作为唯一的元素发出。

1
2
3
4
5
6
7
8
let disposeBag = DisposeBag()

Observable.of("🐱", "🐰", "🐶", "🐸", "🐷", "🐵")
    .elementAt(3)
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

// 🐸