Rx 操作符三

• deferred

直到订阅发生，才创建 Observable，并且为每位订阅者创建全新的 Observable  deferred 操作符将等待观察者订阅它，才创建一个 Observable，它会通过一个构建函数为每一位订阅者创建新的 Observable。看上去每位订阅者都是对同一个 Observable 产生订阅，实际上它们都获得了独立的序列。

在一些情况下，直到订阅时才创建 Observable 是可以保证拿到的数据都是最新的。

• delay

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

delay 操作符将修改一个 Observable，它会将 Observable 的所有元素都拖延一段设定好的时间， 然后才将它们发送出来。

• delaySubscription

进行延时订阅

delaySubscription 操作符将在经过所设定的时间后，才对 Observable 进行订阅操作

• dematerialize

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

• distinctUntilChanged

阻止 Observable 发出相同的元素

distinctUntilChanged 操作符将阻止 Observable 发出相同的元素。如果后一个元素和前一个元素是相同的，那么这个元素将不会被发出来。如果后一个元素和前一个元素不相同，那么这个元素才会被发出来。

let disposeBag = DisposeBag()

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

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

当 Observable 的某些事件产生时，可以使用 do 操作符来注册一些回调操作。这些回调会被单独调用，它们会和 Observable 原本的回调分离。

• elementAt

只发出 Observable 中的第 n 个元素

elementAt 操作符将拉取 Observable 序列中指定索引数的元素，然后将它作为唯一的元素发出。

let disposeBag = DisposeBag()

Observable.of("??", "??", "??", "??", "??", "??")
    .elementAt(3)
    .subscribe(onNext: { print($0) })
    .disposed(by: disposeBag)

• empty

创建一个空 Observable

empty 操作符将创建一个 Observable，这个 Observable 只有一个完成事件。

创建一个空 Observable：

let id = Observable<Int>.empty()

它相当于：
let id = Observable<Int>.create { observer in
    observer.onCompleted()
    return Disposables.create()
}

• error

创建一个只有 error 事件的 Observable

error 操作符将创建一个 Observable，这个 Observable 只会产生一个 error 事件

创建一个只有 error 事件的 Observable：

let error: Error = ...
let id = Observable<Int>.error(error)

相当于：

let error: Error = ...
let id = Observable<Int>.create { observer in
    observer.onError(error)
    return Disposables.create()
}

• filter

仅仅发出 Observable 中通过判定的元素

filter 操作符将通过你提供的判定方法过滤一个 Observable。

let disposeBag = DisposeBag()

Observable.of(2, 30, 22, 5, 60, 1)
          .filter { $0 > 10 }
          .subscribe(onNext: { print($0) })
          .disposed(by: disposeBag)

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

flatMap 操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。 然后将这些 Observables 的元素合并之后再发送出来。

这个操作符是非常有用的，例如，当 Observable 的元素本身拥有其他的 Observable 时，你可以将所有子 Observables 的元素发送出来。

let disposeBag = DisposeBag()
let first = BehaviorSubject(value: "????")
let second = BehaviorSubject(value: "???")
let variable = Variable(first)

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

first.onNext("??")
variable.value = second
second.onNext("???")
first.onNext("??")

• flatMapLatest

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

flatMapLatest 操作符将源 Observable 的每一个元素应用一个转换方法，将他们转换成 Observables。一旦转换出一个新的 Observable，就只发出它的元素，旧的 Observables 的元素将被忽略掉。

tips：与 flatMap 比较更容易理解

let disposeBag = DisposeBag()
let first = BehaviorSubject(value: "????")
let second = BehaviorSubject(value: "???")
let variable = Variable(first)

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

first.onNext("??")
variable.value = second
second.onNext("???")
first.onNext("??")