RxSwift（4）— 高阶函数（上

时间  2019-11-07
标签 rxswift 高阶 函数 繁體版
原文   原文链接

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

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度仰望天空，该死！我这无处安放的魅力！app

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程