RxSwift (3) 组合符号

startWith

在开始发出订阅信号前，按照后进先出原则，发出指定的信号

    func rx_operators_startWith(){
        let disposeBag = DisposeBag()

        // 观察量序列 of是固定元素的观察序列
        var ofObservable = Observable.of("制服","丝袜","吊带","短裙")

        // startWith 订阅前添加
        ofObservable = ofObservable.startWith("都穿上")
        ofObservable = ofObservable.startWith("换一下衣服")
        ofObservable = ofObservable.startWith("老板娘","把妹妹们都喊出来")

        // 订阅
        ofObservable.subscribe { print("\($0)")
        }.addDisposableTo(disposeBag)


        // 这是拆解开来写，下面是组合 示范

        // 观察量序列 of是固定元素的观察序列
//        Observable.of("制服","丝袜","吊带","短裙")
//            
//            // startWith 订阅前添加
//            .startWith("都穿上")
//            .startWith("换一下衣服")
//            .startWith("老板娘","把妹妹们都喊出来")
//            
//            // 订阅
//            .subscribe { print("\($0)")
//            }.addDisposableTo(disposeBag)
    }

打印结果
next(老板娘)
next(把妹妹们都喊出来)
next(换一下衣服)
next(都穿上)
next(制服)
next(丝袜)
next(吊带)
next(短裙)
completed

merge

用一个 订阅者，同时订阅多个 观察量序列的 信号

将多个观察量序列(observable)比如a,b,c 合并为一个观察者(observe)序列s，当a、b、c任何一个序列发出信号的时候，s里，都接收个信号

 func rx_operators_merge(){
        let disposeBag = DisposeBag()

        // 传入一个元素，生成一个 发送元素信号的观察量序列
        let aObservable = { (x:String)->Observable<String> in
            return Observable<String>.create{ observe in

                observe.onNext(x)

                return Disposables.create {
                    print("a  结束")
                }
            }

        }

        let bObservable = { (x:String)->Observable<String> in
            return Observable<String>.create{ observe in

                observe.onNext(x)

                return Disposables.create {
                    print("b  结束")
                }
            }

        }


        let cObservable = { (x:String)->Observable<String> in
            return Observable<String>.create{ observe in

                observe.onNext(x)

                return Disposables.create {
                    print("c  结束")
                }
            }

        }

        // 合成
        Observable.from([aObservable("a萝莉"),bObservable("b御姐"),cObservable("c少妇")])
        // 关键代码 合成
        .merge()
        // 订阅
        .subscribe(onNext:{print($0)})
        .addDisposableTo(disposeBag)

    }

打印：
a萝莉
b御姐
c少妇
a  结束
b  结束
c  结束

zip

压缩合成，最多合成8个观察量序列，合成的几个 序列中，必须多个序列的同一次 信号发送必须有值，否则不发送

    func rx_operators_zip(){
        let disposeBag = DisposeBag()

        let aObservable = Observable<String>.create({observe in
            observe.onNext("美腿")

            return Disposables.create()
        })

        let bObservable = Observable<String>.create({observe in

            observe.onNext("丝袜")
            observe.onNext("制服")

            return Disposables.create()
        })

        let cObservable = Observable<String>.create({observe in

            observe.onNext("超短裙")
            observe.onNext("诱惑")
            observe.onNext("很不错")

            return Disposables.create()
        })

        //压缩  合成
        Observable.zip(aObservable, bObservable, cObservable) { (a, b, c)  in
            a+b+c
            }.subscribe (onNext:{
            print($0)
        }).addDisposableTo(disposeBag)
    }

打印结果:美腿丝袜超短裙

combineLatest

合成观察量序列，多8个，只要其中一个观察量序列 发出信号，那么这个合成序列就会采集所有序列目前最新的信号，合起来发送一次。

func rx_operators_combineLatest(){
        let disposeBag = DisposeBag()

        let aObservable = Observable.of("0","小朋友","萝莉")
        let bObservable = Observable.of("1","2","3","白丝")
        let cObservable = Observable.of("正义","欲望","邪恶","高尚")

        Observable.combineLatest(aObservable,bObservable,cObservable) { a,b,c in
            a+b+c
            }.subscribe{
                print($0)}.addDisposableTo(disposeBag)


    }

打印结果:
next(01正义)
next(小朋友1正义)
next(小朋友2正义)
next(小朋友2欲望)
next(萝莉2欲望)
next(萝莉3欲望)
next(萝莉3邪恶)
next(萝莉白丝邪恶)
next(萝莉白丝高尚)
completed

你会发现打印结果找不出来规律，是因为3个of发送信号不是串行的。你可以自己create几个序列试试哦。

switchLatest

订阅 2维 观察量序列，也就是 观察量序列里面 发送的信号也是观察量序列，将其转换为一个可以切换订阅序列的一维序列，当切换到新的序列的时候，旧订阅将取消

func rx_operators_switchLatest(){
        let disposeBag = DisposeBag()

        let aObservable = Observable<String>.create{observe in

            observe.onNext("女仆")
            observe.onNext("诱人")

            observe.onCompleted()

            return Disposables.create()
        }

        let bObservable = Observable<String>.create{observe in

            observe.onNext("萝莉")
            observe.onNext("音清体柔易推倒")

            observe.onCompleted()

            return Disposables.create{print("取消")}
        }

        let cObservable = Observable<Observable<String>>.create{ observe in
            observe.onNext(aObservable)
            observe.onNext(bObservable)

            observe.onCompleted()

            return Disposables.create()
        }

        Observable.of(aObservable,bObservable)
        .switchLatest()
        .subscribe {
            print($0)
        }
        .addDisposableTo(disposeBag)

        print("——————————————1111——————————————————————")
        cObservable.switchLatest()
        .subscribe{
        print($0)
        }
        .addDisposableTo(disposeBag)
        print("——————————————2222——————————————————————")


        let  vab = Variable(aObservable)

        vab.asObservable()
            .switchLatest()
            .subscribe(onNext:{print($0)})
            .addDisposableTo(disposeBag)

        // 切换到b
        vab.value = bObservable

        // 切换到a
        vab.value = aObservable

        print("———————————3333—————————————————————————")

        let aSubject = PublishSubject<String>()
        let bSubject = PublishSubject<String>()

        let variab = Variable(aSubject)

        variab.asObservable()
            .switchLatest()
            .subscribe{print($0)}
            .addDisposableTo(disposeBag)

        aSubject.onNext("萌萌哒小萝莉")
        bSubject.onNext("小苹果儿")

        //切换订阅
        variab.value = bSubject

        bSubject.onNext("皮皮虾我们走")
        aSubject.onNext("怪蜀黍")
        bSubject.onNext("哈哈哈")

        //再切换一次
        variab.value = aSubject

        aSubject.onNext("~~~！！！@@@")
        aSubject.onNext("制服诱惑")
        bSubject.onNext("看看结果")




    }

打印结果:
next(女仆)
next(诱人)
next(萝莉)
next(音清体柔易推倒)
取消
completed
——————————————1111——————————————————————
next(女仆)
next(诱人)
next(萝莉)
next(音清体柔易推倒)
取消
completed
——————————————2222——————————————————————
女仆
诱人
萝莉
音清体柔易推倒
取消
女仆
诱人
———————————3333—————————————————————————
next(萌萌哒小萝莉)
next(皮皮虾我们走)
next(哈哈哈)
next(~~~！！！@@@)
next(制服诱惑)