RxSwift 总结

基本概念：

Observable (可观察序列):异步地产生一系列Event（事件）即：event(element:T)
Observer（订阅者）：订阅Observable,收到Observable发出的Event
Event：一个枚举源码如下

public enum Event {
/// Next element is produced.
case next(Element)
/// Sequence terminated with an error.
case error(Swift.Error)
 /// Sequence completed successfully.
 case completed
 }

创建Observable序列

分为普通序列和特征序列

一、普通序列

1、just()
Observable.just(5) 发出一个5
2、of()
Observable.of("a","b","c") 可变参数同一类型
3、from()
Observable.from(["a","b","c"]) 需要一个数组
4、empty()
空
5、never()
永远不会发出
6、error()
Observable.error(myError.errorA)
需要一个Error类型参数
7、range()
Observable.range(start: 1, count: 5)
范围值
8、repeatElement()
Observable.repeatElement(1)
无限发出给定元素的event （永不终止）
9、generate()

Observable.generate(
    initialState: 0, 
    condition: { $0 <= 10 }, 
    iterate: { $0 + 2 }
)// 0 2 4 6 8 10

条件判断
10、create()
block创建

let observable10 = Observable.create { ob in
            ob.onNext("test")
            ob.onError(myError.errorA)
            ob.onCompleted()
//            因为一个订阅行为会有一个Disposables类型的返回值，所以在结尾一定要return一个Disposables
            return Disposables.create {}
        }

11、deferred()
创建一个工厂

        var isOdd = true
        
        let factory: Observable = Observable.deferred {
            isOdd = !isOdd
            
            if isOdd {
                return Observable.of(1,3,5,7)
            }
            else {
                return Observable.of(2,4,6,8)
            }
        }
        
//        第一次订阅
        factory.subscribe{ event in
                print("\(isOdd)",event)
        }//false 2...
        
//        第二次订阅
        factory.subscribe{ event in
            print("\(isOdd)",event)
        }//true,1 ...

12、interval()
创建一个 Observable 每隔一段时间，发出一个索引数

Observable.interval(1, scheduler: MainScheduler.instance)
        ob.subscribe { event in
                print(event)
        }.disposed(by: disposeBag)

13、timer()

        //timer()  创建一个经过设定的一段时间后，产生唯一的元素
        let ob2 = Observable.timer(5, scheduler: MainScheduler.instance)
        
        ob2.subscribe{  event in
                print("ob2--->",event)
        }
        
//        第二种 就是经过设定一段时间，每隔一段时间产生一个元素
//        第一个参数就是等待5秒，第二个参数为每个1秒产生一个元素
        
        let ob3 = Observable.timer(5, period: 1, scheduler: MainScheduler.instance)

二、特征序列

1、Single()

• 发出一个元素，或一个 error 事件
• 不会[共享附加作用]

2、Completable()

• 发出零个元素
• 发出一个 completed 事件或者一个 error 事件
• 不会共享附加作用

3、Maybe()

• 发出一个元素或者一个 completed 事件或者一个 error 事件
• 不会共享附加作用

4、Driver()---->(用于UI事件)

• 不会产生 error 事件
• 一定在 MainScheduler 监听（主线程监听）
• 共享附加作用

5、Signal()

• 不会产生 error 事件
• 一定在 MainScheduler 监听（主线程监听）
• 共享附加作用
  与Driver 相似 区别：Driver会对新的观察者回放（重新发送）上一个元素，而Signal不会对新观察着回放上一个元素。
  一般情况下状态序列我们会选用 Driver这个类型，事件序列我们会选用 Signal 这个类型。

6、ControlEvent
专门用于描述 UI 控件所产生的事件，具有以下特征：

• 不会产生 error 事件
• 一定在 MainScheduler 订阅（主线程订阅）
• 一定在 MainScheduler 监听（主线程监听）
• 共享附加作用

创建Observer 观察者

创建观察者最直接的方法就是在 Observable 的 subscribe 方法后面描述，事件发生时，需要如何做出响应。而观察者就是由后面的 onNext，onError，onCompleted的这些闭包构建出来的。
还可以以下方式：
1、AnyObserver
AnyObserver 可以用来描叙任意一种观察者。

2、Binder

• 不会处理错误事件
• 确保绑定都是在给定 Scheduler 上执行（默认 MainScheduler）

既是观察者也是监听者 Subject

1、AsyncSubject
AsyncSubject 将在源 Observable 产生完成事件后，发出最后一个元素（仅仅只有最后一个元素），如果源 Observable 没有发出任何元素，只有一个完成事件。那 AsyncSubject 也只有一个完成事件。
它会对随后的观察者发出最终元素。如果源 Observable 因为产生了一个 error 事件而中止， AsyncSubject 就不会发出任何元素，而是将这个 error 事件发送出来。
2、PublishSubject
PublishSubject 将对观察者发送订阅后产生的元素，而在订阅前发出的元素将不会发送给观察者。
3、ReplaySubject
ReplaySubject 将对观察者发送全部的元素，无论观察者是何时进行订阅的。
4、BehaviorSubject
当观察者对 BehaviorSubject 进行订阅时，它会将源 Observable 中最新的元素发送出来（如果不存在最新的元素，就发出默认元素）。然后将随后产生的元素发送出来。
如果源 Observable 因为产生了一个 error 事件而中止， BehaviorSubject 就不会发出任何元素，而是将这个 error 事件发送出来。
5、ControlProperty
ControlProperty 专门用于描述 UI 控件属性的，它具有以下特征：

• 不会产生 error 事件
• 一定在 MainScheduler 订阅（主线程订阅）
• 一定在 MainScheduler 监听（主线程监听）
• 共享附加作用

RxRelay

RxRelay 既是 可监听序列 也是 观察者 使用accept代替onNext。
他和 Subjects 相似，唯一的区别是不会接受 onError 或 onCompleted 这样的终止事件。
1、PublishRelay
PublishRelay 就是 PublishSubject 去掉终止事件 onError 或 onCompleted。
2、BehaviorRelay
BehaviorRelay 就是 BehaviorSubject 去掉终止事件 onError 或 onCompleted。

Operator -操作符

操作符可以帮助大家创建新的序列，或者变化组合原有的序列，从而生成一个新的序列。

• amb
  在多个源 Observables 中， 取第一个发出元素或产生事件的 Observable，然后只发出它的元素

  
  
  image.png

• buffer
  缓存元素，然后将缓存的元素集合，周期性的发出来

  
  
  image.png

• catchError
  从一个错误事件中恢复，将错误事件替换成一个备选序列
  包含不同版本
  1、catchError：不会结束
  2、catchErrorJustReturn
  catchErrorJustReturn 操作符会将error 事件替换成其他的一个元素，然后结束该序列。

  
  
  image.png

• combineLatest
  当多个 Observables 中任何一个发出一个元素，就发出一个元素。这个元素是由这些 Observables 中最新的元素，通过一个函数组合起来的

  
  
  image.png

• concat
  让两个或多个 Observables 按顺序串连起来

  
  
  image.png

• concatMap
  将 Observable 的元素转换成其他的 Observable，然后将这些 Observables 串连起来

  
  
  image.png
  
  

  concatMap 操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。然后让这些 Observables 按顺序的发出元素，当前一个 Observable 元素发送完毕后，后一个 Observable 才可以开始发出元素。等待前一个 Observable 产生完成事件后，才对后一个 Observable 进行订阅。

let disposeBag = DisposeBag()

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

let variable = Variable(subject1)

variable.asObservable()
        .concatMap { $0 }
        .subscribe { print($0) }
        .disposed(by: disposeBag)

subject1.onNext("")
subject1.onNext("")

variable.value = subject2

subject2.onNext("I would be ignored")
subject2.onNext("")

subject1.onCompleted()

subject2.onNext("")

输出结果

next()
next()
next()
next()
next()

• connect
  通知 ConnectableObservable 可以开始发出元素了
  ConnectableObservable 和普通的 Observable 十分相似，不过在被订阅后不会发出元素，直到 connect 操作符被应用为止。这样一来你可以等所有观察者全部订阅完成后，才发出元素。

  
  
  image.png

• create
  通过一个构建函数完整的创建一个 Observable

• debounce
  过滤掉高频产生的元素

  
  
  image.png

• debug
  打印所有的订阅，事件以及销毁信息

• deferred
  直到订阅发生，才创建 Observable，并且为每位订阅者创建全新的 Observable

  
  
  image.png

• delay
  将 Observable 的每一个元素拖延一段时间后发出

• delaySubscription
  进行延时订阅

• dematerialize
  dematerialize 操作符将 materialize 转换后的元素还原
  

  image.png

• distinctUntilChanged
  阻止 Observable 发出相同的元素

  
  
  image.png

• do
  当 Observable 产生某些事件时，执行某个操作

• elementAt
  只发出 Observable 中的第 n 个元素
  *empty
  只有一个完成事件
  *error
  只有一个error事件

• filter - 过滤

  
  
  image.png

• flatMap
  将 Observable 的元素转换成其他的 Observable，然后将这些 Observables 合并

  
  
  image.png

• flatMapLatest
  将 Observable 的元素转换成其他的 Observable，然后取这些 Observables 中最新的一个

  
  
  image.png

• from
  将其他类型或者数据结构转换为 Observable

• groupBy
  将源 Observable 分解为多个子 Observable，并且每个子 Observable 将源 Observable 中“相似”的元素发送出来

• ignoreElements
  忽略掉所有的元素，只发出 error 或 completed 事件

• interval
  创建一个 Observable 每隔一段时间，发出一个索引数

• just
  创建 Observable 发出唯一的一个元素

• map - 转换
  通过一个转换函数，将 Observable 的每个元素转换一遍
  *merge
  将多个 Observables 合并成一个

  
  
  image.png
  
  

  *materialize
  将序列产生的事件，转换成元素

• never
  创建一个永远不会发出元素的 Observable

• observeOn
  指定 Observable 在那个 Scheduler 发出通知

• publich
  将 Observable 转换为可被连接的 Observable

• reduce
  持续的将 Observable 的每一个元素应用一个函数，然后发出最终结果(eg：累加)

• refCount
  将可被连接的 Observable 转换为普通 Observable

• repeatElement
  创建 Observable 重复的发出某个元素

• replay
  确保观察者接收到同样的序列，即使是在 Observable 发出元素后才订阅
  replay 操作符将 Observable 转换为可被连接的 Observable，并且这个可被连接的 Observable 将缓存最新的 n 个元素。当有新的观察者对它进行订阅时，它就把这些被缓存的元素发送给观察者。

• retry
  如果源 Observable 产生一个错误事件，重新对它进行订阅，希望它不会再次产生错误

• sample
  不定期的对 Observable 取样

  
  
  image.png
  
  

  sample 操作符将不定期的对源 Observable 进行取样操作。通过第二个 Observable 来控制取样时机。一旦第二个 Observable 发出一个元素，就从源 Observable 中取出最后产生的元素。

• scan
  持续的将 Observable 的每一个元素应用一个函数，然后发出每一次函数返回的结果

  
  
  image.png

• shareReplay
  使观察者共享 Observable，观察者会立即收到最新的元素，即使这些元素是在订阅前产生的

• single
  限制 Observable 只有一个元素，否出发出一个 error 事件

• skip
  跳过 Observable 中头 n 个元素

• skipUntil
  跳过 Observable 中头几个元素，直到另一个 Observable 发出一个元素

• skipWhile
  跳过 Observable 中头几个元素，直到元素的判定为否

• startWith
  将一些元素插入到序列的头部 （如果你想在尾部加入一些元素可以用concat

• subscribeOn
  指定 Observable 在那个 Scheduler 执行

• take
  仅仅从 Observable 中发出头 n 个元素

• takeLast
  仅仅从 Observable 中发出尾部 n 个元素

• takeUntil
  忽略掉在第二个 Observable 产生事件后发出的那部分元素

• takeWhile
  镜像一个 Observable 直到某个元素的判定为 false

  
  
  image.png
  
  

  takeWhile 操作符将镜像源 Observable 直到某个元素的判定为 false。此时，这个镜像的 Observable 将立即终止。

• timeout
  如果源 Observable 在规定时间内没有发出任何元素，就产生一个超时的 error 事件

  
  
  image.png

• timer
  创建一个 Observable 在一段延时后，产生唯一的一个元素

• using
  创建一个可被清除的资源，它和 Observable 具有相同的寿命

• window
  将 Observable 分解为多个子 Observable，周期性的将子 Observable 发出来
  window 操作符和 buffer 十分相似，buffer 周期性的将缓存的元素集合发送出来，而 window 周期性的将元素集合以 Observable 的形态发送出来。
  buffer 要等到元素搜集完毕后，才会发出元素序列。而 window 可以实时发出元素序列。

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

  
  
  image.png

• zip-配对

  
  
  image.png
  
  

  你可以用 zip来合成一个新的序列。这个序列将汉堡序列的元素和薯条序列的元素配对后，生成一个新的套餐序列。