RxSwift (4) 转换符号

转换 观察量序列 发出的next信号 元素的 运算符

map

将接收的信号的值 做出处理 再传递下去

func rx_map(){
        let disposeBag = DisposeBag()

        let aObserable = Observable<String>.create { (observe) -> Disposable in
            observe.onNext("-1")
            observe.onNext("10")
            observe.onNext("5")

            observe.onCompleted()
            return Disposables.create()
        }


        let bObserable = Observable<String>.create { (observe) -> Disposable in
            observe.onNext("2")
            observe.onNext("3")
            observe.onNext("4")

            observe.onCompleted()
            return Disposables.create()
        }

        // 这里解释一下{(a,b) in (a,b) }，第一个(a,b)是形参，第二个(a,b)是一个泛型 也可以说是自定义类型有两个元素a和b
        Observable.zip(aObserable,bObserable){(a,b) in (a,b) }
        // 就是将接收的信号元素 做出处理 再返回新的 元素
        .map {
            (Int)($0.0)! + (Int)($0.1)!
        }
            .subscribe{print($0)}
        .addDisposableTo(disposeBag)
    }

打印：
next(1)
next(13)
next(9)
completed

flatMap

将接收的观察量信号 的元素 作为参数，返回一个新的观察量序列
可以理解成重写 观察量序列的方法

func rx_flatMap(){
        let disposeBag = DisposeBag()

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

            observe.onNext("橘子酒")
            observe.onNext("苹果酒")
            observe.onNext("红粉佳人")

            observe.onCompleted()

            return Disposables.create()
        }


        aObservable.flatMap { (x:String) -> Observable<String> in
            return Observable<String>.create{observe in

                let xx = x + "来一杯"
                observe.onNext(xx)

                return Disposables.create()
            }
        }
            .subscribe{print($0)}
        .addDisposableTo(disposeBag)




    }

打印结果
next(橘子酒来一杯)
next(苹果酒来一杯)
next(红粉佳人来一杯)

flatMap与flatMapLatest对比

flatMap可以同时 订阅合成来源序列的每一个，flatMapLatest只能订阅合成里最新的

let vari1 = Variable("1-0")
        let vari2 =  Variable("2-0")

        let vari = Variable(vari1)

        // 第一种flatMapLatest
        vari.asObservable().flatMapLatest { x in
        x.asObservable()
        }
        // 第二种
        //vari.asObservable().flatMap { x in
        //x.asObservable()
        //}
            .subscribe{print($0)}
        .addDisposableTo(disposeBag)

        vari1.value = "1-1"
        vari2.value = "2-11"

        vari.value = vari2

        vari2.value = "2-1"
        vari1.value = "1-11"

打印结果 第一种
next(1-0)
next(1-1)
next(2-11)
next(2-1)
completed



打印结果 第二种
next(1-0)
next(1-1)
next(2-11)
next(2-1)
next(1-11)
completed

Scan

观察量序列 把每次的运算结果累积起来，作为下一次运算的输入值，第一次的时候上次结果取 scan设置的默认值

func rx_scan(){

        let disposeBag = DisposeBag()

        Observable.of("连续","超神","五杀")
            .scan("排位赛", accumulator: {(a,b) in

                a+b
            })
            .subscribe{print($0)}
            .addDisposableTo(disposeBag)
    }

打印结果
next(排位赛连续)
next(排位赛连续超神)
next(排位赛连续超神五杀)
completed