一.`Observable` - 可监听序列

1.特征序列`Driver`

<1>表示具有以下特征的可观察序列：

不会产生error事件
在MainScheduler上监听事件
使用了share(replay: 1, scope: .whileConnected)共享策略(共享附加作用)

这些都是驱动UI的序列所需要具有的特征。

<2>补充说明：

所有订阅者共享序列计算资源
如果可观察序列产生了至少一个元素，则在进行新订阅后，最后一个产生的元素将立即在订阅的同一线程上重播
如果没有订阅者，它将释放序列计算资源

<3>使用场景：

通过CoreData模型驱动UI
使用一个UI元素值来驱动另外一个UI元素值
搜索框中每次输入一个文本，就会获取一次网络请求，请求成功后将数据渲染到UI界面

2.特征序列`ControlEvent`

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

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

二.`Observer` - 观察者

1. `AnyObserver`：可以描述任意一种观察者。

用户名提示语是否隐藏:

usernameValid
    .bind(to: usernameValidLabel.rx.isHidden)
    .disposed(by: disposeBag)

可以看作是：

let observer: AnyObserver<Bool> = AnyObserver { [weak self] event in
    switch event {
    case .next(let isHidden):
        self?.usernameValidLabel.isHidden = isHidden
    default:
        break
    }
}

usernameValid
    .bind(to: observer)
    .disposed(by: disposeBag)

2.特征观察者`Binder`

<1>表示具有以下特征的观察者：

不会处理error事件
确保绑定都是在给定Scheduler上执行(默认MainScheduler)

<2>在上面的AnyObserver例子，由于这个观察者是一个UI观察者，所以它在响应事件时，只会处理next事件，并且更新UI的操作需要在主线程上执行，因此更好的方案就是使用Binder：

let observer: Binder<Bool> = Binder(usernameValidLabel) { label, isHidden in
     label.isHidden = isHidden
}
usernameValid
    .bind(to: observer)
    .disposed(by: disposeBag)

<3>由于一个页面是否隐藏是一个常用的观察者，所以应该让所有的UIView都提供这种观察者：

extension Reactive where Base: UIView {
    public var isHidden: Binder<Bool> {
      return Binder(self.base) { view, hidden in 
            view.isHidden = hidden
        }
    }
}

usernameValid
    .bind(to: usernameValidLabel.rx.isHidden)
    .disposed(by: disposeBag)

三.`Observable & Observer` - 即是可监听序列也是观察者

1.`PublishSubject`：将对观察者发送订阅后产生的元素，而在订阅前发出的元素将不会发送给观察者。

let subject = PublishSubject<String>()

subject
    .subscribe { print("Subscription: 1 Event:", $0) }
    .disposed(by: disposeBag)

subject.onNext("🐶")
subject.onNext("🐻")

subject
    .subscribe { print("Subscription: 2 Event:", $0) }
    .disposed(by: disposeBag)

subject.onNext("🅰️")
subject.onNext("🅱️")

/// 输出结果：第2个观察者不会收到订阅前发出的元素🐶和🐻
Subscription: 1 Event: next(🐶)
Subscription: 1 Event: next(🐻)
Subscription: 1 Event: next(🅰️)
Subscription: 2 Event: next(🅰️)
Subscription: 1 Event: next(🅱️)
Subscription: 2 Event: next(🅱️)

2.`ReplaySubject`：在新观察者订阅时，补发已经发送过的元素。

这里存在多个版本的ReplaySubject，有的只会将最新的n个元素发送给观察者，有的只会将限制时间段内的最新元素发送给观察者。

如果ReplaySubject当作观察者来使用，注意不要多个线程调用onNext、onError或onCompleted。这样会导致无序调用，将造成意想不到的结果。

let subject = ReplaySubject<String>.create(bufferSize: 1)

subject
    .subscribe { print("Subscription: 1 Event:", $0) }
    .disposed(by: disposeBag)

subject.onNext("🐶")
subject.onNext("🐻")

subject
    .subscribe { print("Subscription: 2 Event:", $0) }
    .disposed(by: disposeBag)

subject.onNext("🅰️")
subject.onNext("🅱️")

/// 输出结果：当第2个观察者订阅的时候，会发送已经发送过的最后一个元素(bufferSize为1)。
Subscription: 1 Event: next(🐶)
Subscription: 1 Event: next(🐻)
Subscription: 2 Event: next(🐻)
Subscription: 1 Event: next(🅰️)
Subscription: 2 Event: next(🅰️)
Subscription: 1 Event: next(🅱️)
Subscription: 2 Event: next(🅱️)

3.`BehaviorSubject`：在新观察者订阅时，会发送最近发送的一个元素，如果没有，则发送一个默认元素值。

let subject = BehaviorSubject(value: "🔴")

subject
    .subscribe { print("Subscription: 1 Event:", $0) }
    .disposed(by: disposeBag)

subject.onNext("🐶")
subject.onNext("🐻")

subject
    .subscribe { print("Subscription: 2 Event:", $0) }
    .disposed(by: disposeBag)

subject.onNext("🅰️")
subject.onNext("🅱️")

/// 输出结果：第1个观察者订阅时，没有发送过的元素，发送默认元素🔴
/// 第2个观察者订阅时，发送最近发送过的元素🐻
Subscription: 1 Event: next(🔴)
Subscription: 1 Event: next(🐶)
Subscription: 1 Event: next(🐻)
Subscription: 2 Event: next(🐻)
Subscription: 1 Event: next(🅰️)
Subscription: 2 Event: next(🅰️)
Subscription: 1 Event: next(🅱️)
Subscription: 2 Event: next(🅱️)

4.`AsyncSubject`：在源`Observable`产生完成事件(`onCompleted`)后，发送最后一个元素(仅仅只有最后一个元素)，如果源 `Observable`没有发出任何元素，只有一个完成事件，那么`AsyncSubject`也只有一个完成事件。

let subject = AsyncSubject<String>()

subject
    .subscribe { print("Subscription: 1 Event:", $0) }
    .disposed(by: disposeBag)

subject.onNext("🐶")
subject.onNext("🐻")

subject
    .subscribe { print("Subscription: 2 Event:", $0) }
    .disposed(by: disposeBag)

subject.onNext("🅰️")
subject.onNext("🅱️")
subject.onCompleted()

/// 输出结果：只会发送最后一个元素🅱️
Subscription: 1 Event: next(🅱️)
Subscription: 2 Event: next(🅱️)
Subscription: 1 Event: completed
Subscription: 2 Event: completed

5.`ControlProperty`

专门用于描述UI控件属性的，具有以下特征：

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

四.`Error Handing` - 错误处理

一旦序列里面产生了一个error事件，整个序列将被终止，RxSwift有两种错误处理机制：

1.`catch`：恢复

catchAndReturn(_:)：当错误产生时，返回一个指定的元素，从而使该可观察序列继续。
catch(_:)：当错误产生时，将错误事件替换成一个备选序列，从而使该可观察序列继续。

2.`retry`：重试

retry(_)：让序列在发生错误时，进行指定次数的重试操作。
retry(when:)：让序列在发生错误时，延时一段时间后进行重试操作。

二.`DelegateProxy`

DelegateProxy是代理委托，可以将它看作是代理的代理。
DelegateProxy的作用是作为一个中间代理，它会把系统的delegate对象保存一份，然后拦截delegate方法。也就是说在每次触发delegate方法之前，会先调用DelegateProxy对应的方法，可以在方法里面发送序列给多个订阅者。

三.创建`Observables`

1.`deferred`：直到订阅发生，才创建`Observable`，并为每个订阅者创建一个新的`Observable`。

通常带有一个Observable工厂函数，为每个订阅者重新执行此操作，每个订阅者都有自己的单独序列。

2.`just`：创建只能发出唯一一个元素的`Observable`。

一个序列只有唯一的元素0:

let id = Observable.just(0)

它相当于:

let id = Observable<Int>.create { observer in
    observer.onNext(0)
    observer.onCompleted()
    return Disposables.create()
}

3.`using`：通过使用`using`操作符创建`Observable`时，同时创建一个可被清除的资源(Disposable)，一旦`Observable`终止了，那么这个资源就会被清除掉了。

四.组合`Observables`

1.`combineLatest`：将多个`Observable`合并，当任意一个`Observable`发出元素时，通过指定的函数组合每个`Observable`发出的最新元素，并根据该函数的结果发出元素(前提是每个`Observable`都至少发出过一次元素)。

combineLatest

let firstSubject = PublishSubject<String>()
let secondSubject = PublishSubject<String>()

firstSubject
    .withLatestFrom(secondSubject) { $0 + $1 }
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

/// 不会发送，因为secondSubject没有最新元素
firstSubject.onNext("🅰️")  
/// 不会发送，因为secondSubject没有最新元素
firstSubject.onNext("🅱️")
/// 不会发送，只有当firstSubject发送元素时才会触发
secondSubject.onNext("1")
/// 不会发送，只有当firstSubject发送元素时才会触发
secondSubject.onNext("2")
/// 会发送
firstSubject.onNext("🆎")

/// 输出结果：
🆎2

2.`withLatestFrom`：当第一个`Observable`发出一个元素时，立即取出第二个`Observable`中的最新元素，通过一个组合函数将两个最新的元素合并后发送出去(若第二个`Observable`没有最新的元素则不发送)。

withLatestFrom

3.`startWith`：在`Observable`发送元素之前，发送指定的元素。

Observable.of(1, 2, 3)
    .startWith(0)
    .startWith(-1)
    .startWith(-2)
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

/// 输出结果：后插入的先发送
-2
-1
0
1
2
3

五.转换`Observables`

1.`map`：通过一个转换函数，将`Observable`的每个元素都转换一遍。

Observable.of(1, 2, 3)
    /// map不会创建新的Observable，只是将转换后的元素赋值给原Observable
    .map { $0 * 10 }
    /// 此处订阅的是Observable.of(1, 2, 3)创建的可观察序列
    .subscribe(onNext: {
        print($0)
    })
    .disposed(by: disposeBag)

2.`flatMap`：对原有`Observable`中的元素进行转换，每一个元素返回一个新的`Observable`，然后将这些`Observable`合并成一个新的`Observable`。

struct Player {
    var score: BehaviorRelay<Int>
}

let first = BehaviorSubject(value: "👦🏻")
let second = BehaviorSubject(value: "🅰️")
let subject = BehaviorSubject(value: first)

subject.asObservable()
        /// flatMap可直接返回一个Observable，或者创建一个新的Observable返回
        .flatMap { $0 }
        /// 此处订阅的不是subject，而是flatMap转换后的first
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)


/// second发出Event，因为second没有被订阅，所以不能接收到并打印
second.onNext("🐻")
/// first发出事件，因为fitst被订阅了，所以能接收到并打印
first.onNext("🐱")
/// subject发出事件，对象是second，因此second也被订阅了
/// 但是first的订阅并没有被取消
subject.onNext(second)
/// second发出事件，因为second被订阅了，所以能接收到并打印
second.onNext("🅱️")
/// first再次发出事件，依然能被接收到并打印
first.onNext("🐶")

/// 输出结果：第三个元素是🐻，是因为BehaviorSubject在订阅时会发出最新的元素
👦🏻
🐱
🐻
🅱️
🐶

3.`flatMapLatest`：当源序列有新的事件发生的时候，会自动取消上一个事件的订阅，转到新的事件的订阅上面。

六.操作符

1.`share(replay:)`

shareRepley

解决有多个订阅者的情况下，map映射会被执行多次的问题：

func test() {
        let subject = PublishSubject<Int>()
        
        let user = subject.map { age -> UserModel in
            print("映射---\(age)")
            return UserModel(age: age)
        }.share(replay: 1)
        
        user.subscribe(onNext: { model in
            print("第一次订阅---", Unmanaged.passUnretained(model).toOpaque())
        }).disposed(by: disposeBag)
        
        subject.onNext(1)
        subject.onNext(2)
        
        /// 订阅的同时会立即收到最新元素结果
        /// 此处会收到subject.onNext(2)的结果
        user.subscribe(onNext: { model in
            print("第二次订阅---", Unmanaged.passUnretained(model).toOpaque())
        }).disposed(by: disposeBag)
        
        subject.onNext(3)
        subject.onNext(4)
        
        /// 订阅的同时会立即收到最新元素结果
        /// 此处会收到subject.onNext(4)的结果
        user.subscribe(onNext: { model in
            print("第三次订阅---", Unmanaged.passUnretained(model).toOpaque())
        }).disposed(by: disposeBag)
        
        subject.onCompleted()
}

映射---1
第一次订阅--- 0x000000028151b920
映射---2
第一次订阅--- 0x0000000281571140
第二次订阅--- 0x0000000281571140
映射---3
第一次订阅--- 0x0000000281570da0
第二次订阅--- 0x0000000281570da0
映射---4
第一次订阅--- 0x00000002815709e0
第二次订阅--- 0x00000002815709e0
第三次订阅--- 0x00000002815709e0

结论：一个信号不管有多少个订阅者，映射代码只执行一次，所有订阅者对同一个信号处理是共享同一个结果的(输出对象的地址是相同的)。

2.`distinctUntilChanged`：阻止`Observable`发出相同的元素，如果后一个元素和前一个元素是相同的，那么这个元素将不会被发出来。

Observable.of("🐱", "🐷", "🐱", "🐱", "🐱", "🐵", "🐱")
    .distinctUntilChanged()
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

/// 输出结果：
🐱
🐷
🐱
🐵
🐱

RxSwift

一.Observable - 可监听序列

1.特征序列Driver

2.特征序列ControlEvent

二.Observer - 观察者

1. AnyObserver：可以描述任意一种观察者。

2.特征观察者Binder

三.Observable & Observer - 即是可监听序列也是观察者

1.PublishSubject：将对观察者发送订阅后产生的元素，而在订阅前发出的元素将不会发送给观察者。

2.ReplaySubject：在新观察者订阅时，补发已经发送过的元素。

3.BehaviorSubject：在新观察者订阅时，会发送最近发送的一个元素，如果没有，则发送一个默认元素值。

4.AsyncSubject：在源Observable产生完成事件(onCompleted)后，发送最后一个元素(仅仅只有最后一个元素)，如果源 Observable没有发出任何元素，只有一个完成事件，那么AsyncSubject也只有一个完成事件。

5.ControlProperty

四.Error Handing - 错误处理

1.catch：恢复

2.retry：重试

二.DelegateProxy

三.创建Observables

1.deferred：直到订阅发生，才创建Observable，并为每个订阅者创建一个新的Observable。

2.just：创建只能发出唯一一个元素的Observable。

3.using：通过使用using操作符创建Observable时，同时创建一个可被清除的资源(Disposable)，一旦Observable终止了，那么这个资源就会被清除掉了。

四.组合Observables

1.combineLatest：将多个Observable合并，当任意一个Observable发出元素时，通过指定的函数组合每个Observable发出的最新元素，并根据该函数的结果发出元素(前提是每个Observable都至少发出过一次元素)。

2.withLatestFrom：当第一个Observable发出一个元素时，立即取出第二个Observable中的最新元素，通过一个组合函数将两个最新的元素合并后发送出去(若第二个Observable没有最新的元素则不发送)。

3.startWith：在Observable发送元素之前，发送指定的元素。

五.转换Observables

1.map：通过一个转换函数，将Observable的每个元素都转换一遍。

2.flatMap：对原有Observable中的元素进行转换，每一个元素返回一个新的Observable，然后将这些Observable合并成一个新的Observable。

3.flatMapLatest：当源序列有新的事件发生的时候，会自动取消上一个事件的订阅，转到新的事件的订阅上面。