就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！

• RxSwift（1）—— 初探
• RxSwift（2）—— 核心逻辑源码分析
• RxSwift（3）—— Observable序列的创建方式
• RxSwift（4）—— 高阶函数（上）
• RxSwift（5）—— 高阶函数（下）
• RxSwift（6）—— scheduler源码解析（上）
• RxSwift（7）—— scheduler源码解析（下）
• RxSwift（8）—— KVO底层探索（上）
• RxSwift（9）—— KVO底层探索（下）
• RxSwift（10）—— 场景序列总结
• RxSwift（11）—— 销毁者-dispose源码解析
• RxSwift（12）—— Subject即攻也守
• RxSwift（13）—— 爬过的坑
• RxSwift（14）—— MVVM双向绑定

RxSwift目录直通车--- 和谐学习，不急不躁！

因为RxSwift，我们游刃在函数响应式的世界里！如果你想玩得更爽，那么这一篇RxSwift-高阶函数对你来说是必须要掌握的内容！只有你玩好了高阶函数才能在实际开发中真正地享受：万物皆Rx

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")
// Cooci - 任何一个响应都会勾起新序列响应

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("Cooci") // 覆盖G -> Cooci 发现intOB 有值2 响应 Cooci 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("Cooci") // 原理同上面 下面如果再次切换到 switchLatestSub1会打印出 Cooci
switchLatestSub2.onNext("4")

• 上面组合操作符大部分都比较简单，原理也比较相似，这里我们挑出combineLatest底层原理来分析
• 初始化中self._arity = arity这就是我们此次管理的序列个数
• 初始化中self._hasValue就是一个初始化的个数为arity的，里面的值都是false,只有为什么这么初始化后面会讲的！
• 核心逻辑next(_ index: Int)方法中，判断self._hasValue[index]就是我们的刚刚初始化的集合，第一次进来就是第一个序列，进来就会标记true,并且_numberOfValues+1，此时就是0->1
• 继续往下面走，发现_numberOfValues < arity就会跳过
• 如果下次还是第一个序列进来，第一层判断就通不过，后面还是跳过
• 如果下次进来的是第二个序列，那么第一层判断就会进去，进来就会标记true,并且_numberOfValues+1，此时就是1->2
• 第二层判断也满足条件self._numberOfValues == self._arity,取回let result = try self.getResult()响应结果，然后就发送出去：self.forwardOn(.next(result))
• 综合得出combineLatest 必须两个序列都响应才会响应最终的结果
• 当然还有多个序列组合的，原理也是一样的！大家自行探索

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

• 将可观测序列发射的元素转换为可观测序列，并将两个可观测序列的发射合并为一个可观测序列。
• 这也很有用，例如，当你有一个可观察的序列，它本身发出可观察的序列，你想能够对任何一个可观察序列的新发射做出反应(序列中序列:比如网络序列中还有模型序列)
• flatMap和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)
// 这里主要强调序列值之间的关系

• 映射型高阶函数，我们拿map来进行分析
• 通过composeMap创建中间序列：Map
• 初始化中 self._source = source & self._transform = transform 保存源序列和外界传进去的映射表达式：$0+2
• MapSink调用on(_ event: Event<SourceType>)来发送信号，发送信号之前let mappedElement = try self._transform(element)取出要发送的结果，就是经过映射表达式处理的结果
• self.forwardOn(.next(mappedElement))正常发送

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("C", "o", "o", "c", "i")
    .elementAt(3)
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

3.4：single

• 只发出可观察序列发出的第一个元素(或满足条件的第一个元素)。如果可观察序列发出多个元素，将抛出一个错误。

print("*****single*****")
Observable.of("Cooci", "Kody")
    .single()
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

Observable.of("Cooci", "Kody")
    .single { $0 == "Kody" }
    .subscribe { print($0) }
    .disposed(by: disposeBag)

3.5：take

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

print("*****take*****")
Observable.of("Hank", "Kody","Cooci", "CC")
    .take(2)
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

3.6：takeLast

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

print("*****takeLast*****")
Observable.of("Hank", "Kody","Cooci", "CC")
    .takeLast(3)
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

3.7：takeWhile

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

print("*****takeWhile*****")
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("Cooci")
sourceSequence.onNext("Kody")
sourceSequence.onNext("CC")

referenceSequence.onNext("Hank") // 条件一出来,下面就走不了

sourceSequence.onNext("Lina")
sourceSequence.onNext("小雁子")
sourceSequence.onNext("婷婷")

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("Cooci")
sourceSeq.onNext("Kody")
sourceSeq.onNext("CC")

referenceSeq.onNext("Hank") // 条件一出来,下面就可以走了

sourceSeq.onNext("Lina")
sourceSeq.onNext("小雁子")
sourceSeq.onNext("婷婷")

4：集合控制操作符

4.1：toArray

• 将一个可观察序列转换为一个数组，将该数组作为一个新的单元素可观察序列发出，然后终止

print("*****toArray*****")
Observable.range(start: 1, count: 10)
    .toArray()
    .subscribe { print($0) }
    .disposed(by: disposeBag)

4.2：reduce

• 从一个设置的初始化值开始，然后对一个可观察序列发出的所有元素应用累加器闭包，并以单个元素可观察序列的形式返回聚合结果 - 类似scan

print("*****reduce*****")
Observable.of(10, 100, 1000)
    .reduce(1, accumulator: +) // 1 + 10 + 100 + 1000 = 1111
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

4.3：concat

• 以顺序方式连接来自一个可观察序列的内部可观察序列的元素，在从下一个序列发出元素之前，等待每个序列成功终止

print("*****concat*****")
let subject1 = BehaviorSubject(value: "Hank")
let subject2 = BehaviorSubject(value: "1")

let subjectsSubject = BehaviorSubject(value: subject1)

subjectsSubject.asObservable()
    .concat()
    .subscribe { print($0) }
    .disposed(by: disposeBag)

subject1.onNext("Cooci")
subject1.onNext("Kody")

subjectsSubject.onNext(subject2)

subject2.onNext("打印不出来")
subject2.onNext("2")

subject1.onCompleted() // 必须要等subject1 完成了才能订阅到! 用来控制顺序 网络数据的异步
subject2.onNext("3")

由于篇幅原因，这篇博客先写到这里，高阶函数的用法还是有点意思的！如果你是一个RxSwift新手，还是非常建议大家耐着性子好好练习，对你的开发绝对有帮助
请继续观看下一篇博客 RxSwift-高阶函数（下）

就问此时此刻还有谁？45度仰望天空，该死！我这无处安放的魅力！