08.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")
複製代碼