Observable介紹

Observable<T>類是RxSwift框架的基礎。其作用就像是一條流水線，讓觀察者可以實時獲取對所有可觀察對象所觸發的事件，也就是說以此來實現對UI的實時更新或數據、事件等實時處理。
與之前介紹RAC類似，Observable對象所觸發的事件有：
next，觸發時將可觀察對象的新值傳遞給觀察者
completed，可觀察對象的生命周期正常結束并不再響應觸發事件
error，可觀察對象出現錯誤導致其生命周期終止

貼一個最基本的Observable的創建與訂閱代碼

        //創建Observable
        let ob = Observable<Any>.create { (anyObser) -> Disposable in
            print("this is a observable create")
            print(anyObser)
            
            anyObser.onNext("執行下一步")
            anyObser.onCompleted()
            anyObser.onNext("執行第二步")
            anyObser.onError(testError.errorB)
            
            return Disposables.create()
        }
        
        //訂閱Observable
        ob.subscribe(onNext: { (signal) in
            print("next === \(signal)")
        }, onError: { (error) in
            print("error == \(error)")
        }, onCompleted: {
            print("完成訂閱")
        }) {
            print("銷毀訂閱")
        }.disposed(by: disposeBag)  //disposeBag為創建的垃圾包

接觸過RAC系列的，會發現RxSwift語法結構非常相似。此處特意把error事件放在completed事件之后，打印結果證明，觀察者在觸發complete事件之后不會再響應任何事件。

打印結果

Observable創建

以下列出Observable各種創建的方法，以及對應不同的使用場景

just方法

該方法通過傳入一個默認值來初始化

        let createJustObservable = Observable.just("one")
        createJustObservable
.subscribe { (event) in
            print(event)
        }.disposed(by: disposeBag)

//為了方便查看，將上述代碼合并
        Observable.just("one")
            .subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

of方法

該方法可以接受可變數量的參數傳入，但必需時同類型的

        Observable.of("o","f","of").subscribe { (event) in
            print(event)
            }.disposed(by: disposeBag)

from方法

該方法需要一個數組參數傳入

        Observable.from(["f","r","o","m"]).subscribe { (event) in
            print(event)
            }.disposed(by: disposeBag)

never方法

該方法創建一個永遠不會發出 Event（也不會終止）的 Observable 序列

        Observable<Int>.never()
            .subscribe { (event) in
            print(event)
            }
            .disposed(by: disposeBag)

empty方法

該方法創建一個空內容的 Observable 序列，執行時直接執行completed方法

        Observable<Int>.empty()
            .subscribe { (event) in
            print(event)
            }
            .disposed(by: disposeBag)

error方法

該方法創建一個不做任何操作，而是直接發送一個錯誤的 Observable 序列

//首先創建一個error類型的枚舉
enum MyError:Error {
    case A
    case B
    var errorType:String {
        switch self {
        case .A:
            return "i am error A"
        case .B:
            return "BBBB"
        }
    }
}

        let myError = MyError.A
        //        print(myError.errorType)
        Observable<Int>.error(myError)
            .subscribe { (event) in
            print(event)
            }
            .disposed(by: disposeBag)

range方法

該方法通過指定起始和結束數值，創建一個以這個范圍內所有值作為初始值的Observable序列

        Observable
            .range(start: 1, count: 6)
            .subscribe { (event) in
            print(event)
            }
            .disposed(by: disposeBag)

repeatElement方法

該方法創建一個可以無限發出給定元素的 Event的 Observable 序列（永不終止）

            Observable.repeatElement("repeat")
                .subscribe { (event) in
                print(event)
            }
                .disposed(by: disposeBag)

generate方法

該方法創建一個只有當提供的所有的判斷條件都為 true 的時候，才會給出動作的 Observable 序列

        //第一個參數：初始化的數值為0
        //第二個參數：判斷條件閉包第一個元素$0是否小于等于10
        //第三個參數：使$0的int值+2
        //若判斷條件為true，依次循環下去
        Observable
            .generate(initialState: 0, condition: {$0<=10}, iterate: {$0+2})
            .subscribe { (event) in
            print(event)
            }
            .disposed(by: disposeBag)

上面的方法也可以用of方法表示，但靈活性不足

        Observable.of(0,2,4,6,8,10)
            .subscribe { (event) in
            print(event)
            }
            .disposed(by: disposeBag)

deferred方法

該方法相當于是創建一個 Observable 工廠，通過傳入一個 block 來執行延遲 Observable序列創建的行為，而這個 block 里才是真正的實例化Observable序列對象

        //此處也可將isOdd屬性修改為false來查看結果
        var isOdd = true
        let factory: Observable<Int> = Observable
            .deferred { () -> Observable<Int> in
            
            isOdd = !isOdd
            if isOdd{
                return Observable.of(0,2,4,6,8)
            }else{
                return Observable.of(1,3,5,7,9)
            }
        }
        
        factory.subscribe { (event) in
            print("\(isOdd)",event)
            }
            .disposed(by: disposeBag)

interval和timer方法

這兩個方法都是創建的 Observable 序列每隔一段設定的時間，會發出一個索引數的元素，而且會一直發送

        Observable<Int>
            .timer(1, scheduler: MainScheduler.instance).subscribe{(event) in
            print("scheduler",event)
        }
            .disposed(by: disposeBag)


        Observable<Int>
            .timer(5, period: 1, scheduler: MainScheduler.instance).subscribe { (event) in
            print("timer",event)
            }
            .disposed(by: disposeBag)

Observable訂閱與銷毀

與 RAC 的訂閱信號方法非常類似，使用過程中是需要在需要訂閱 Observable 的地方調用 subscribe 方法即可。在RxSwift中每一個訂閱都是唯一的，而且沒有一個類似NotificationCenter通知機制 default 這樣的全局單例對象。當沒有訂閱者時，Observable 對象不會發送通知。
在創建Observable時，在訂閱任何不同的觀察者之后，代碼一定會添加一行 .disposed(by: disposeBag) 代碼，而 disposeBag 是之前全局創建生成的let disposeBag = DisposeBag()。此處代碼是將所有的訂閱者通過RxSwift提供的集中銷毀管理垃圾包來集中銷毀訂閱信號。若不這么做，Observable 對象在生命周期完結時會存在內存泄漏的問題引發崩潰。

該文章首次發表在 簡書：我只不過是出來寫寫代碼 博客，并自動同步至 騰訊云：我只不過是出來寫寫iOS 博客