1.Amb

在多个源 Observables 中， 取第一个发出元素或产生事件的Observable ，然后只发出它的元素
当你传入多个 Observables 到 amb 操作符时，它将取其中一个 Observable：第一个产生事件的那个 Observable，可以是一个 next，error 或者 completed 事件。 amb 将忽略掉其他的 Observables。

2.buffer

缓存元素，然后将缓存的元素集合，周期性的发出来
buffer 操作符将缓存 Observable 中发出的新元素，当元素达到某个数量，或者经过了特定的时间，它就会将这个元素集合发送出来。

3.catchError、catchErrorJustReturn

catchError 操作符将会拦截一个 error 事件，将它替换成其他的元素或者一组元素，然后传递给观察者。这样可以使得 Observable 正常结束，或者根本都不需要结束。
catchErrorJustReturn 操作符会将error 事件替换成其他的一个元素，然后结束该序列。

4.combineLatest

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

image

combineLatest 操作符将多个 Observables 中最新的元素通过一个函数组合起来，然后将这个组合的结果发出来。这些源 Observables 中任何一个发出一个元素，他都会发出一个元素（前提是，这些 Observables 曾经发出过元素）。

5.concat

让两个或多个 Observables 按顺序串连起来
concat 操作符将多个 Observables 按顺序串联起来，当前一个 Observable 元素发送完毕后，后一个 Observable 才可以开始发出元素。

concat 将等待前一个 Observable 产生完成事件后，才对后一个 Observable 进行订阅。如果后一个是“热” Observable ，在它前一个 Observable 产生完成事件前，所产生的元素将不会被发送出来。

startWith 和它十分相似。但是startWith不是在后面添加元素，而是在前面插入元素。

merge 和它也是十分相似。merge并不是将多个 Observables 按顺序串联起来，而是将他们合并到一起，不需要 Observables 按先后顺序发出元素。

6.concatMap

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

7.connect

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

8.create

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

image

create 操作符将创建一个 Observable，你需要提供一个构建函数，在构建函数里面描述事件（next，error，completed）的产生过程。

通常情况下一个有限的序列，只会调用一次观察者的 onCompleted 或者 onError 方法。并且在调用它们后，不会再去调用观察者的其他方法。

9.debounce

过滤掉高频产生的元素

image

debounce 操作符将发出这种元素，在 Observable 产生这种元素后，一段时间内没有新元素产生。

10.debug

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

11.deferred

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

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

12.delay

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

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

13.delaySubscription

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

14.dematerialize

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

15.distinctUntilChanged

阻止 Observable 发出相同的元素

16.do

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

17.elementAt

只发出 Observable 中的第 n 个元素

image

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

18.empty

创建一个空 Observable

19.error

创建一个只有 error 事件的 Observable

20.filter

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

image

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

21.flatMap

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

image

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

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

22. flatMapLatest

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

image

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

23.from

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

image

当你在使用 Observable 时，如果能够直接将其他类型转换为 Observable，这将是非常省事的。from 操作符就提供了这种功能。

24.groupBy

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

image

groupBy 操作符将源 Observable 分解为多个子 Observable，然后将这些子 Observable 发送出来。

它会将元素通过某个键进行分组，然后将分组后的元素序列以 Observable 的形态发送出来。

25.interval

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

26.ignoreElements

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

27.just

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

28.map

通过一个转换函数，将 Observable 的每个元素转换一遍

image

map 操作符将源 Observable 的每个元素应用你提供的转换方法，然后返回含有转换结果的 Observable。

29.merge

将多个 Observables 合并成一个

image

通过使用 merge 操作符你可以将多个 Observables 合并成一个，当某一个 Observable 发出一个元素时，他就将这个元素发出。

如果，某一个 Observable 发出一个 onError 事件，那么被合并的 Observable 也会将它发出，并且立即终止序列。

30. materialize

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

image

通常，一个有限的 Observable 将产生零个或者多个 onNext 事件，然后产生一个 onCompleted 或者 onError 事件。

materialize 操作符将 Observable 产生的这些事件全部转换成元素，然后发送出来。

31.never

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

32.observeOn

指定 Observable 在那个 Scheduler 发出通知

image

ReactiveX 使用 Scheduler 来让 Observable 支持多线程。你可以使用 observeOn 操作符，来指示 Observable 在哪个 Scheduler 发出通知。

image

注意⚠️：一旦产生了 onError 事件， observeOn 操作符将立即转发。他不会等待 onError 之前的事件全部被收到。这意味着 onError 事件可能会跳过一些元素提前发送出去，如上图所示。

image

subscribeOn 操作符非常相似。它指示 Observable 在哪个 Scheduler 发出执行。

默认情况下，Observable 创建，应用操作符以及发出通知都会在 Subscribe 方法调用的 Scheduler 执行。subscribeOn 操作符将改变这种行为，它会指定一个不同的 Scheduler 来让 Observable 执行，observeOn 操作符将指定一个不同的 Scheduler 来让 Observable 通知观察者。

如上图所示，subscribeOn 操作符指定 Observable 在那个 Scheduler 开始执行，无论它处于链的那个位置。 另一方面 observeOn 将决定后面的方法在哪个 Scheduler 运行。因此，你可能会多次调用 observeOn 来决定某些操作符在哪个线程运行。

33.publish

将 Observable 转换为可被连接的 Observable

34.reduce

持续的将 Observable 的每一个元素应用一个函数，然后发出最终结果

35.refCount

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

36.repeatElement

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

37.replay

确保观察者接收到同样的序列，即使是在 Observable 发出元素后才订阅

38.retry

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

39.sample

不定期的对 Observable 取样

40.scan

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

41.shareReplay

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

42.single

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

43.skipUntil

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

44.skipWhile

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

45.startWith

将一些元素插入到序列的头部#46.

47. subscribeOn

指定 Observable 在那个 Scheduler 执行

image

ReactiveX 使用 Scheduler 来让 Observable 支持多线程。你可以使用 subscribeOn 操作符，来指示 Observable 在哪个 Scheduler 执行。

observeOn 操作符非常相似。它指示 Observable 在哪个 Scheduler 发出通知。

image

默认情况下，Observable 创建，应用操作符以及发出通知都会在 Subscribe 方法调用的 Scheduler 执行。subscribeOn 操作符将改变这种行为，它会指定一个不同的 Scheduler 来让 Observable 执行，observeOn 操作符将指定一个不同的 Scheduler 来让 Observable 通知观察者。

如上图所示，subscribeOn 操作符指定 Observable 在那个 Scheduler 开始执行，无论它处于链的那个位置。 另一方面 observeOn 将决定后面的方法在哪个 Scheduler 运行。因此，你可能会多次调用 observeOn 来决定某些操作符在哪个线程运行。

48.take

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

49.takeLast

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

50.takeUntil

忽略掉在第二个 Observable 产生事件后发出的那部分元素
takeUntil 操作符将镜像源 Observable，它同时观测第二个 Observable。一旦第二个 Observable 发出一个元素或者产生一个终止事件，那个镜像的 Observable 将立即终止。

51.takeWhile

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

image

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

52.timeout

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

image

如果 Observable 在一段时间内没有产生元素，timeout 操作符将使它发出一个 error 事件。

53.timer

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

image

timer 操作符将创建一个 Observable，它在经过设定的一段时间后，产生唯一的一个元素。

这里存在其他版本的 timer 操作符。
创建一个 Observable 在一段延时后，每隔一段时间产生一个元素

public static func timer(
_ dueTime: RxTimeInterval, // 初始延时
period: RxTimeInterval?, // 时间间隔
scheduler: SchedulerType
) -> Observable<E>

54.using

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

55.window

将 Observable 分解为多个子 Observable，周期性的将子 Observable 发出来

56.withLatestFrom

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

57.zip

通过一个函数将多个 Observables 的元素组合起来，然后将每一个组合的结果发出来