Observable生命周期
- 发出next事件，可以继续发出事件
- 发出error事件，Observable生命结束，不能继续发出事件
- 发出completed事件，Observable生命结束，不能继续发出事件
RxSwift事件定义：
/// Represents a sequence event.
///
/// Sequence grammar:
/// **next\* (error | completed)**
public enum Event<Element> {
/// Next element is produced.
case next(Element)
/// Sequence terminated with an error.
case error(Swift.Error)
/// Sequence completed successfully.
case completed
}
创建Observable
just
// 1
let one = 1
let two = 2
let three = 3
// 2
let observable: Observable<Int> = Observable<Int>.just(one)
创建一个序列，只包含一个元素。
of
let observable = Observable.of(one, two, three)
of包含多个元素。
from
let observable = Observable.from([one, two, three])
from包含一个集合，可以是数组，集合，字典，Observable会拆解这个数组，一个个发出元素。
empty
let observable = Observable<Void>.empty()
empty不包含任何元素，只会发出一个Completed事件。必须指定元素类型，因为没有元素让Swift来推导类型。这里用Void类型没有实际意义，只是表示没有值而已，其他类型也可以。
never
let observable = Observable<Any>.never()
never不发送任何事件，也永远不会结束。这里类型Any的意义和上面的Void一样。
range
let observable = Observable<Int>.range(start: 1, count: 10)
range应该很好理解。
上面的创建Observable的方法都可以看做是方便方法，实际的定制方法是下面的create
create
Observable<String>.create { observer in
// 1
observer.onNext("1")
// 2
observer.onCompleted()
return Disposables.create()
}
deferred
let disposeBag = DisposeBag()
// 1
var flip = false
// 2
let factory: Observable<Int> = Observable.deferred {
// 3
flip = !flip
// 4
if flip {
return Observable.of(1, 2, 3)
} else {
return Observable.of(4, 5, 6)
}
}
和create不同的地方是，create会捕获外面传入的变量，而deferred不会捕获变量，会在每次订阅时，创建deferred闭包。
参考
可以不用指明元素类型，Swift可以推导出。
订阅Observable
Observable只有被订阅了才会发出事件。
这个机制就像Swift里的sequence迭代器，每次调用next()，取一个值。
let sequence = 0..<3
var iterator = sequence.makeIterator()
while let n = iterator.next() {
print(n)
}
/*
Prints:
0
1
2
*/
Subscribe定义：
/**
Subscribes an event handler to an observable sequence.
- parameter on: Action to invoke for each event in the observable sequence.
- returns: Subscription object used to unsubscribe from the observable sequence.
*/
func subscribe(_ on: @escaping (Event<E>) -> Void)
-> Disposable
传入Event<E>枚举类型
/**
Subscribes an element handler, an error handler, a completion handler and disposed handler to an observable sequence.
- parameter onNext: Action to invoke for each element in the observable sequence.
- parameter onError: Action to invoke upon errored termination of the observable sequence.
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
- parameter onDisposed: Action to invoke upon any type of termination of sequence (if the sequence has
gracefully completed, errored, or if the generation is canceled by disposing subscription).
- returns: Subscription object used to unsubscribe from the observable sequence.
*/
public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
-> Disposable
直接传入元素E
Dispose
结束一个订阅，防止内存泄漏:
类似于MRC时代，内存管理中的relase，和autorelase
如果要立即释放订阅者，直接dispose()
// 1
let observable = Observable.of("A", "B", "C")
// 2
let subscription = observable.subscribe { event in
// 3
print(event)
}
subscription.dispose()
注意，这里的
dispose()会立即执行，结束订阅。真实环境中，要依情况而定。
disposeBag
// 1
let disposeBag = DisposeBag()
// 2
Observable.of("A", "B", "C").subscribe { // 3
print($0)
}
.disposed(by: disposeBag) // 4
注意，这里的
disposeBag是局部变量，执行完了就会释放。真实环境中，要依情况而定。加入disposeBag里面的订阅者什么时候释放？1.在disposeBag释放的时候；2.订阅者本身结束事件发生，例如发送error，completed事件。
使用Trait
使用不同的方法实现同样的功能，目的是使代码跟可读。下面是取代Observable的对象：
Single
只发送一次.success(value)或者.error事件。
Single.create { single in
let disposable = Disposables.create()
single(.error(FileReadError.fileNotFound))
single(.success(contents))
return disposable
}
可以用.asSingle()转Observable
Completable
只发送一次.completed或者.error事件。
Maybe
只发送一次发送.success(value)，.completed或者.error事件。
可以用.asMaybe()转Observable。
