Swift进阶之RxSwift（二）

2017-05-11 本文已影响248人 Cocoaleeo

前言

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的脚步更近了一步，我还只是个小菜鸟，需要各位的支持，如果觉的本文有用，下面点个喜欢！有问题可留言！**

Swift进阶之RxSwift（二）

前言

步入正题

1.Combination Operators 组合操作

2. Transforming Operators 转换操作

关联文章

猜你喜欢

热点阅读