(八)RxSwift之组合操作符（combination）

组合多个被观察者Observable,合并需要发送的事件。

操作符	描述
startWith	在序列的头部插入一些元素
merge	将几个源序列合并成一个，响应每个事件
concat	第一个终止后，才会接收第二个，控制顺序
zip	将源序列组合到一起，以组合的形式发出（存值）
combineLatest	将源序列组合到一起，以组合的形式发出（覆盖）
switchLatest	只响应最近的源序列
withLatestFrom	每次都取第二个序列最新的
toArray	转换为一个数组，将该数组作为一个新的单元素可观察序列发出，然后终止
reduce	设置的初始化值开始，然后对可观察序列发出的所有元素应用累积器闭包，并以单个元素可观察序列的形式返回聚合结果 - 类似scan

• startWith

将一些元素插入到序列的头部

示例：

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

• merge

将多个 Observables 合并成一个

示例：

let subject1 = PublishSubject<String>()
let subject2 = PublishSubject<String>()
// merge subject1 和 subject2
Observable.of(subject1, subject2)
    .merge()
    .subscribe(onNext: { print($0, terminator: "") })
    .disposed(by: disposeBag)
subject1.onNext("M")
subject1.onNext("a")
subject2.onNext("X")
subject2.onNext("i")
subject1.onNext("a")
subject1.onNext("o")
subject1.onNext("l")
subject2.onNext("i")
subject2.onNext("a")
subject2.onNext("o")
//输出：MaXiaoliao 
//任何一个响应都会勾起新序列响应

• concat

让两个或多个 Observables 按顺序串连起来，第一个终止后，才接收第二个。

let subject1 = BehaviorSubject(value: "Maxiaoliao")
let subject2 = BehaviorSubject(value: "1")

let subjectSubject = BehaviorSubject(value: subject1)

subjectSubject.asObservable()
    .concat()
    .subscribe{ print($0, terminator: " ") }
    .disposed(by: disposeBag)

subject1.onNext("apple")
subject1.onNext("banana")
subjectSubject.onNext(subject2)

subject2.onNext("打印不出来")
subject2.onNext("打印不出来_2")
subject2.onNext("3")
subject2.onNext("4")

subject1.onCompleted()// 必须要等subject1 完成了才能订阅到! 用来控制顺序 网络数据的异步
subject2.onNext("5")
//输出：next(Maxiaoliao) next(apple) next(banana) next(4) next(5)

• zip

将多达8个源可观测序列组合成一个新的可观察序列，然后将每一个组合的结果发出来

示例：

let stringSubject = PublishSubject<String>()
let intSubject = PublishSubject<Int>()

Observable.zip(stringSubject, intSubject) { stringSubject, intSubject in
    "\(stringSubject) - \(intSubject)"
    }
.subscribe(onNext: {print($0, terminator: " ")})
    .disposed(by: disposeBag)
stringSubject.onNext("L") //存一个
stringSubject.onNext("i") //存一个
intSubject.onNext(1) // 勾出一个
intSubject.onNext(2) // 勾出另一个
stringSubject.onNext("a") // 存一个
stringSubject.onNext("o") // 存一个
intSubject.onNext(3) // 勾出一个
//输出 ：L - 1 i - 2 a - 3
//只有两个序列同时有值的时候才会响应,否则存值

• combineLatest

将多达8个源可观察序列组合成一个新的观察序列,并将开始发出联合观察序列的每个源的最新 元素可观察序列一旦所有排放源序列至少有一个元素,并且当源可观测序列发出的任何一个新元素

示例：

let stringSub = PublishSubject<String>()
let intSub = PublishSubject<Int>()
Observable.combineLatest(stringSub, intSub) {strElement, intElement in
    "\(strElement) - \(intElement)"
    }
    .subscribe(onNext: {print($0, terminator:" ")})
    .disposed(by: disposeBag)
stringSub.onNext("M") //存一个 M
stringSub.onNext("a") //覆盖 M 寸a
intSub.onNext(1)// stringSub有a值 响应 a - 1
intSub.onNext(2)// stringSub有a值 响应 a - 2
stringSub.onNext("MaXiaoLiao") //MaXiaoLiao - 2
intSub.onNext(3)//MaXiaoLiao - 3

//输出：a - 1 a - 2 MaXiaoLiao - 2 MaXiaoLiao - 3
//应用非常频繁: 比如账户和密码同时满足->才能登陆. 不关系账户密码怎么变化的只要查看最后有值就可以 loginEnable

combineLatest和zip比较相似，zip存值 combineLatest覆盖

• switchLatest

将可观察序列发出的元素转换为可观察序列，只接收最新的observe发出的序列。

let switchLasestSub1 = BehaviorSubject(value: "M")
let switchLatestSub2 = BehaviorSubject(value: "1")
let switchLatestSub  = BehaviorSubject(value: switchLasestSub1)//选择了switchLatestSub1 就不会监听 switchLatestSub2
switchLatestSub.asObserver()
    .switchLatest()
    .subscribe(onNext: {print($0, terminator: " ")})
    .disposed(by: disposeBag)

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

//输出：M X - 3 4

• withLatestFrom

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

示例：

let withLatestSub1 = BehaviorSubject(value: "M")
let withLatestSub2 = BehaviorSubject(value: "1")

withLatestSub1
    .withLatestFrom(withLatestSub2)
    .subscribe(onNext: {print($0, terminator: " ")})
    .disposed(by: disposeBag)

withLatestSub1.onNext("X")
withLatestSub1.onNext("-")
withLatestSub2.onNext("2")
withLatestSub2.onNext("3")
withLatestSub1.onNext("*")
withLatestSub1.onNext("Maxiaoliao")
withLatestSub2.onNext("4")

//输出：1 1 1 3 3  每次都发出withLatestSub2的最后一个

• 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