RxSwift学习笔记10：startWith/merge/zip/combineLatest/withLatestFrom/switchLatest

　　　　　//startWith
        //该方法会在 Observable 序列开始之前插入一些事件元素。即发出事件消息之前，会先发出这些预先插入的事件消息
        Observable.of(1,2,3)
            .startWith(0)
            .subscribe(onNext:{print($0)})
            .disposed(by: disposeBag)
        /*
         0
         1
         2
         3
         */
        print("
")
        //插入多个数据也是可以的
        Observable.of(1,2,3)
            .startWith(0)
            .startWith(-1)
            .startWith(-2)
            .subscribe(onNext:{print($0)})
            .disposed(by: disposeBag)
        /*
         -2
         -1
         0
         1
         2
         3
         */
        
        print("
")
        //merge
        //该方法可以将多个（两个或两个以上的）Observable 序列合并成一个 Observable 序列。
        let ps1 = PublishSubject<Int>()
        let ps2 = PublishSubject<Int>()
        Observable.of(ps1,ps2)
            .merge()
            .subscribe(onNext:{print($0)})
            .disposed(by: disposeBag)
        ps1.onNext(1)
        ps2.onNext(10)
        ps1.onNext(2)
        ps2.onNext(20)
        ps1.onNext(3)
        ps2.onNext(30)
        ps2.onNext(40)
        ps2.onNext(50)
        ps1.onNext(30)
        /*
         1
         10
         2
         20
         3
         30
         40
         50
         30
         */
        
        print("
")
        //zip
        //该方法可以将多个（两个或两个以上的）Observable 序列压缩成一个 Observable 序列。
        //而且它会等到每个 Observable 事件一一对应地凑齐之后再合并。
        
        let ps3 = PublishSubject<Int>()
        let ps4 = PublishSubject<String>()
        Observable.zip(ps3, ps4) { (s1, s2) -> String in
            return "(s1)(s2)"
            }.subscribe(onNext:{print($0)}).disposed(by: disposeBag)
        ps3.onNext(1)
        ps4.onNext("A")
        ps3.onNext(2)
        ps4.onNext("B")
        ps4.onNext("C")
        ps4.onNext("D")
        ps3.onNext(3)
        ps3.onNext(4)
        ps3.onNext(5)
        
        /*
         1A
         2B
         3C
         4D
         */
   
        print("
")
        // combineLatest
        // 该方法同样是将多个（两个或两个以上的）Observable 序列元素进行合并。
        // 但与 zip 不同的是，每当任意一个 Observable 有新的事件发出时，它会将每个 Observable 序列的最新的一个事件元素进行合并。
        let ps5 = PublishSubject<Int>()
        let ps6 = PublishSubject<String>()
        Observable.combineLatest(ps5, ps6) { (s1, s2) -> String in
            return "(s1)(s2)"
            }.subscribe(onNext:{print($0)}).disposed(by: disposeBag)
        ps5.onNext(1)
        ps6.onNext("A")
        ps5.onNext(2)
        ps6.onNext("B")
        ps6.onNext("C")
        ps6.onNext("D")
        ps5.onNext(3)
        ps5.onNext(4)
        ps5.onNext(5)
        /*
         1A
         2A
         2B
         2C
         2D
         3D
         4D
         5D
         */
        
        print("
")
        //withLatestFrom:
        //该方法将两个 Observable 序列合并为一个。每当 self 队列发射一个元素时，便从第二个序列中取出最新的一个值。
        let ps7 = PublishSubject<Int>()
        let ps8 = PublishSubject<String>()
         ps7.withLatestFrom(ps8)
            .subscribe(onNext:{print($0)})
            .disposed(by: disposeBag)
        ps7.onNext(1)
        ps8.onNext("A")
        ps7.onNext(2)
        ps8.onNext("B")
        ps8.onNext("C")
        ps8.onNext("D")
        ps7.onNext(3)
        ps7.onNext(4)
        ps7.onNext(5)
        /*
         A
         D
         D
         D
         */
        
        print("
")
        //switchLatest
        //switchLatest 有点像其他语言的 switch 方法，可以对事件流进行转换。
        //比如本来监听的 subject1，我可以通过更改 variable 里面的 value 更换事件源。变成监听 subject2。
        let subject1 = BehaviorSubject(value: "A")
        let subject2 = BehaviorSubject(value: "1")
        
        let variable = BehaviorRelay(value: subject1)
        
        variable.asObservable()
            .switchLatest()
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        subject1.onNext("B")
        subject1.onNext("C")
        
        //改变事件源
        variable.accept(subject2)//1
        subject1.onNext("D")
        subject2.onNext("2") //2
        
        //改变事件源
        variable.accept(subject1)//D
        subject2.onNext("3")
        subject1.onNext("E")//E
        
        /*
         A
         B
         C
         1
         2
         D
         E
         */