前言
- Swift进阶之RxSwift（一）
- Demo地址，个人水平有限，如有问题，欢迎指出！！
- 本篇主要介绍RxSwift中Observable的一些进阶用法，需要掌握上篇中的基础知识。
步入正题
1.Combination Operators 组合操作
-
startWith
顾名思义，就是在一个订阅者订阅信号之前先“接收”一个信号！
/// 我们用subject来玩这个功能
let disposeBag = DisposeBag()
let subject = PublishSubject<String>()
/// 订阅信号之前先接收到first信号
subject.startWith("first")
.subscribe { (event) in
print(event.element!)
}.disposed(by: disposeBag)
subject.onNext("test one")
subject.onNext("test two")
/// 还可以这样用,在订阅之前需要进行多组操，注意這里要逆序写！
subject.startWith("third")
.startWith("second")
.startWith("first")
.subscribe { (event) in
print(event.element!)
}.disposed(by: disposeBag)
/// 打印结果
first
second
third
test one
test two
-
merge 融合
将两个可观测序列合并为一个可观测序列，这一订阅者可以收到任一者发出的事件
let disposeBag = DisposeBag()
/// 创建两个subject
let subject1 = PublishSubject<String>()
let subject2 = PublishSubject<String>()
/// 将两个subject进行融合
let mergeSubject = Observable.of(subject1, subject2).merge()
mergeSubject.subscribe({ (event) in
print(event.element!)
}).disposed(by: disposeBag)
/// 发送事件
subject1.onNext("one")
subject2.onNext("two")
/// 打印结果
one
two
-
zip 绑定
将两个或多个（最多八个）可观测序列进行绑定，和merge的区别在于：订阅者只有接收到所有被绑定着所发送的事件后才会执行订阅操作！
let disposeBag = DisposeBag()
/// 创建两个被绑定subject
let stringSubject = PublishSubject<String>()
let intSubject = PublishSubject<Int>()
/// 创建绑定subject
let zipSubject = Observable.zip(stringSubject, intSubject)
zipSubject.subscribe({ (event) in
print(event.element!)
}).disposed(by: disposeBag)
/// 发送事件
stringSubject.onNext("️hello")
stringSubject.onNext("️hi")
intSubject.onNext(1)
intSubject.onNext(2)
stringSubject.onNext("U")
intSubject.onNext(3)
/// 打印结果
("hello", 1)
("hi", 2)
("U", 3)
-
combineLatest
和zip非常相似，区别在于zip会将多个信号凑齐以后才会发送新的事件，而combineLatest会将本subject的事件与其他subject上一次的事件组合进行发送，这样你可以获取到每个subject的最新事件。
let disposeBag = DisposeBag()
/// 创建subjects
let stringSubject = PublishSubject<String>()
let intSubject = PublishSubject<Int>()
/// 进行组合
let combineSubject = Observable.combineLatest(stringSubject, intSubject)
/// 订阅
combineSubject.subscribe({ (event) in
print(event.element?.0, event.element?.1)
}).disposed(by: disposeBag)
/// 发送事件
stringSubject.onNext("️Sun")
stringSubject.onNext("️Moon")
intSubject.onNext(1)
intSubject.onNext(2)
stringSubject.onNext("sunday")
/// 打印结果
Optional("Sun") Optional(1)
Optional("Moon") Optional(2)
Optional("sunday") Optional(2)
-
switchLatest
拿到最近的一个事件！
let disposeBag = DisposeBag()
let subject1 = BehaviorSubject(value: "sub1")
let subject2 = BehaviorSubject(value: "sub2")
///
let variable = Variable(subject1)
variable.asObservable()
.switchLatest()
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
subject1.onNext("66")
subject2.onNext("333")
///
variable.value = subject2
subject1.onNext("mei")
subject2.onNext("mu")
/// 打印结果
sub1
66
333
mie
/// 当variable的value发生更改时，可以拿到该subject最近一次所发送的事件，如果subject2 不发送“333”事件，那么订阅者拿到的事件就是sub2
小结：在编写代码的过程中，适当的使用组合事件可以提供很大程度的便利 ，尤其是在MVVM架构中，例如，当你一个页面有多个请求时，你就可以把多个请求发送过来的事件绑定在一起刷新页面！
2. Transforming Operators 转换操作
-
map
对拿到的事件进行进一步操作，返回操作后的事件，很好理解，就不多废话了。
let disposeBag = DisposeBag()
let mapSubject = PublishSubject<Int>()
mapSubject.map({ (num) -> Int in
return num * num
}).subscribe({ (event) in
print(event.element!)
}).disposed(by: disposeBag)
mapSubject.onNext(2)
-
flatMap and flatMapLatest
flatMap 简单点解释就是将两个序列进行融合并且拿到他们的所有事件
flatMapLatest 则是只拿到最新的事件
/// 这个理解起来可能比较费劲，解释一下，先定义了一个player，属性为score，score是一个Variable，这个score可以看作可观测序列，而flatMap就是当可观测序列发生变化时，拿到可观测序列的所有值。
let disposeBag = DisposeBag()
struct Player {
var score: Variable<Int>
}
let boy = Player(score: Variable(80))
let girl = Player(score: Variable(90))
let player = Variable(boy)
player.asObservable()
.flatMap { $0.score.asObservable() } // Change flatMap to flatMapLatest and observe change in printed output
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
boy.score.value = 85
player.value = girl
boy.score.value = 95 // Will be printed when using flatMap, but will not be printed when using flatMapLatest
girl.score.value = 100
/// 打印结果
80
85
90
95
100
-
scan
扫描操作，对每一个事件都进行一项操作
let subject = PublishSubject<Int>()
/// 参数2 是aggregateValue的初始值，newValue为接收到是事件，当操作完成后，返回的值成为aggregateValue
subject.scan(2, accumulator: { (aggregateValue, newValue) -> Int in
return aggregateValue * newValue
}).subscribe({ (event) in
print(event.element ?? 0)
}).disposed(by: disposeBag)
subject.onNext(1)
subject.onNext(2)
subject.onNext(3)
/// 打印结果
2
4
132
以上几个方法是对subject的进一步操作，掌握这些方法在很大程度上方便代码的编写！各位在实际操作中可以更加深刻的体会到其便利性！
关联文章
** 恭喜各位能看完的各位离大V的脚步更近了一步，我还只是个小菜鸟，需要各位的支持，如果觉的本文有用，下面点个喜欢！有问题可留言！**
