RxSwift学习--高阶函数 / 操作符（上）

作者: Henry_Jeannie | 来源:发表于2019-08-14 16:39 被阅读0次

前言

在RxSwift中，高阶函数也可以成为操作符，高阶函数可以帮助我们创建新的序列，或者变化组合原有的序列，从而生成一个新的序列。

转换操作符

1. map

map操作符会通过传入一个函数闭包把原来的 Observable 序列转变为一个新的 Observable 序列,map函数会将源序列的所有元素进行转换，返回一个新序列.

例子：

    let disposeBag = DisposeBag()
 
    Observable.of(1, 2, 3)
        .map { $0 * 100}
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
    
    //结果：
    100
    200
    300

2. flatMap

map在做转换的时候容易出现“升维”的情况。即转变之后，从一个序列变成了一个序列的序列。而flatMap 操作符会对源Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。然后将这些 Observables 的元素合并之后再发送出来。即又将其降维成一个 Observable 序列。

这个操作符是非常有用的。比如当 Observable 的元素本身就拥有其他的 Observable 时，我们可以将所有子 Observables 的元素发送出来。

例子：

    let disposeBag = DisposeBag()
    let Henry = BehaviorSubject(value: 1)
    let Jeannie = BehaviorSubject(value: 2)
    let Henry_Subject = BehaviorSubject(value: Henry)

    Henry_Subject.asObservable()
          .flatMap { $0 }
          .subscribe(onNext: { print($0) })
          .disposed(by: disposeBag)
    Henry.onNext(3)
    Henry_Subject.onNext(Jeannie)
    Henry.onNext(5)
    Jeannie.onNext(6)
    
    //结果
    1
    3
    2
    5
    6

3. flatMapLatest

flatMapLatest操作符会将Observable 的元素转换成其他的 Observable，然后取这些 Observables 中最新的一个。

flatMapLatest操作符将源Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。一旦转换出一个新的 Observable，就只发出它的元素，旧的 Observables 的元素将被忽略掉。

flatMapLatest与 flatMap 的唯一区别是：flatMapLatest 只会接收最新的 value 事件。
flatMapLatest实际上是map和switchLatest操作符的组合
有flatMapLatest就会有flatMapFirst，flatMapFirst与 flatMapLatest正好相反：flatMapFirst 只会接收最初的 value 事件。（该操作符可以防止重复请求：
比如点击一个按钮发送一个请求，当该请求完成前，该按钮点击都不应该继续发送请求。便可该使用 flatMapFirst 操作符。）

例子：

    let disposeBag = DisposeBag()
    let Henry = BehaviorSubject(value: 1)
    let Jeannie = BehaviorSubject(value: 2)
    let Henry_Subject = BehaviorSubject(value: Henry)
        
    Henry_Subject.asObservable()
        .flatMapLatest{ $0 }
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
        
    Henry.onNext(3)
    Henry_Subject.onNext(Jeannie)
    Jeannie.onNext(5)
    Henry.onNext(6)
    
    
    //结果：
    1
    3
    2
    5

4. concatMap

concatMap操作符会将 Observable的元素转换成其他的 Observable，然后将这些 Observables串连起来

concatMap操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。然后让这些Observables 按顺序的发出元素.

concatMap 与flatMap 的唯一区别是：当前一个 Observable 元素发送完毕后，后一个 Observable 才可以开始发出元素。等待前一个Observable 产生完成事件后，才对后一个 Observable 进行订阅。

例子：

    let disposeBag = DisposeBag()
    let Henry = BehaviorSubject(value: 1)
    let Jeannie = BehaviorSubject(value: 2)
    let Henry_Subject = BehaviorSubject(value: Henry)
        
    Henry_Subject.asObservable()
        .concatMap{ $0 }
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
        
    Henry.onNext(3)
    Henry_Subject.onNext(Jeannie)
    Jeannie.onNext(5)
    Jeannie.onNext(6)
    Henry.onCompleted()
    
    //结果：
    1
    3
    6

5. scan

scan操作符会持续的将Observable ，然后发出每一次函数返回的结果

scan 操作符将对第一个元素应用一个函数，将结果作为第一个元素发出。然后，将结果作为参数填入到第二个元素的应用函数中，创建第二个元素。以此类推，直到遍历完全部的元素。也就是scan 先给一个初始化的数，然后不断的拿前一个结果和最新的值进行处理操作。

例子：

    let disposeBag = DisposeBag()

    Observable.of(1, 2, 3, 4, 5)
        .scan(0) { acum, elem in
        acum + elem
    }
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)

    //结果
    1
    3
    6
    10
    15

6. reduce

reduce操作符和scan操作符还是有点类似的，reduce 操作符将对第一个元素应用一个函数。然后，将结果作为参数填入到第二个元素的应用函数中。以此类推，直到遍历完全部的元素后发出最终结果。

例子：

    let disposeBag = DisposeBag()

    Observable.of(10, 20, 30)
        .reduce(0, accumulator: +)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
        
    //结果：
    60

7.toArray

toArray操作符先把一个序列转成一个数组，并作为一个单一的事件发送，然后结束。

例子：

    let disposeBag = DisposeBag()
 
    Observable.of(1, 2, 3)
        .toArray()
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
    //结果：
    [1,2,3]

组合操作符

1. merge

merge操作符会将多个Observables 合并成一个Observable.
通过使用 merge 操作符可以将多个 Observables 合并成一个，当某一个 Observable 发出一个元素时，它就将这个元素发出。

image
如果，其中某一个 Observable 发出一个 onError 事件，那么被合并的这个Observable 也会将这个onError 事件发出，并且立即终止序列。

值得注意的是这里被合并的序列元素必须是同类型的。

例子：

    let disposeBag = DisposeBag()
        
    let Henry = PublishSubject<Int>()
    let Jeannie = PublishSubject<Int>()
        
    Observable.of(Henry, Jeannie)
        .merge()
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
        
    Henry.onNext(1)
    Henry.onNext(2)
    Jeannie.onNext(100)
    Henry.onNext(3)
    Henry.onNext(4)
    Jeannie.onNext(1000)
    
    //结果：
    1
    2
    100
    3
    4
    1000

2. startWith

startWith操作符会在 Observable 头部插入一些事件元素。即发出Observable的事件元素之前，会先发出这些预先插入的事件元素。

如果在Observable头部分多次插入事件元素，那么这些事件元素会一直在Observable头部追加，也就是后插入的先发出来。

例子：

    let disposeBag = DisposeBag()
        
    Observable.of("1", "2")
        .startWith("A")
        .startWith("B")
        .startWith("a", "b")
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
    
    //结果：
    a
    b
    B
    A
    1
    2

3. zip

zip操作符可将多个 Observables 的元素组合压缩，而且它会等到每个Observable 元素事件一一对应地凑齐之后再合并，然后将每一个组合的结果元素发出来。

zip操作符最多可以将8个Observables 的元素通过一个函数组合起来，然后将这个组合的结果发出来。它会严格的按照序列的索引数进行组合。例如，返回的 Observable的第一个元素，是由每一个源 Observables 的第一个元素组合出来的。它的第二个元素，是由每一个源 Observables 的第二个元素组合出来的。它的第三个元素，是由每一个源 Observables 的第三个元素组合出来的，以此类推。它的元素数量等于源 Observables中元素数量最少的那个。

例子：

    let disposeBag = DisposeBag()
    let Henry = PublishSubject<String>()
    let Jeannie = PublishSubject<String>()
        
    Observable.zip(Henry, Jeannie) { $0 + $1 }
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
    
    Henry.onNext("1")
    Jeannie.onNext("A")
    Henry.onNext("2")
    Jeannie.onNext("B")
    Jeannie.onNext("C")
    Henry.onNext("3")
    Henry.onNext("4")
    
    //结果：
    1A
    2B
    3C

zip操作符常常用在整合网络请求上。
比如我们想同时发送两个请求，只有当两个请求都成功后，再将两者的结果整合起来继续往下处理。这个功能就可以通过 zip 来实现。

4. combineLatest

combineLatest操作符同样是将多个Observables 序列元素进行合并。但与zip不同的是，每当任意一个 Observable有新的事件发出时，它会将每个Observable 序列的最新的一个事件元素进行合并,然后发送这个组合出来的元素。（前提是，这些 Observables 曾经发出过元素）。

例子：

    let disposeBag = DisposeBag()
    let Henry = PublishSubject<String>()
    let Jeannie = PublishSubject<String>()
    
    Observable.combineLatest(Henry, Jeannie) { $0 + $1 }
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
    
    Henry.onNext("1")
    Jeannie.onNext("A")
    Henry.onNext("2")
    Jeannie.onNext("B")
    Jeannie.onNext("C")
    Henry.onNext("3")
    Henry.onNext("4")
    
    //结果：
    1A
    2A
    2B
    2C
    3C
    4C

5. concat

concat 操作符将多个 Observables 按顺序串联起来，并且只有当前面一个 Observable 序列发出了 completed 事件，才会开始发送下一个 Observable序列事件。

例子：

    let disposeBag = DisposeBag()
    let Henry = BehaviorSubject(value: 1)
    let Jeannie = BehaviorSubject(value: 2)
    let Henry_Subject = BehaviorSubject(value: Henry)
        
    Henry_Subject.asObservable()
        .concat()
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
        
    Henry.onNext(3)
    Henry_Subject.onNext(Jeannie)
    Jeannie.onNext(5)
    Jeannie.onNext(6)
    Henry.onCompleted()
    Jeannie.onNext(7)
    
    //结果：
    1
    3
    6
    7

感觉concat操作符和concatMap操作符比较相似，它们都是要等到前面一个 Observable 序列发出了 completed 事件，才会开始发送下一个 Observable序列事件。

6. withLatestFrom

withLatestFrom操作符会将两个 Observables 最新的元素通过一个函数组合起来，当第一个 Observable 发出一个元素，就将组合后的元素发送出来。

例子：

    let disposeBag = DisposeBag()
    let firstSubject = PublishSubject<String>()
    let secondSubject = PublishSubject<String>()

    firstSubject
         .withLatestFrom(secondSubject) {
              (first, second) in
              return first + second
         }
         .subscribe(onNext: { print($0) })
         .disposed(by: disposeBag)

    firstSubject.onNext("A️")
    secondSubject.onNext("1")
    firstSubject.onNext("B")
    
    //结果：
    B1

过滤条件操作符

1. filter

filter操作符就是用来过滤掉某些不符合要求的事件，仅仅发出Observable中通过判定的元素。

例子：

    let disposeBag = DisposeBag()

    Observable.of(11, 22, 3, 8, 2, 1)
          .filter { $0 > 10 }
          .subscribe(onNext: { print($0) })
          .disposed(by: disposeBag)
    
    //结果：
    11
    22

2. take

take操作符仅仅从 Observable中发出头n 个元素，在满足数量之后会自动发送 .completed事件。

例子：

    let disposeBag = DisposeBag()

    Observable.of(1, 2, 3, 4, 5, 6)
        .take(3)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
    
    //结果：
    1
    2
    3

3. takeLast

takeLast操作符与take操作符类似，实现仅发送 Observable 序列中的后n个元素，忽略前面的元素。

例子：

let disposeBag = DisposeBag()

    Observable.of(1, 2, 3, 4, 5, 6)
        .takeLast(3)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
    
    //结果：
    4
    5
    6

4. takeWhile

takeWhile操作符会依次判断 Observable 序列的每一个值是否满足给定的条件。当第一个不满足条件的值出现时，它便自动完成。

例子：

   let disposeBag = DisposeBag()
 
   Observable.of(2, 3, 4, 5, 6)
       .takeWhile { $0 < 4 }
       .subscribe(onNext: { print($0) })
       .disposed(by: disposeBag)
       
    //结果：
    2
    3

5. takeUntil

takeUntil操作符会忽略掉在第二个Observable 产生事件后发出的那部分元素。也就是，takeUntil 操作符会观测源Observable，它同时观测第二个 Observable。一旦第二个 Observable 发出一个元素或者产生一个终止事件，那么源Observable 将自动完成，停止发送事件。

例子：

    let disposeBag = DisposeBag()
        
    let Henry = PublishSubject<String>()
    let Jeannie = PublishSubject<String>()
        
    Henry
        .takeUntil(Jeannie)
        .subscribe { print($0) }
        .disposed(by: disposeBag)
        
    Henry.onNext("Good")
    Henry.onNext("Lucky")
    Jeannie.onNext("Bug")
    Henry.onNext("Tnanks")
    Henry.onNext("a lot")
    
    //结果：
    next(Good)
    next(Lucky)
    completed

6. skip

skip操作符用于跳过源 Observable序列发出的前n 个元素事件。

例子：

    let disposeBag = DisposeBag()
 
    Observable.of(1, 2, 3, 4)
        .skip(2)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
        
    //结果：
    3
    4

7. skipWhile

skipWhile 操作符可以让你忽略源 Observable 中头几个满足条件的事件。

例子：

    let disposeBag = DisposeBag()
 
    Observable.of(2, 3, 4, 5, 6)
        .skipWhile { $0 < 5 }
        .subscribe(onNext: { print($0) })
         .disposed(by: disposeBag)
   
   //结果：
   5
   6

8. skipUntil

同上面的 takeUntil类似，skipUntil 除了订阅源 Observable外，通过 skipUntil 方法我们还可以监视另外一个 Observable。skipUntil操作符会跳过Observable 中头几个元素，直到另一个 Observable发出一个元素。

例子：

    let disposeBag = DisposeBag()
        
    let Henry = PublishSubject<Int>()
    let Jeannie = PublishSubject<Int>()
        
    Henry
        .skipUntil(Jeannie)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
        
    Henry.onNext(1)
    Henry.onNext(2)
    //开始接收消息
    Jeannie.onNext(0)
    Henry.onNext(3)
    Henry.onNext(4)
    //仍然接收消息
    Jeannie.onNext(0)
    Henry.onNext(5)
    
    //结果：
    3
    4
    5

9. elementAt

elementAt操作符只发出 Observable 中的第 n 个元素，即是只处理指定位置的元素事件

例子：

    let disposeBag = DisposeBag()

    Observable.of(1, 2, 3, 4)
        .elementAt(2)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
        
    //结果：
    3

10. distinctUntilChanged

distinctUntilChanged操作符用于过滤掉连续重复的事件。如果后一个元素和前一个元素是相同的，那么这个元素将不会被发出来。如果后一个元素和前一个元素不相同，那么这个元素才会被发出来。

例子：

    let disposeBag = DisposeBag()
 
    Observable.of(1, 2, 1, 1, 1, 3)
        .distinctUntilChanged()
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
    
    //结果
    1
    2
    1
    3

11.amb

amb操作符在多个源 Observables中，取第一个发出元素或产生事件的 Observable，这个事件可以是一个 next，error 或者 completed事件，然后就只发出这个Observable的元素事件，忽略掉其他的Observables。

例子：

    let disposeBag = DisposeBag()
 
    let subject1 = PublishSubject<Int>()
    let subject2 = PublishSubject<Int>()
    let subject3 = PublishSubject<Int>()
 
    subject1
        .amb(subject2)
        .amb(subject3)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
 
    subject2.onNext(1)
    subject1.onNext(20)
    subject2.onNext(2)
    subject1.onNext(40)
    subject3.onNext(0)
    subject2.onNext(3)
    subject1.onNext(60)
    subject3.onNext(0)
    subject3.onNext(0)
    
    //结果：
    1
    2
    3

总结

关于RxSwift的高阶函数先总结这么一部分。其实通过这些简单的示例来看，这些操作符在我们对序列进行操作的时候会有很大的帮助，而且使用简单。学好RxSwift,走遍天下都不怕。

感谢RxSwift中文文档

RxSwift学习--高阶函数 / 操作符（上）

前言

转换操作符

1. map

2. flatMap

3. flatMapLatest

4. concatMap

5. scan

6. reduce

7.toArray

组合操作符

1. merge

2. startWith

3. zip

4. combineLatest

5. concat

6. withLatestFrom

过滤条件操作符

1. filter

2. take

3. takeLast

4. takeWhile

5. takeUntil

6. skip

7. skipWhile

8. skipUntil

9. elementAt

10. distinctUntilChanged

11.amb

总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Swift