RxSwift之常用的高阶函数

Posted 2021-09-04 Forever_wj

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了RxSwift之常用的高阶函数相关的知识，希望对你有一定的参考价值。

一、组合操作符

① startWith

startWith 方法会在 Observable 序列开始之前插入一些事件元素，即发出事件消息之前，会先发出这些预先插入的事件消息。如下所示：

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

插入多个数据，如下所示：

    Observable.of("2", "3", "4")
        .startWith("1")
        .startWith("0")
        .startWith("B")
        .startWith("A")
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
        
	// 输出结果
	A
	B
	0
	1
	2
	3
	4

② merge

将将多个（两个或两个以上的）Observable 序列合并成一个 Observable 序列，并将像每个源可观察序列发出元素一样发出每个元素。

    let subject1 = PublishSubject<String>()
    let subject2 = PublishSubject<String>()
    Observable.of(subject1, subject2)
        .merge()
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)

    subject1.onNext("s")
    subject1.onNext("w")
    subject2.onNext("i")
    subject2.onNext("f")
    subject1.onNext("t")

	// 输出结果
	s
	w
	i
	f
	t

③ zip

zip 方法可以将多个（两个或两个以上的）Observable 序列压缩成一个 Observable 序列，而且它会等到每个 Observable 事件一一对应地凑齐之后再合并。
可以将多达 8 个源可观测序列组合成一个新的可观测序列，并将从组合的可观测序列中发射出对应索引处每个源可观测序列的元素。

    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("Y")
    stringSubject.onNext("D")

    intSubject.onNext(1)
    intSubject.onNext(2)
    stringSubject.onNext("W")
    intSubject.onNext(3)
    
    // 输出结果
    Y 1
	D 2
	W 3

只有两个序列同时有值的时候才会响应，否则存值。

④ combineLatest

combineLatest 是将多个（两个或两个以上的）Observable 序列元素进行合并。
但与 zip 不同的是，每当任意一个 Observable 有新的事件发出时，它会将每个 Observable 序列的最新的一个事件元素进行合并。
combineLatest 可以将 8 源可观测序列组合成一个新的观测序列，并将开始发出联合观测序列的每个源的最新元素可观测序列，一旦所有排放源序列至少有一个元素，并且当源可观测序列发出的任何一个新元素。

    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("D")     // 存一个 D
    stringSub.onNext("W")     // 存了一个覆盖 - 和zip不一样
    intSub.onNext(1)          // 发现 strOB 也有 W 响应 W 1
    intSub.onNext(2)          // 覆盖1 -> 2 发现 strOB 有值W 响应 W 2
    stringSub.onNext("Y")     // 覆盖W -> Y 发现 intOB 有值2 响应 Y 2
    
	// 输出结果
	W 1
	W 2
	Y 2

⑤ switchLatest

将可观察序列发出的元素转换为可观察序列，并从最近的内部可观察序列发出元素。
switchLatest 方法可以将两个 Observable 序列合并为一个，每当 self 队列发射一个元素时，便从第二个序列中取出最新的一个值。

	let switchLatestSub1 = BehaviorSubject(value: "Y")
    let switchLatestSub2 = BehaviorSubject(value: "1")
    let switchLatestSub  = BehaviorSubject(value: switchLatestSub1)// 选择了 switchLatestSub1 就不会监听 switchLatestSub2

    switchLatestSub.asObservable()
        .switchLatest()
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)

    switchLatestSub1.onNext("D")
    switchLatestSub1.onNext("_")
    switchLatestSub2.onNext("2")
    switchLatestSub2.onNext("3") // 2-3都会不会监听,但是默认保存由 2覆盖1 3覆盖2
    switchLatestSub.onNext(switchLatestSub2) // 切换到 switchLatestSub2
    switchLatestSub1.onNext("*")
    switchLatestSub1.onNext("W") // 原理同上面 下面如果再次切换到 switchLatestSub1 会打印出 YDW
    switchLatestSub2.onNext("4")

	// 输出结果
	Y
	D
	_
	3
	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 必须两个序列都响应才会响应最终的结果。

二、映射操作符

① map

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

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

	// 输出结果
	next(3)
	next(4)
	next(5)
	next(6)
	completed

② flatMap and flatMapLatest

将可观测序列发射的元素转换为可观测序列，并将两个可观测序列的发射合并为一个可观测序列。
例如，当有一个可观察的序列，它本身发出可观察的序列，想能够对任何一个可观察序列的新发射做出反应(序列中序列：比如网络序列中还有模型序列)。
flatMap 和 flatMapLatest 的区别是，flatMapLatest 只会从最近的内部可观测序列发射元素。
flatMapLatest 实际上是 map 和 switchLatest 操作符的组合。

	let boy  = YDWPlayer(score: 100)
	let girl = YDWPlayer(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)

③ 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)来发送信号，发送信号之前 let mappedElement = try self._transform(element) 取出要发送的结果，就是经过映射表达式处理的结果；
- self.forwardOn(.next(mappedElement)) 正常发送。

三、过滤条件操作符

① filter

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

	Observable.of(1,2,3,4,5,6,7,8,9,0)
	    .filter { $0 % 2 == 0 }
	    .subscribe(onNext: { print($0) })
	    .disposed(by: disposeBag)
	    
	// 输出结果
	2
	4
	6
	8
	0

② distinctUntilChanged

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

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

③ elementAt

仅在可观察序列发出的所有元素的指定索引处发出元素：

	Observable.of("Y", "D", "W", "N", "B")
    	.elementAt(3)
	    .subscribe(onNext: { print($0) })
    	.disposed(by: disposeBag)
    	
    	// 输出结果
    	N

④ single

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

	Observable.of("D", "W")
	    .single()
	    .subscribe(onNext: { print($0) })
	    .disposed(by: disposeBag)
	
	Observable.of("D", "W")
	    .single { $0 == "W" }
	    .subscribe { print($0) }
	    .disposed(by: disposeBag)

	// 输出结果
	D
	Unhandled error happened: Sequence contains more than one element.
 subscription called from:

	next(W)
	completed

⑤ take

只从一个可观察序列的开始发出指定数量的元素。 signal 只有一个序列，在实际开发会受到局限，这里引出 take 可以不受限制。

	Observable.of("A", "B","C", "D")
    	.take(2)
	    .subscribe(onNext: { print($0) })
    	.disposed(by: disposeBag)
    
    // 输出结果
    A
    B

⑥ takeLast

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

	Observable.of("A", "B","C", "D")
	    .takeLast(3)
	    .subscribe(onNext: { print($0) })
	    .disposed(by: disposeBag)
	    
	    // 输出结果
    	B
    	C
    	D

⑦ takeWhile

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

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

⑧ takeUntil

从源可观察序列发出元素，直到参考可观察序列发出元素。takeUntil 应用非常频繁比如页面销毁，就不能获取值(cell 重用运用)。

	let sourceSequence = PublishSubject<String>()
	let referenceSequence = PublishSubject<String>()
	
	sourceSequence
	    .takeUntil(referenceSequence)
	    .subscribe { print($0) }
	    .disposed(by: disposeBag)
	
	sourceSequence.onNext("A")
	sourceSequence.onNext("B")
	sourceSequence.onNext("C")
	
	referenceSequence.onNext("D") // 条件一出来,下面就不执行
	
	sourceSequence.onNext("E")
	sourceSequence.onNext("F")
	sourceSequence.onNext("G")

	// 输出结果
	next(A)
	next(B)
	next(C)
	completed

⑨ skip

从源可观察序列发出元素，直到参考可观察序列发出元素。skip 应用非常频繁，不用解释 textfiled 都会有默认序列产生。

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

	// 输出结果
	3
	4
	5
	6

	4
	5
	6

⑩ skipUntil

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

	let sourceSeq = PublishSubject<String>()
    let referenceSeq = PublishSubject<String>()

    sourceSeq
        .skipUntil(referenceSeq)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)

    // 没有条件命令 下面不执行
    sourceSeq.onNext("A")
    sourceSeq.onNext("B")
    sourceSeq.onNext("C")

    referenceSeq.onNext("D") // 条件一出来,下面就可以执行

    sourceSeq.onNext("E")
    sourceSeq.onNext("F")
    sourceSeq.onNext("G")
    
	// 输出结果
	E
	F
	G

四、集合控制操作符

① toArray

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

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

	// 输出结果
	success([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

② reduce

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

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

	// 输出结果
	1111

③ concat

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

	let subject1 = BehaviorSubject(value: "Y")
	let subject2 = BehaviorSubject(value: "1")
	
	let subjectsSubject = BehaviorSubject(value: subject1)
	
	subjectsSubject.asObservable()
	    .concat()
	    .subscribe { print($0) }
	    .disposed(by: disposeBag)
	
	subject1.onNext("D")
	subject1.onNext("W")
	
	subjectsSubject.onNext以上是关于RxSwift之常用的高阶函数的主要内容，如果未能解决你的问题，请参考以下文章 
 RxSwift高阶函数merge解读
 Scala语言之高阶函数
 kotlin学习之高阶函数及常用基本高阶函数
 python之高阶函数
 MySQL数据库高阶语句之函数存储
 JavaScript之手撕常用数组高阶函数