iOS Swift RxSwift-结合操作符（七）

今天我们继续讲解RxSwift中结合操作符的使用。

结合操作符一共包含了六种，分别是startWith、merge、zip、combineLatest、withLatestFrom和switchLatest

 1、startWith

它的作用就是会在 Observable 序列开始之前插入一些事件元素。即发出事件消息之前，会先发出这些预先插入的事件消息。

代码如下：

    func startWith() {
        // 该方法会在 Observable 序列开始之前插入一些事件元素。即发出事件消息之前，会先发出这些预先插入的事件消息。
        //单个数据
        Observable.of(2,3).startWith(1).subscribe(onNext: {
            print($0)
            }).disposed(by: disposeBag)
        //多个数据
        Observable.of(11,12).startWith(1).startWith(2,3).startWith(4,5,6).startWith(7,8,9,10).subscribe(onNext: {
            print($0)
            }).disposed(by: disposeBag)
    }

结果如下：

1
2
3
7
8
9
10
4
5
6
2
3
1
11
12

startWith 会将最新的数据放到最前面，先进行处理。

---

2、merge

该方法可以将多个（两个或两个以上的）Observable 序列合并成一个 Observable序列。

func merge() {
        // 该方法可以将多个（两个或两个以上的）Observable 序列合并成一个 Observable序列。
        let subject1 = PublishSubject<Int>()
        let subject2 = PublishSubject<Int>()
        Observable.of(subject1,subject2).merge().subscribe(onNext: {
            print($0)
            }).disposed(by: disposeBag)
        subject1.onNext(20)
        subject1.onNext(40)
        subject1.onNext(60)
        subject2.onNext(1)
        subject1.onNext(80)
        subject1.onNext(100)
        subject2.onNext(1)
    }

结果如下：

20
40
60
1
80
100
1

从结果可以看出，相当于把两个PublishSubject合并成了一个，并将结果依次打印。

---

3、zip

该方法可以将多个（两个或两个以上的）Observable 序列压缩成一个 Observable 序列。 而且它会等到每个 Observable 事件一一对应地凑齐之后再合并。

func zip() {
        /*
         该方法可以将多个（两个或两个以上的）Observable 序列压缩成一个 Observable 序列。
         而且它会等到每个 Observable 事件一一对应地凑齐之后再合并。
         结果1A,2B,3C,4D
         */
        let subject1 = PublishSubject<Int>()
        let subject2 = PublishSubject<String>()
        Observable.zip(subject1, subject2){
            "\($0)\($1)"
        }.subscribe(onNext: {
            print($0)
            }).disposed(by: disposeBag)
        subject1.onNext(1)
        subject2.onNext("A")
        subject1.onNext(2)
        subject2.onNext("B")
        subject2.onNext("C")
        subject2.onNext("D")
        subject1.onNext(3)
        subject1.onNext(4)
        subject1.onNext(5)
    }

结果如下：

1A
2B
3C
4D

从结果看出，发送的内容必须是一对一的，如果subject1、subject2中有任何一个确实都不会进行打印。

---

4、combineLatest

 该方法同样是将多个（两个或两个以上的）Observable 序列元素进行合并。 但与 zip 不同的是，每当任意一个 Observable 有新的事件发出时，它会将每个 Observable 序列的最新的一个事件元素进行合并。

代码如下：

func combineLatest() {
        // 该方法同样是将多个（两个或两个以上的）Observable 序列元素进行合并。
        // 但与 zip 不同的是，每当任意一个 Observable 有新的事件发出时，它会将每个 Observable 序列的最新的一个事件元素进行合并。
        // 结果1A,2A,2B,2C,2D,3D,4D,5D
        let subject1 = PublishSubject<Int>()
        let subject2 = PublishSubject<String>()
        Observable.combineLatest(subject1, subject2){
            "\($0)\($1)"
        }.subscribe(onNext: {
            print($0)
            }).disposed(by: disposeBag)
        subject1.onNext(1)
        subject2.onNext("A")
        subject1.onNext(2)
        subject2.onNext("B")
        subject2.onNext("C")
        subject2.onNext("D")
        subject1.onNext(3)
        subject1.onNext(4)
        subject1.onNext(5)
    }

结果如下：

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

从结果可以看出subject1、subject2也是一一对应的，但是他会保持subject1、subject2的最新值逐一打印。

---

5、withLatestFrom

该方法将两个 Observable 序列合并为一个。每当 self 队列发射一个元素时，便从第二个序列中取出最新的一个值

代码如下：

func withLatestFrom() {
        // 该方法将两个 Observable 序列合并为一个。每当 self 队列发射一个元素时，便从第二个序列中取出最新的一个值
        // 这里的self相当于subject1
        // 结果1，1，2
        let subject1 = PublishSubject<String>()
        let subject2 = PublishSubject<String>()
        
        subject1.withLatestFrom(subject2)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        subject1.onNext("A")
        subject2.onNext("1")
        subject1.onNext("B")
        subject1.onNext("C")
        subject2.onNext("2")
        subject1.onNext("D")
    }

结果如下：

1
1
2

从结果可以看出，每当subject1变化了，都会将subject2的最新值进行一次打印。

---

6、switchLatest

switchLatest 有点像其他语言的switch 方法，可以对事件流进行转换。比如本来监听的 subject1，我可以通过更改 variable 里面的 value 更换事件源。变成监听 subject2。

代码如下：

func switchLatest() {
        // switchLatest 有点像其他语言的switch 方法，可以对事件流进行转换。
        // 比如本来监听的 subject1，我可以通过更改 variable 里面的 value 更换事件源。变成监听 subject2。
        //结果A,B,C,1,2,D,E
        
        let subject1 = BehaviorSubject(value: "A")
        let subject2 = BehaviorSubject(value: "1")
        
        let variable = Variable(subject1)
        
        variable.asObservable().switchLatest().subscribe(onNext: {
            print($0)
            }).disposed(by: disposeBag)
        
        subject1.onNext("B")
        subject1.onNext("C")
        
        //改变事件源
        variable.value = subject2
        subject1.onNext("D")
        subject2.onNext("2")
        
        //改变事件源
        variable.value = subject1
        subject2.onNext("3")
        subject1.onNext("E")
    }

结果如下：

A
B
C
1
2
D
E

从结果可以看出，每当我们更换Variable的value，再次发送事件，都会打印出更换后的value值。

---

以上就是RxSwift的结合操作符的使用。

下面是本人学习过程自己写的一个demo，感兴趣的小伙伴大家可以下载看一看。

---

Csdn下载

Gitbub下载