RxSwift基础讲解

RxSwift:
RxSwift是一个使用可观察序列和函数式操作符编写异步和基于事件的代码的库。
RxSwift常用的类型：

Observable可被观察的，和可被观察序列，在RxSwift中所有的事物都是序列

sequence.png

Observable在没有订阅者之前不会发送事件或执行任何工作;
Observable实际上是一个序列定义;订阅一个可观察对象实际上更像是在Swift标准库的迭代器上调用next()。

Observable 的特征序列

Single：发出一个元素，或一个error事件
Completable：发出零个元素，发出一个completed事件或者一个error事件（只关心任务是否完成）
Maybe：介于Singles 和 Completable 之间，它要么只能发出一个元素，要么产生一个completed事件，要么产生一个error
Driver 不会产生error事件，一定在MainScheduler监听
Signal 和 Driver相似，Drive会对新观察者回放上一个元素，而signal不会对新观察者回放上一个元素
ControlEvent：专门用于描述UI控件产生的事件，一定在主线程监听，一定在主线程订阅

Subject: Observable & observer 即使是观察者也是响应者

辅助类型

PuhlishSubject:开始时为空，只向订阅者发送新元素
BehaviorSubject:以初始值开始，并将其或最新元素重播给新订阅者
ReplaySubject:初始化一个缓冲区大小，并将保持一个元素缓冲区的大小，并将其重播给新的订阅者
PublishRelay和BehaviorSubject:只接受接下来的事件。你不能添加。completed或。error事件，所以它们非常适合不终止序列

collection.png

Operators

您也可以将Rx的简单运算符串连和组合在一起来表达复杂的应用逻辑。

Filtering Operators

ignoreElements忽略所有元素，只接受complete和error事件
filter:过滤到闭包里面的条件
skip:skip第几个实体
skipWhile:跳过闭包里的条件直到不满足位置
skipUntil：依赖别的observable，一直忽略元素，直到别的observable发出next事件。
take: 只取前面几个元素
takeWhile取闭包里面满足条件的元素
takeUntil依赖别的observable，一直接受，直到别的observable发出next事件。就开始忽略元素。
distinctUntilChanged防止连续重复的元素，如果当前元素和上一个元素重复，当前元素就会被忽略

Transforming Operators

toArray将所有放到一个数组里
map操作符将源 Observable 的每个元素应用你提供的转换方法，然后返回含有转换结果的 Observable。map只是转化元素内容而不是转化Observable
flatmap转化内部的observable,并保持每一个它创建的observable

 func testflatmap() {
        struct Student {
            let score: BehaviorSubject<Int>
        }
        let laura = Student(score: BehaviorSubject(value: 80))
        let charlotte = Student(score: BehaviorSubject(value: 90))
        let student = PublishSubject<Student>()
        
        student.flatMap {
            $0.score
        }
        .subscribe(onNext: {
            print($0)
        }, onError: nil, onCompleted: nil, onDisposed: nil)
        .disposed(by: disposeBag)
        student.onNext(Laura)
        laura.score.onNext(85)
        student.onNext(Charlotte)
        laura.score.onNext(95)//输出了95代表既保持了Laura的observable也保持了Charlotte的observable
        charlotte.score.onNext(100)
    }

flatMapLatest转化内部的observable,并保持最后一个它创建的observable
materialize把监听的元素包裹为事件
dematerialize将监听的事件解为元素

Combining Operators

concat结合两个observable的元素,前一个终止，才能轮到下一个
concatMap把两个observable结合为一个observable
merge结合两个observable任何一个observable发出元素都可以监听的到

Combining elements

combineLatest结合Observables，直到每个observable都有一个元素产生。结合的Observable才有元素发出。
zip通过一个函数将多个 Observables 的元素组合起来，然后将每一个组合的结果发出来,它会严格的按照序列的索引数进行组合

  func testzip() {
        let first = PublishSubject<String>()
        let second = PublishSubject<String>()
        Observable.zip(first, second) {
            $0 + $1
        }
        .subscribe(onNext: {
            print($0)
        }, onError: { error in
            print(error)
        }, onCompleted: {
            print("完成")
        }, onDisposed: nil)
        .disposed(by: disposeBag)
        
        first.onNext("1")
        first.onNext("2")
        second.onNext("A")
        second.onNext("B")
    }

输出结果为：

1A
2B

withLatestFrom结合一个observable，当自己的observable有元素发出的时候，取结合的那个observable的最后一个元素

Switches

switchLatest序列内部还是序列的时候调用，切换最新的observable，只监听最新的observable