三、Observable 介紹
Observable 作為 Rx 的根基，我們首先對它要有一些基本的了解。
1，Observable<T>
-
Observable<T>這個類就是Rx框架的基礎，我們可以稱它為可觀察序列。它的作用就是可以異步地產生一系列的Event（事件），即一個Observable<T>對象會隨著時間推移不定期地發出event(element : T)這樣一個東西。 - 而且這些
Event還可以攜帶數據，它的泛型<T>就是用來指定這個Event攜帶的數據的類型。 - 有了可觀察序列，我們還需要有一個
Observer（訂閱者）來訂閱它，這樣這個訂閱者才能收到Observable<T>不時發出的Event。
2，Event
查看 RxSwift 源碼可以發現，事件 Event 的定義如下：
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
}
可以看到 Event 就是一個枚舉，也就是說一個 Observable 是可以發出 3 種不同類型的 Event 事件：
-
next：
next事件就是那個可以攜帶數據<T>的事件，可以說它就是一個“最正常”的事件。
-
error：
error事件表示一個錯誤，它可以攜帶具體的錯誤內容，一旦Observable發出了error event，則這個Observable就等于終止了，以后它再也不會發出event事件了。
-
completed：
completed事件表示Observable發出的事件正常地結束了，跟error一樣，一旦Observable發出了completed event，則這個Observable就等于終止了，以后它再也不會發出event事件了。
3，Observable 與 Sequence比較
（1）為更好地理解，我們可以把每一個 Observable 的實例想象成于一個 Swift 中的 Sequence：
- 即一個
Observable（ObservableType）相當于一個序列Sequence（SequenceType）。 -
ObservableType.subscribe(_:)方法其實就相當于SequenceType.generate()
（2）但它們之間還是有許多區別的：
-
Swift中的SequenceType是同步的循環，而Observable是異步的。 -
Observable對象會在有任何Event時候，自動將Event作為一個參數通過ObservableType.subscribe(_:)發出，并不需要使用next方法。
四、創建 Observable 序列
我們可以通過如下幾種方法來創建一個 Observable序列
1，just() 方法
（1）該方法通過傳入一個默認值來初始化。
（2）下面樣例我們顯式地標注出了 observable 的類型為 Observable<Int>，即指定了這個 Observable所發出的事件攜帶的數據類型必須是 Int 類型的。
let observable = Observable<Int>.just(5)
2，of() 方法
（1）該方法可以接受可變數量的參數（必需要是同類型的）
（2）下面樣例中我沒有顯式地聲明出 Observable 的泛型類型，Swift 也會自動推斷類型。
let observable = Observable.of("A", "B", "C")
3，from() 方法
（1）該方法需要一個數組參數。
（2）下面樣例中數據里的元素就會被當做這個 Observable 所發出 event攜帶的數據內容，最終效果同上面餓 of()樣例是一樣的。
let observable = Observable.from(["A", "B", "C"])
4，empty() 方法
該方法創建一個空內容的 Observable 序列。
let observable = Observable<Int>.empty()
5，never() 方法
該方法創建一個永遠不會發出 Event（也不會終止）的 Observable 序列。
let observable = Observable<Int>.never()
6，error() 方法
該方法創建一個不做任何操作，而是直接發送一個錯誤的 Observable 序列。
enum MyError: Error {
case A
case B
}
let observable = Observable<Int>.error(MyError.A)
7，range() 方法
（1）該方法通過指定起始和結束數值，創建一個以這個范圍內所有值作為初始值的Observable序列。
（2）下面樣例中，兩種方法創建的 Observable 序列都是一樣的。
//使用range()
let observable = Observable.range(start: 1, count: 5)
//使用of()
let observable = Observable.of(1, 2, 3 ,4 ,5)
8，repeatElement() 方法
該方法創建一個可以無限發出給定元素的 Event的 Observable 序列（永不終止）。
let observable = Observable.repeatElement(1)
9，generate() 方法
（1）該方法創建一個只有當提供的所有的判斷條件都為 true 的時候，才會給出動作的 Observable 序列。
（2）下面樣例中，兩種方法創建的 Observable 序列都是一樣的。
//使用generate()方法
let observable = Observable.generate(
initialState: 0,
condition: { $0 <= 10 },
iterate: { $0 + 2 }
)
//使用of()方法
let observable = Observable.of(0 , 2 ,4 ,6 ,8 ,10)
10，create() 方法
（1）該方法接受一個 block 形式的參數，任務是對每一個過來的訂閱進行處理。
（2）下面是一個簡單的樣例。為方便演示，這里增加了訂閱相關代碼（關于訂閱我之后會詳細介紹的）。
//這個block有一個回調參數observer就是訂閱這個Observable對象的訂閱者
//當一個訂閱者訂閱這個Observable對象的時候，就會將訂閱者作為參數傳入這個block來執行一些內容
let observable = Observable<String>.create{observer in
//對訂閱者發出了.next事件，且攜帶了一個數據"hangge.com"
observer.onNext("hangge.com")
//對訂閱者發出了.completed事件
observer.onCompleted()
//因為一個訂閱行為會有一個Disposable類型的返回值，所以在結尾一定要returen一個Disposable
return Disposables.create()
}
//訂閱測試
observable.subscribe {
print($0)
}
運行結果如下：
11，deferred() 方法
（1）該個方法相當于是創建一個 Observable 工廠，通過傳入一個 block 來執行延遲 Observable序列創建的行為，而這個 block 里就是真正的實例化序列對象的地方。
（2）下面是一個簡單的演示樣例：
//用于標記是奇數、還是偶數
var isOdd = true
//使用deferred()方法延遲Observable序列的初始化，通過傳入的block來實現Observable序列的初始化并且返回。
let factory : Observable<Int> = Observable.deferred {
//讓每次執行這個block時候都會讓奇、偶數進行交替
isOdd = !isOdd
//根據isOdd參數，決定創建并返回的是奇數Observable、還是偶數Observable
if isOdd {
return Observable.of(1, 3, 5 ,7)
}else {
return Observable.of(2, 4, 6, 8)
}
}
//第1次訂閱測試
factory.subscribe { event in
print("\(isOdd)", event)
}
//第2次訂閱測試
factory.subscribe { event in
print("\(isOdd)", event)
}
運行結果如下，可以看到我們兩次訂閱的得到的 Observable 是不一樣的：
12，interval() 方法
（1）這個方法創建的 Observable 序列每隔一段設定的時間，會發出一個索引數的元素。而且它會一直發送下去。
（2）下面方法讓其每 1 秒發送一次，并且是在主線程（MainScheduler）發送。
let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable.subscribe { event in
print(event)
}
運行結果如下：
13，timer() 方法
（1）這個方法有兩種用法，一種是創建的 Observable序列在經過設定的一段時間后，產生唯一的一個元素。
//5秒種后發出唯一的一個元素0
let observable = Observable<Int>.timer(5, scheduler: MainScheduler.instance)
observable.subscribe { event in
print(event)
}
運行結果如下：
（2）另一種是創建的 Observable 序列在經過設定的一段時間后，每隔一段時間產生一個元素。
//延時5秒種后，每隔1秒鐘發出一個元素
let observable = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
observable.subscribe { event in
print(event)
}
運行結果如下：
