RxSwift（3）— Observable序列的建立方式

時間 2019-11-06

標籤 rxswift observable 序列建立方式简体版

原文原文鏈接

就問此時此刻還有誰？45度仰望天空，該死！我這無處安放的魅力！swift

RxSwift（1）— 初探

RxSwift（2）— 核心邏輯源碼分析

RxSwift（3）— Observable序列的建立方式

RxSwift（4）— 高階函數（上）

RxSwift（5）— 高階函數（下）

RxSwift（6）— 調度者-scheduler源碼解析（上）

RxSwift（7）— 調度者-scheduler源碼解析（下）

RxSwift（8）— KVO底層探索（上）

RxSwift（9）— KVO底層探索（下）

RxSwift（10）— 場景序列總結

RxSwift（11）— dispose源碼解析

RxSwift（12）— Subject即攻也守

RxSwift（13）— 爬過的坑

RxSwift（14）— MVVM雙向綁定

RxSwift 目錄直通車 --- 和諧學習，不急不躁！數組

序列在RxSwift的世界裏面是很是重要，平時開發過程用好序列的建立，可以給開發帶來事半功倍的效果！這個篇章總結了經常使用的序列建立方式安全

1：emty

首先來一個空的序列 - 原本序列事件是Int類型的,這裏調用emty函數 沒有序列,只能completebash

print("********emty********")
let emtyOb = Observable<Int>.empty()
_ = emtyOb.subscribe(onNext: { (number) in
    print("訂閱:",number)
}, onError: { (error) in
    print("error:",error)
}, onCompleted: {
    print("完成回調")
}) {
    print("釋放回調")
}
複製代碼

這種方式不經常使用，可是咱們以點及面展開分析
經過源碼解析查看

override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
    observer.on(.completed)
    return Disposables.create()
}
複製代碼

很明顯在訂閱的時候，直接observer.on(.completed) 發送了完成信號，很是簡潔

2： just

單個信號序列建立
該方法經過傳入一個默認值來初始化，構建一個只有一個元素的Observable隊列，訂閱完信息自動complete。
下面的樣例，咱們顯示地標註出了Observable的類型爲Observable<[String]>，即指定了這個 Observable 所發出的事件攜帶的數據類型必須是String 類型的

print("********just********")
//MARK: just
// 單個信號序列建立
let array = ["LG_Cooci","LG_Kody"]
Observable<[String]>.just(array)
    .subscribe { (event) in
        print(event)
    }.disposed(by: disposeBag)

_ = Observable<[String]>.just(array).subscribe(onNext: { (number) in
    print("訂閱:",number)
}, onError: { (error) in
    print("error:",error)
}, onCompleted: {
    print("完成回調")
}) {
    print("釋放回調")
}
複製代碼

感受有點數據便利的感受
這個序列在平時開發裏面仍是應用挺多的，看看底層源碼

override func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == Element {
    observer.on(.next(self._element))
    observer.on(.completed)
    return Disposables.create()
}
複製代碼

observer.on(.next(self._element))常規訂閱以後就會發送.next事件
以後就會自動發送完成事件，跟咱們效果徹底吻合

3：of

此方法建立一個新的可觀察實例，該實例具備可變數量的元素。
該方法能夠接受可變數量的參數（必須要是同類型的）

print("********of********")
//MARK: of
// 多個元素 - 針對序列處理
Observable<String>.of("LG_Cooci","LG_Kody")
    .subscribe { (event) in
        print(event)
    }.disposed(by: disposeBag)

// 字典
Observable<[String: Any]>.of(["name":"LG_Cooci","age":18])
    .subscribe { (event) in
        print(event)
    }.disposed(by: disposeBag)

// 數組
Observable<[String]>.of(["LG_Cooci","LG_Kody"])
    .subscribe { (event) in
        print(event)
    }.disposed(by: disposeBag)
複製代碼

不管字典,數組，多個元素都是正常使用
底層源碼的結構也是中規中矩
初始化保存調度環境和傳入的元素
訂閱流程也是利用sink,而後經過mutableIterator迭代器處理髮送

4：from

將可選序列轉換爲可觀察序列。
從集合中獲取序列:數組,集合,set 獲取序列 - 有可選項處理 - 更安全

print("********from********")
// MARK: from
Observable<[String]>.from(optional: ["LG_Cooci","LG_Kody"])
    .subscribe { (event) in
        print(event)
    }.disposed(by: disposeBag)
複製代碼

self._optional = optional底層初始化可選項保存
訂閱流程判斷是否匹配咱們的可選項
發送observer.on(.next(element))序列 * 隨即自動observer.on(.completed)完成序列發送

5：deferred

返回一個可觀察序列，該序列在新觀察者訂閱時調用指定的工廠函數。
這裏有一個需求:動態序列 - 根據外界的標識 - 動態輸出
使用deferred()方法延遲Observable序列的初始化，經過傳入的block來實現Observable序列的初始化而且返回。

print("********defer********")
//MARK: defer
var isOdd = true
_ = Observable<Int>.deferred { () -> Observable<Int> in
    // 這裏設計咱們的序列
    isOdd = !isOdd
    if isOdd {
        return Observable.of(1,3,5,7,9)
    }
    return Observable.of(0,2,4,6,8)
    }
    .subscribe { (event) in
        print(event)
    }
複製代碼

self._observableFactory = observableFactory初始化保存了這段工廠閉包

func run() -> Disposable {
    do {
        let result = try self._observableFactory()
        return result.subscribe(self)
    }
    catch let e {
        self.forwardOn(.error(e))
        self.dispose()
        return Disposables.create()
    }
}
複製代碼

在訂閱流程到sink的時候，把這段工廠閉包執行
有種中間層被包裝的感受

6：rang

使用指定的調度程序生成併發送觀察者消息，生成指定範圍內的可觀察整數序列。

print("********rang********")
//MARK: rang
Observable.range(start: 2, count: 5)
    .subscribe { (event) in
        print(event)
    }.disposed(by: disposeBag)

// 底層源碼
init(start: E, count: E, scheduler: ImmediateSchedulerType) {
    self._start = start
    self._count = count
    self._scheduler = scheduler
}

override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == E {
    let sink = RangeSink(parent: self, observer: observer, cancel: cancel)
    let subscription = sink.run()
    return (sink: sink, subscription: subscription)
}
複製代碼

保存序列中第一個整數的值。
保存要生成的順序整數的數目。
保存調度環境

if i < self._parent._count {
    self.forwardOn(.next(self._parent._start + i))
    recurse(i + 1)
}
else {
    self.forwardOn(.completed)
    self.dispose()
}
複製代碼

根據以前保存的信息，數據的狀態也不斷攀升，而後遞歸到規定的要求

7：generate

經過運行產生序列元素的狀態驅動循環，使用指定的調度程序運行循環，發送觀察者消息，從而生成一個可觀察序列。
該方法建立一個只有當提供的全部的判斷條件都爲 true 的時候，纔會給出動做的 Observable 序列。
初始值給定而後判斷條件1 再判斷條件2 會一直遞歸下去,直到條件1或者條件2不知足
相似數組遍歷循環
-參數一initialState: 初始狀態。
-參數二 condition：終止生成的條件(返回「false」時)。
-參數三 iterate：迭代步驟函數。
-參數四調度器：用來運行生成器循環的調度器，默認：CurrentThreadScheduler.instance。
-返回：生成的序列。

print("********generate********")
//MARK: generate
Observable.generate(initialState: 0,// 初始值
                    condition: { $0 < 10}, // 條件1
                    iterate: { $0 + 2 })  // 條件2 +2
    .subscribe { (event) in
        print(event)
    }.disposed(by: disposeBag)

// 數組遍歷
let arr = ["LG_Cooci_1","LG_Cooci_2","LG_Cooci_3","LG_Cooci_4","LG_Cooci_5","LG_Cooci_6","LG_Cooci_7","LG_Cooci_8","LG_Cooci_9","LG_Cooci_10"]
Observable.generate(initialState: 0,// 初始值
    condition: { $0 < arr.count}, // 條件1
    iterate: { $0 + 1 })  // 條件2 +2
    .subscribe(onNext: {
        print("遍歷arr:",arr[$0])
    })
    .disposed(by: disposeBag)
複製代碼

8：timer

返回一個可觀察序列，該序列使用指定的調度程序運行計時器，在指定的初始相對到期時間事後按期生成一個值。
第一次參數:第一次響應距離如今的時間
第二個參數:時間間隔
第三個參數:線程

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

// 由於沒有指按期限period,故認定爲一次性
Observable<Int>.timer(1, scheduler: MainScheduler.instance)
    .subscribe { (event) in
        print("111111111 \(event)")
    }
    //.disposed(by: disposeBag)
複製代碼

狀態碼的不斷攀升，間隔時間不斷髮送響應

9：interval

返回一個可觀察序列，該序列在每一個週期以後生成一個值，使用指定的調度程序運行計時器併發送觀察者消息。

print("********interval********")
//MARK: interval
// 定時器
Observable<Int>.interval(1, scheduler: MainScheduler.instance)
    .subscribe { (event) in
        print(event)
    }
    //.disposed(by: disposeBag)
複製代碼

9：repeatElement

使用指定的調度程序發送觀察者消息，生成無限重複給定元素的可觀察序列。

print("********repeatElement********")
//MARK: repeatElement
Observable<Int>.repeatElement(5)
    .subscribe { (event) in
        // print("訂閱:",event)
    }
    .disposed(by: disposeBag)
複製代碼

10：error

返回一個以「error」結束的可觀察序列。
這個序列平時在開發也比較常見，請求網絡失敗也會發送失敗信號！

print("********error********")
//MARK: error
// 對消費者發出一個錯誤信號
Observable<String>.error(NSError.init(domain: "lgerror", code: 10086, userInfo: ["reason":"unknow"]))
    .subscribe { (event) in
        print("訂閱:",event)
    }
    .disposed(by: disposeBag)
複製代碼

11：never

該方法建立一個永遠不會發出 Event（也不會終止）的 Observable 序列。
這種類型的響應源在測試或者在組合操做符中禁用確切的源很是有用

print("********never********")
//MARK: never
Observable<String>.never()
    .subscribe { (event) in
        print("走你",event)
    }
    .disposed(by: disposeBag)
print("********never********") 
複製代碼

12：create()

該方法接受一個閉包形式的參數，任務是對每個過來的訂閱進行處理。
下面是一個簡單的樣例。爲方便演示，這裏增長了訂閱相關代碼
這也是序列建立的通常方式，應用很是之多

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)
}
複製代碼

序列的建立也是學習 RxSwift 的根基，有不少時候我遇到不少的BUG,說白了就是根基沒有掌握好！如今咱們的已經RxSwift第十節課上完了,不少同窗對RxSwift有了一個比較深刻的瞭解，固然這裏我仍是以博客的形式寫出來，就是但願你們可以及時回來看看，我知道，確定會有不少同窗回來繼續加深基礎的！網絡

就問此時此刻還有誰？45度仰望天空，該死！我這無處安放的魅力！閉包

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。