首先，了解一下下面的代码:
public func example(of description: String, action: () -> Void) {
print("\n--- Example of:", description, "---")
action()
}
我们将使用这个 方法 来封装不同的示例。
一、 Creating observables(创建可观察者)
1、just
（1）含义:
Creates an Observable sequence with a single element.
创建一个序列，这个序列只能发出一个特定的事件，并且可以正常结束（会发出 completed 事件）
在所有 Observable 对象的创建方法中，最简单的就是 just。
（2）图解:
（3）Code:
// MARK: - just
example(of: "just") {
// 1
let one = 1
let two = 2
let three = 3
// 2
let observable: Observable<Int> = Observable<Int>.just(one)
}
以下是上面的代码所做的操作:
- 定义一些您将在以下示例中使用的整数常量。
- 使用 just 方法携带一个 integer 的值，创建一个 Int 类型的可观察序列。
恰如其名，它所做的就是创建一个只包含一个元素的 observable(可观察者序列)。just 是 Observable 的一个类型方法，但是，在 Rx 中，方法被称为 operators(操作符)。
2、of
（1）含义:
Creates an Observable sequence with a fixed number of elements.
创建一个序列，这个序列可以发出很多事件。
（2）图解:
（3）Code:
// MARK: - of
example(of: "of") {
// 1
let one = 1
let two = 2
let three = 3
// 2
let observable2 = Observable.of(one, two, three)
}
这次我们没有明确指定数据类型，你可能会认为，因为我们给它传了几个整数，所以 observable2 的类型是 Observable<[Int]> 。这个时候，通过按住 Option 键单击 observable2，以显示它的推断类型，我们发现 observable2 的类型是 Observable<Int>，而不是一个数组类型 Observable<[Int]>。
如果我们想创建一个可观察的数组，我们可以传递一个数组给 of 操作符。
let observable3 = Observable.of([one, two], [three])
同样的，我们可以看一下 observable3 的推断类型，如下:
这就说明，just 操作符也可以将数组作为单个元素。这个时候，数组作为单个元素，而不是数组中的内容。
3、from
（1）含义:
Creates an Observable sequence from a Sequence, such as an Array, Dictionary, or Set.
创建一个序列，这个序列中的 element 可以来自Array、Dictionary 或
Set。
（2）图解:
（3）Code:
// MARK: - "from"
example(of: "from") {
// 1
let one = 1
let two = 2
let three = 3
// 2
let observable4 = Observable.from([one, two, three])
}
from 从常规的元素数组中创建一个单个类型的实例。
查看 observable4 的推断类型，如下:
元素数组为 [Int] 类型，from 创建出来的 observable4 是 Observable<Int> 类型，而不是 Observable[Int]。
二、 Subscribing to observables(订阅可观察者)
在上面的示例中，我们会发现，所有的示例在控制台中都没有任何打印输出，除了 example 的 header。接下来，我们就需要通过订阅可观察者来实现相关的打印输出。
1、subscribe
(1) 含义
在日常 iOS 编程中，通知模式可以说是使用频率相当高的一个设计模式。我们通过 NotificationCenter 实现消息的广播和订阅。下面是一个典型的通知模式代码用于处理 UIKeyboardDidChangeFrame 消息：
let observer = NotificationCenter.default.addObserver(
forName: .UIKeyboardDidChangeFrame,
object: nil,
queue: nil ) { notification in
// 闭包
}
RxSwift 中的订阅操作也非常简单，只需要调用 subscribe 方法就行了。不过与 NotificationCenter 机制不同的是，RxSwift 中每一个订阅都是唯一的并没有一个类似 default 这样的全局单例对象。
更为重要的是，在没有订阅者的时候 Observable 对象不会发送事件。
(2) Code
// MARK: - subscribe
example(of: "subscribe") {
// 1
let one = 1
let two = 2
let three = 3
// 2
let observable = Observable.of(one, two, three)
// 3
observable
.subscribe({ event in
print(event)
})
}
(3) 结果
--- Example of: subscribe ---
next(1)
next(2)
next(3)
completed
(4) 打印元素
如果想在控制台打印元素，可以通过以下代码:
// 4
observable
.subscribe({ event in
if let element = event.element {
print(element)
}
})
输出结果为:
--- Example of: subscribe ---
1
2
3
(5) 通过 onNext 闭包取值
Observable.of(one, two, three)
.subscribe(onNext: { (element) in
print(element)
})
这里，我们只处理了 .next 事件的元素而忽略了其它所有事件。onNext 闭包接收 .Next 事件的元素作为参数，所以我们不必像之前那样从事件中去检索该元素。
输出结果:
--- Example of: subscribe ---
1
2
3
2、empty
（1）含义:
Creates an empty Observable sequence that only emits a Completed event.
创建一个空的序列，这个序列可以正常结束（只会发出 completed 事件）
（2）图解:
（3）Code:
// MARK: - empty
example(of: "empty") {
let observable = Observable<Any>.empty()
observable
.subscribe(onNext: { (element) in
print(element)
}, onCompleted: {
print("Completed")
})
}
（4）结果:
--- Example of: empty ---
Completed
（5） 什么时候使用 empty
当我们需要返回一个会立即终止的 observable 或者 故意零值的 observable 的时候。
3、never
（1）含义:
Creates a sequence that never terminates and never emits any events.
创建一个序列，这个序列永远不会终止，并且永远不会发出任何事件。
（2）图解:
（3）code:
// MARK: - never
example(of: "never") {
let observable = Observable<Any>.never()
observable
.subscribe(onNext: { (element) in
print(element)
}, onCompleted: {
print("Completed")
})
（4）结果:
--- Example of: never ---
什么都没打印，除了 example header。甚至没有发出 .completed 事件。
4、range
到目前为止，我们学习的都是具有显式变量的 observables。但是它也可以从一系列值中生成一个 observable。
（1）含义:
Creates an Observable sequence that emits a range of sequential integers and then terminates.
创建一个序列，这个序列会发出给定范围中的从开始到结束的所有事件，可以终止。
（2）图解:
（3）code:
// MARK: - range
example(of: "range") {
let observable = Observable.range(start: 1, count: 10)
observable
.subscribe(onNext: {
let n = Double($0)
let fibonacci = Int(((pow(1.61803, n) - pow(0.61803, n)) /
2.23606).rounded())
print(fibonacci)
})
}
（4）结果:
--- Example of: range ---
0
1
2
3
5
8
13
21
34
55
除了 never() 示例之外，到目前为止，我们一直在使用 observable 自动发出 .completed 事件并自然终止。
三、Disposing and terminating(处理和终止)
1、dispose
（1）含义
请记住，在收到订阅之前，observable不会执行任何操作。 它的触发observable开始发出事件的订阅，直到它发出一个 .error 或 .completed 事件并被终止。 你可以手动导致通过取消订阅来观察终止。
（2）Code
// MARK: - dispose
example(of: "dispose") {
// 1
let observable = Observable.of("A", "B", "C")
// 2
observable
.subscribe({ (event) in
print(event)
})
.dispose()
}
（3）输出结果
--- Example of: dispose ---
next(A)
next(B)
next(C)
completed
2、disposeBag
（1）含义
单独管理每个订阅将是乏味的，因此 RxSwift 包括一个DisposeBag类型。一个 DisposeBag 持有 disposables - 通常使用 .disposed(by:) 方法来添加 - 并且当 disposeBag 即将被解除分配时将在每个 disposable 上调用dispose()。
（2）Code
// MARK: - disposeBag
example(of: "disposeBag") {
// 1
let disposeBag = DisposeBag()
// 2
Observable.of("A", "B", "C")
.subscribe({
print($0)
})
.disposed(by: disposeBag)
}
（3）输出结果
--- Example of: disposeBag ---
next(A)
next(B)
next(C)
completed
这是您最常使用的模式; 创建和订阅可观察者，并立即将订阅添加到 disposeBag 中。
3、create
（1）含义:
Creates a custom Observable sequence.
创建一个自定义的序列。
（2）图解:
（3）code:
// MARK: - create
func demo6() {
let disposeBag = DisposeBag()
let observable = { (element: String) -> Observable<String> in
return Observable.create { observer in
observer.onNext(element)
observer.onCompleted()
return Disposables.create()
}
}
observable("123")
.subscribe { event in
print(event)
}
.addDisposableTo(disposeBag)
}
（4）结果:
8、repeatElement
（1）含义:
Creates an Observable sequence that emits the given element indefinitely.
创建一个序列，这个序列可以将特定的事件发送多次。
（2）图解:
（3）code:
// MARK: - repeatElement
func demo8() {
let disposeBag = DisposeBag()
let observable = Observable.repeatElement("🔴")
observable
.take(3)
.subscribe { event in
print(event)
}
.addDisposableTo(disposeBag)
}
（4）结果:
9、generate
（1）含义:
Creates an Observable sequence that generates values for as long as the provided condition evaluates to true.
创建一个序列，当条件为 true 时，就会发出对应的事件。
（2）图解:
（3）code:
// MARK: - generate
func demo9() {
let disposeBag = DisposeBag()
let observable = Observable.generate(
initialState: 0,
condition: { $0 < 5 },
iterate: { $0 + 1 })
observable
.subscribe { event in
print(event)
}
.addDisposableTo(disposeBag)
}
（4）结果:
10、deferred
（1）含义:
Creates a new Observable sequence for each subscriber.
创建一个序列，为每一个订阅者创建一个新的可观察序列。
（2）图解:
（3）code:
// MARK: - deferred
func demo10() {
let disposeBag = DisposeBag()
var count = 1
let deferredSequence = Observable<String>.deferred {
print("Creating \(count)")
count += 1
return Observable.create { observer in
print("Emitting...")
observer.onNext("🐶")
observer.onNext("🐱")
observer.onNext("🐵")
return Disposables.create()
}
}
deferredSequence
.subscribe(onNext: { print($0) })
.addDisposableTo(disposeBag)
deferredSequence
.subscribe(onNext: { print($0) })
.addDisposableTo(disposeBag)
}
（4）结果:
11、error
（1）含义:
Creates an Observable sequence that emits no items and immediately terminates with an error.
创建一个序列，不会发出任何正常事件，只会发送 error 事件，并立即终止。
（2）图解:
（3）code:
// MARK: - error
public enum TestError : Error {
case test
}
func demo11() {
let disposeBag = DisposeBag()
let observable = Observable<Int>.error(TestError.test)
observable
.subscribe {
print($0)
}
.addDisposableTo(disposeBag)
}
（4）结果:
12、doOn
（1）含义:
Invokes a side-effect action for each emitted event and returns (passes through) the original event.
创建一个序列，。
（2）图解:
（3）code:
// MARK: - doOn
func demo12() {
let disposeBag = DisposeBag()
let observable = Observable.of("🍎", "🍐", "🍊", "🍋")
observable
.do(onNext: {
print("Intercepted:", $0)
}, onError: {
print("Intercepted error:", $0)
}, onCompleted: {
print("Completed")
})
.subscribe { event in
print(event)
}
.addDisposableTo(disposeBag)
}
（4）结果:
