08.RxSwift 高阶函数(二)

时间 2019-11-17

标签 08.rxswift rxswift 高阶函数繁體版

原文原文链接

1. 组合操做符

1.1 startWith

在开始从可观察源发出元素以前，发出指定的元素序列

print("*****startWith*****")
        Observable.of("1", "2", "3", "4")
            .startWith("A")
            .startWith("B")
            .startWith("C", "a", "b")
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        //效果: CabBA1234
复制代码

1.2 merge

将源可观察序列中的元素组合成一个新的可观察序列，并将像每一个源可观察序列发出元素同样发出每一个元素

print("*****merge*****")
        let subject1 = PublishSubject<String>()
        let subject2 = PublishSubject<String>()
        // merge subject1和subject2
        Observable.of(subject1, subject2)
            .merge()
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        subject1.onNext("C")
        subject1.onNext("o")
        subject2.onNext("o")
        subject2.onNext("o")
        subject1.onNext("c")
        subject2.onNext("i")
        //任何一个响应都会勾起新序列响应
复制代码

1.3 zip

将多达8个源可观测序列组合成一个新的可观测序列，并将从组合的可观测序列中发射出对应索引处每一个源可观测序列的元素

print("*****zip*****")
        let stringSubject = PublishSubject<String>()
        let intSubject = PublishSubject<Int>()

        Observable.zip(stringSubject, intSubject) { stringElement, intElement in
                "\(stringElement) \(intElement)"
            }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        stringSubject.onNext("C")
        stringSubject.onNext("o") // 到这里存储了 C o 可是不会响应除非;另外一个响应

        intSubject.onNext(1) // 勾出一个
        intSubject.onNext(2) // 勾出另外一个
        stringSubject.onNext("i") // 存一个
        intSubject.onNext(3) // 勾出一个
        // 说白了: 只有两个序列同时有值的时候才会响应,不然存值
复制代码

1.4 combineLatest

将8源可观测序列组合成一个新的观测序列,并将开始发出联合观测序列的每一个源的最新元素可观测序列一旦全部排放源序列至少有一个元素,而且当源可观测序列发出的任何一个新元素

print("*****combineLatest*****")
        let stringSub = PublishSubject<String>()
        let intSub = PublishSubject<Int>()
        Observable.combineLatest(stringSub, intSub) { strElement, intElement in
                "\(strElement) \(intElement)"
            }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        stringSub.onNext("L") // 存一个 L
        stringSub.onNext("G") // 存了一个覆盖 - 和zip不同
        intSub.onNext(1)      // 发现strOB也有G 响应 G 1
        intSub.onNext(2)      // 覆盖1 -> 2 发现strOB 有值G 响应 G 2
        stringSub.onNext("AAAAAA") // 覆盖G -> AAAAAA 发现intOB 有值2 响应 AAAAAA 2
        // combineLatest 比较zip 会覆盖
        // 应用很是频繁: 好比帐户和密码同时知足->才能登录. 不关系帐户密码怎么变化的只要查看最后有值就能够 loginEnable
复制代码

1.5 switchLatest

将可观察序列发出的元素转换为可观察序列，并从最近的内部可观察序列发出元素

print("*****switchLatest*****")
        let switchLatestSub1 = BehaviorSubject(value: "L")
        let switchLatestSub2 = BehaviorSubject(value: "1")
        let switchLatestSub  = BehaviorSubject(value: switchLatestSub1)// 选择了 switchLatestSub1 就不会监听 switchLatestSub2
        
        switchLatestSub.asObservable()
            .switchLatest()
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        switchLatestSub1.onNext("G")
        switchLatestSub1.onNext("_")
        switchLatestSub2.onNext("2")
        switchLatestSub2.onNext("3") // 2-3都会不会监听,可是默认保存由 2覆盖1 3覆盖2
        switchLatestSub.onNext(switchLatestSub2) // 切换到 switchLatestSub2
        switchLatestSub1.onNext("*")
        switchLatestSub1.onNext("BBBBBB") // 原理同上面 下面若是再次切换到 switchLatestSub1会打印出 BBBBBB
        switchLatestSub2.onNext("4")
复制代码

2. 映射操做符

2.1 map

转换闭包应用于可观察序列发出的元素，并返回转换后的元素的新可观察序列。

print("*****map*****")
        let ob = Observable.of(1,2,3,4)
        ob.map { (number) -> Int in
            return number+2
            }
            .subscribe{
                print("\($0)")
            }
            .disposed(by: disposeBag)
复制代码

2.2 flatMap: and flatMapLatest:

将可观测序列发射的元素转换为可观测序列，并将两个可观测序列的发射合并为一个可观测序列。
这也颇有用，例如，当你有一个可观察的序列，它自己发出可观察的序列，你想可以对任何一个可观察序列的新发射作出反应(序列中序列:好比网络序列中还有模型序列)
latMap和flatMapLatest的区别是，flatMapLatest只会从最近的内部可观测序列发射元素

print("*****flatMap*****")
        let boy  = LGPlayer(score: 100)
        let girl = LGPlayer(score: 90)
        let player = BehaviorSubject(value: boy)
        
        player.asObservable()
            .flatMap { $0.score.asObservable() } // 自己score就是序列 模型就是序列中的序列
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        boy.score.onNext(60)
        player.onNext(girl)
        boy.score.onNext(50)
        boy.score.onNext(40)//  若是切换到 flatMapLatest 就不会打印
        girl.score.onNext(10)
        girl.score.onNext(0)
        // flatMapLatest其实是map和switchLatest操做符的组合。
复制代码

2.3 scan

从初始就带有一个默认值开始，而后对可观察序列发出的每一个元素应用累加器闭包，并以单个元素可观察序列的形式返回每一个中间结果

print("*****scan*****")
        Observable.of(10, 100, 1000)
            .scan(2) { aggregateValue, newValue in
                aggregateValue + newValue // 10 + 2 , 100 + 10 + 2 , 1000 + 100 + 2
            }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        // 这里主要强调序列值之间的关系
复制代码

3. 过滤条件操做符

3.1 filter

仅从知足指定条件的可观察序列中发出那些元素

print("*****filter*****")
        Observable.of(1,2,3,4,5,6,7,8,9,0)
            .filter { $0 % 2 == 0 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
复制代码

3.2 distinctUntilChanged

抑制可观察序列发出的顺序重复元素

print("*****distinctUntilChanged*****")
        Observable.of("1", "2", "2", "2", "3", "3", "4")
            .distinctUntilChanged()
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
复制代码

3.3 elementAt

仅在可观察序列发出的全部元素的指定索引处发出元素

print("*****elementAt*****")
        Observable.of("A", "B", "C", "D", "E")
            .elementAt(3)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
复制代码

3.4 single

只发出可观察序列发出的第一个元素(或知足条件的第一个元素)。若是可观察序列发出多个元素，将抛出一个错误。

print("*****single*****")
        Observable.of("AAA", "BBB")
            .single()
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        Observable.of("AAA", "BBB")
            .single { $0 == "BBB" }
            .subscribe { print($0) }
            .disposed(by: disposeBag)
复制代码

3.5 take

只从一个可观察序列的开始发出指定数量的元素。上面signal只有一个序列在实际开发会受到局限这里引出 take 想几个就几个

print("*****take*****")
        Observable.of("AAA", "BBB","CCC", "DDD")
            .take(2)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
复制代码

3.6 takeLast

仅从可观察序列的末尾发出指定数量的元素

print("*****takeLast*****")
        Observable.of("AAA", "BBB","CCC", "DDD")
            .takeLast(3)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
复制代码

3.7 takeWhile

只要指定条件的值为true，就从可观察序列的开始发出元素

Observable.of(1, 2, 3, 4, 5, 6)
            .takeWhile { $0 < 3 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
复制代码

3.8 takeUntil

从源可观察序列发出元素，直到参考可观察序列发出元素
这个要重点,应用很是频繁好比我页面销毁了,就不能获取值了(cell重用运用)

print("*****takeUntil*****")
        let sourceSequence = PublishSubject<String>()
        let referenceSequence = PublishSubject<String>()
        
        sourceSequence
            .takeUntil(referenceSequence)
            .subscribe { print($0) }
            .disposed(by: disposeBag)
        
        sourceSequence.onNext("AAA")
        sourceSequence.onNext("BBB")
        sourceSequence.onNext("CCC")

        referenceSequence.onNext("BBB") // 条件一出来,下面就走不了
        
        sourceSequence.onNext("DDD")
        sourceSequence.onNext("EEE")
        sourceSequence.onNext("FFF")
复制代码

3.9 skip

从源可观察序列发出元素，直到参考可观察序列发出元素
这个要重点,应用很是频繁不用解释 textfiled 都会有默认序列产生

print("*****skip*****")
        Observable.of(1, 2, 3, 4, 5, 6)
            .skip(2)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
print("*****skipWhile*****")
        Observable.of(1, 2, 3, 4, 5, 6)
            .skipWhile { $0 < 4 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
复制代码

3.10 skipUntil

抑制从源可观察序列发出元素，直到参考可观察序列发出元素

print("*****skipUntil*****")
        let sourceSeq = PublishSubject<String>()
        let referenceSeq = PublishSubject<String>()
        
        sourceSeq
            .skipUntil(referenceSeq)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
        
        // 没有条件命令 下面走不了
        sourceSeq.onNext("AAA")
        sourceSeq.onNext("BBB")
        sourceSeq.onNext("CCC")
        
        referenceSeq.onNext("BBB") // 条件一出来,下面就能够走了
        
        sourceSeq.onNext("DDD")
        sourceSeq.onNext("EEE")
        sourceSeq.onNext("FFF")
复制代码