Observable介紹

Observable作為RxSwift的基礎，一切的根基基于此，因此，想要透徹理解RxSwift，我們也要對Observable要有一些基本的了解。

Observable<T>

1. Observable<T>這個類是RxSwift框架的基礎，通常我們把它稱作為可觀察序列，它存在的作用就是可以異步的產生一系列的Event事件。
2. 產生的這些Event事件還可以攜帶數據，那么泛型<T>就是用來傳遞這個Event事件攜帶的數據的類型。
3. 那么既然有了Observable可觀察序列，我們還需要一個Observer（訂閱者）來訂閱它，這樣這個訂閱者才能收到發(fā)出的Event事件

Event事件

我們進入RxSwift的源碼查看，可以發(fā)現事件Eventd的定義如下：

/// 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
}

我們可以看到，Event其實就是一個枚舉，因此，可以知道Observable可以發(fā)出3種不同類型的Event事件：

next：next事件就是通常攜帶數據<T>的事件。

屏幕快照 2019-07-28 09.34.27.png

error：error事件表示一個錯誤，它攜帶了具體錯誤內容，只要Observable發(fā)出了error event，Observable就會終止，不會再發(fā)出error事件了。

屏幕快照 2019-07-28 09.40.56.png

completed：completed事件表示Observable發(fā)出的事件完成了，和error一樣，只要Observable發(fā)出后就終止，不在發(fā)出event事件。

屏幕快照 2019-07-28 09.46.01.png

Observable 與 Sequence比較

1. 為更好地理解，我們可以把每一個 Observable的實例想象成于一個Swift中的 Sequence：

• 即一個 Observable（ObservableType）相當于一個序列 Sequence（SequenceType）。
• ObservableType.subscribe(_:) 方法其實就相當于 SequenceType.generate()

2. 區(qū)別：

• Swift 中的 SequenceType 是同步的循環(huán)，而 Observable 是異步的。
• Observable 對象會在有任何 Event 時候，自動將 Event 作為一個參數通過 ObservableType.subscribe(_:) 發(fā)出，并不需要使用 next 方法。

創(chuàng)建 Observable 序列

RxSwift為我們提供了以下幾種方法來創(chuàng)建一個Observable序列。

just()方法

1. 該方法通過傳入一個默認值來初始化，構建一個只有一個元素的Observable隊列，訂閱完信息自動complete。
2. 下面的樣例，我們顯示地標注出了Observable的類型為Observable<Int>，即指定了這個 Observable 所發(fā)出的事件攜帶的數據類型必須是 Int 類型的。

let observable = Observable<Int>.just(5)

of()方法

1. 該方法可以接受可變數量的參數（必需要是同類型的），創(chuàng)建一個固定數量元素的Observable序列。
2. 下面樣例中我們沒有顯式地聲明出 Observable 的泛型類型，Swift 也會自動推斷類型。

let observable = Observable.of("A", "B", "C")

from()方法

1. 該方法需要一個數組/字典/集合參數，這樣的一個序列中創(chuàng)建一個Observable序列。
2. 下面樣例中數據里的元素就會被當做這個 Observable 所發(fā)出 event 攜帶的數據內容，最終效果同上面of() 樣例是一樣的。

let observable = Observable.from(["A", "B", "C"])

empty()方法

1. 該方法創(chuàng)建一個空內容的 Observable 序列，但是只能訂閱到complete。

let observable = Observable<Int>.empty()

never()方法

1. 該方法創(chuàng)建一個永遠不會發(fā)出 Event（也不會終止）的 Observable 序列。

let observable = Observable<Int>.never()

error()方法

1. 該方法創(chuàng)建一個不做任何操作，而是直接發(fā)送一個錯誤的 Observable 序列。

enum MyError: Error {
    case A
    case B
}
         
let observable = Observable<Int>.error(MyError.A)

range()方法

1. 該方法通過指定起始和結束數值，創(chuàng)建一個以這個范圍內所有值作為初始值的 Observable 序列。
2. 下面兩種方法創(chuàng)建的 Observable 序列都是一樣的。

//使用range()
let observable = Observable.range(start: 1, count: 5)
 
//使用of()
let observable = Observable.of(1, 2, 3 ,4 ,5)

repeatElement()方法

1. 該方法創(chuàng)建一個可以無限發(fā)出給定元素的 Event 的 Observable 序列（永不終止）。

let observable = Observable.repeatElement(1)

generate()方法

1. 該方法創(chuàng)建一個只有當提供的所有的判斷條件都為 true 的時候，才會給出動作的 Observable 序列。
2. 兩種方法創(chuàng)建的 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)

create()方法

1. 該方法接受一個 block形式的參數，任務是對每一個過來的訂閱進行處理。
2. 下面的樣例增加了訂閱相關代碼（訂閱的內容，以后講）。

//這個block有一個回調參數observer就是訂閱這個Observable對象的訂閱者
//當一個訂閱者訂閱這個Observable對象的時候，就會將訂閱者作為參數傳入這個block來執(zhí)行一些內容
let observable = Observable<String>.create{observer in
    //對訂閱者發(fā)出了.next事件，且攜帶了一個數據"hangge.com"
    observer.onNext("hangge.com")
    //對訂閱者發(fā)出了.completed事件
    observer.onCompleted()
    //因為一個訂閱行為會有一個Disposable類型的返回值，所以在結尾一定要returen一個Disposable
    return Disposables.create()
}
 
//訂閱測試
observable.subscribe {
    print($0)
}

deferred()方法

1. 該個方法相當于是創(chuàng)建一個 Observable 工廠，通過傳入一個 block 來執(zhí)行延遲 Observable 序列創(chuàng)建的行為，而這個 block 里就是真正的實例化序列對象的地方。
2. 演示樣例：

//用于標記是奇數、還是偶數
var isOdd = true
 
//使用deferred()方法延遲Observable序列的初始化，通過傳入的block來實現Observable序列的初始化并且返回。
let factory : Observable<Int> = Observable.deferred {
     
    //讓每次執(zhí)行這個block時候都會讓奇、偶數進行交替
    isOdd = !isOdd
     
    //根據isOdd參數，決定創(chuàng)建并返回的是奇數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)
}

interval()方法

1. 這個方法創(chuàng)建的 Observable 序列每隔一段設定的時間，會發(fā)出一個索引數的元素。而且它會一直發(fā)送下去。那么，它的底層其實就是封裝timer。
2. 下面方法讓其每 1 秒發(fā)送一次，并且是在主線程MainScheduler發(fā)送。

let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}

timer()方法

1. 這個方法有兩種用法，一種是創(chuàng)建的 Observable 序列在經過設定的一段時間后，產生唯一的一個元素。

//5秒種后發(fā)出唯一的一個元素0
let observable = Observable<Int>.timer(5, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}

2. 另一種是創(chuàng)建的 Observable序列在經過設定的一段時間后，每隔一段時間產生一個元素。

//延時5秒種后，每隔1秒鐘發(fā)出一個元素
let observable = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}

最后，感謝一下我們的航歌。