RxSwift Observable Create

目錄:

RxSwift - 入門
RxSwift Observable Create
RxSwift Subject
RxSwift Combination Operators
RxSwift Transforming Operators
RxSwift Filterning and conditional operators
RxSwift Mathematical and aggregate operators
RxSwift Connectable Operators
RxSwift ErrorHandding Operators
RxSwift Debug Operators


Demo地址


Create Observables

上一節(jié)中，我們從一個數組中大概的理解了一下Observable，現在讓我們用Rx的形式去把上節(jié)的內容在實現一次

假設你還沒有安裝RxSwift到你的項目中，可以參考官方文檔，查看如何把RxSwift導入到工程中，過程很簡單。

當你把上一步做完之后，就可以進入正題了。

1、新建一個Observable

 Observable.of(1,2,3,4,5,6,7,8) 
//or
 Observable.form([1,2,3,4,5,6,7,8])

2、然后對數據進行過濾Filter

 Observable.of(1,2,3,4,5,6,7,8)
    .filter { $0 % 2 == 0 }

3、最后讓我們把處理之后的結果訂閱一下

 Observable.of(1,2,3,4,5,6,7,8)
    .filter { $0 % 2 == 0 }
    .subscribe(
        onNext: { num in 
            print(num)
        }
    )

4、最后運行起來，其結果應該如下:

2
4
6
8

然后作為程序員的你，一定注意到了這樣子一行提示

Result of call to 'subscribe(onNext:onError:onCompleted:onDisposed:)' is unused,

雖然代碼正常運行了，其結果也和我們預料的一致，但是這個提示究竟是想表達寫什么呢？僅僅是告訴我們返回值沒有用么？

—————————————————— 我是一條華麗麗的分割線——————————————————

結果當然不是啦，如果僅僅是因為返回值沒有被使用而提示這個警告，大可以用@discardableResult修飾啦，如果你有看過官方的Demo的話，就可以看到在官方的示例中:


    let disposeBag = DisposeBag()
    let neverSequence = Observable<String>.never()
    
    let neverSequenceSubscription = neverSequence
        .subscribe { _ in
            print("This will never be printed")
    }
    
    neverSequenceSubscription.disposed(by: disposeBag)

在訂閱之后，調用了一個disposed方法，并且還傳入了一個DisposeBag()的對象，這究竟是為何？

這個是因為，RxSwift提供了一個類似RAII的機制，叫做DisposeBag，我們可以把所有的訂閱對象放在一個DisposeBag里，當DisposeBag對象被銷毀的時候，它里面“裝”的所有訂閱對象就會自動取消訂閱，對應的事件序列的資源也就被自動回收了。

還有一種回收資源的形式直接調用neverSequenceSubscription.dispose()方法，但是這個并不是官方推薦的方法。

在了解了整個事件的執(zhí)行過程之后，我們來看看還有有哪些Create Observable

of ： 用固定數量的元素生成一個Observable

example(title: "of") {
    let bag = DisposeBag()
    print("of 1")
    Observable.of(1,2,3,4,5,6,7,8)
        .subscribe(
            onNext:{
            print("\t",$0)
        }).disposed(by: bag)
    
    print("of 2")
    Observable.of([1,2,3,4,5,6,7,8], 
                scheduler: MainScheduler.instance)
        .subscribe(
            onNext:{
                print("\t", $0)
        }).disposed(by: bag)
    
}

from: 用一個Sequence類型的對象創(chuàng)建一個Observable

example(title: "from") {
    let bag = DisposeBag()
    Observable.from([1,2,3,4,5,6,7,8])
        .subscribe(
            onNext:{
                print("\t",$0)
        }).disposed(by: bag)
}

never: 不會執(zhí)行的Observable

example(title: "never") {
    let bag = DisposeBag()
    
    Observable<String>
        .never()
        .subscribe(
            onNext: { _ in
                 print("永遠都不會打印")
            }
        ).disposed(by: bag)
}

empty: 一個空的Observable，會直接發(fā)送onCompleted事件

example("empty") {
    let disposeBag = DisposeBag()
    
    Observable<Int>.empty()
        .subscribe(
            onNext: { print("next \($0)") }
        ).disposed(by: bag)

emmm，上面的代碼執(zhí)行之后什么都不會打印，為什么呢？因為在訂閱方法中，一共有四個事件組成，他們分別是：

onNext: 發(fā)生Next事件時候調用的方法，會把值傳出來

onError 發(fā)生錯誤的方法，會把錯誤回調出來

onCompleted 完成時候調用的方法，不帶參數

onDisposed 資源釋放時候調用的方法，不帶參數

然后我們把empty改成下面這個樣子

example("empty") {
    let bag = DisposeBag()
    
    Observable<Int>.empty()
        .subscribe(
            onNext: { print("next \($0)") },
            onError: { print("error \($0)") },
            onCompleted: { print("completed") },
            onDisposed: { print("disposed") })
        .disposed(by: bag)
}

其打印結果如下：

---------- empty ----------
completed
disposed

just: 只會發(fā)送一次值的Observable

example("just") {
    let disposeBag = DisposeBag()
    
    Observable.just("??")
        .subscribe(
            onNext: { print($0) }
            onError: { print("error \($0)") },
            onCompleted: { print("completed") },
            onDisposed: { print("disposed") })
        ).disposed(by: disposeBag)
}

其打印結果如下:

---------- just ----------
??
completed
disposed

just 是比較特殊的一個存在，因為在發(fā)送一次值之后，內部會自行調用completed方法

override func subscribe<O : ObserverType>(_ observer: O) ->
Disposable where O.E == Element {
    observer.on(.next(_element))
    observer.on(.completed)
    return Disposables.create()
}
代碼片段為RxSwift源碼

create： 創(chuàng)建一個Observable，他接收一個泛型參數Element表示任意類型


example(title: "create") {
    let bag = DisposeBag()
    let observable = Observable<String>.create({ (observar) -> Disposable in
        observar.onNext("on next")
        observar.onCompleted()
        return Disposables.create()
    })
    
    observable.subscribe(
        onNext: { print($0) }
    ).disposed(by: bag)
}

其打印結果如下：

---------- create ----------
on next
completed
disposed

range: 新建Observable在某個范圍內,

start起始值

count后移個數

example("range") {
    let bag = DisposeBag()
    
    Observable.range(start: 1, count: 10)
        .subscribe(
            onNext: { print($0) },
            onError: { print("error \($0)") },
            onCompleted: { print("completed") },
            onDisposed: { print("disposed") }
        ).disposed(by: bag)
}

其結果如下：

---------- range ----------
1
2
3
4
5
6
7
8
9
10
completed
disposed

repeatElement ： 重復某個值的Observable

example("repeatElement") {
    let bag = DisposeBag()
    
    Observable.repeatElement("??")
        .take(3)
        .subscribe(
            onNext: { print($0) },
            onError: { print("error \($0)") },
            onCompleted: { print("completed") },
            onDisposed: { print("disposed") }
        )
        .disposed(by: bag)
}

這里我們看到了一個新的方法take,

  • take: 取前幾次值

這里的take(3)是因為repeatElement會一直重復發(fā)送一個值，這里我們不需要一直監(jiān)聽，所以就取前三次值，

當然你也可以改為你想要取的次數

其打印結果如下：

---------- repeatElement ----------
??
??
??
completed
disposed

generate: 根據條件生成的Observable

initialState： 初始值

condition 條件

iterate 修改值的公式/方法

example("generate") {
            let bag = DisposeBag()
            
            Observable.generate(
                initialState: 0,
                condition: { $0 < 3 },
                iterate: { $0 + 1 }
                )
                .subscribe(
                    onNext: { print($0) },
                    onError: { print("error \($0)") },
                    onCompleted: { print("completed") },
                    onDisposed: { print("disposed") }
                )
                .disposed(by: bag)
        }

其打印結果如下：

---------- generate ----------
0
1
2
completed
disposed

deferred: 只有訂閱之后才會開始執(zhí)行操作的Observable

example("deferred") {
    let bag = DisposeBag()
    var count = 1
    
    let deferredSequence = Observable<String>.deferred {
        print("Creating \(count)")
        count += 1
        
        return Observable.create { observer in
            print("Emitting...")
            observer.onNext("??")
            observer.onNext("??")
            observer.onNext("??")
            return Disposables.create()
        }
    }
    
    deferredSequence
        .subscribe(onNext: { print($0) })
        .disposed(by: bag)
    
    deferredSequence
        .subscribe(onNext: { print($0) })
        .disposed(by: bag)
}

其打印結果如下：

---------- deferred ----------
Creating 1
Emitting...
??
??
??
Creating 2
Emitting...
??
??
??

error: 一個用于發(fā)送error的Observable

example("error") {
    enum TestError: Error {
        case test
    }
    
    let bag = DisposeBag()
    
    Observable<Int>.error(TestError.test)
        .subscribe { print($0) }
        .disposed(by: bag)
}

其打印結果如下：

---------- error ----------
error(test)

do: 用于觀察每個事件的經過

example("doOn") {
    let bag = DisposeBag()
    
    Observable.of("??", "??", "??", "??")
        .do(onNext: { print("do:", $0) },
onError: { print("do error:", $0) },
onCompleted: { print("do Completed")  },
            onDispose: { print("do dispose") })
        .subscribe(
            onNext: { print($0) },
            onError: { print("error \($0)") },
            onCompleted: { print("completed") },
            onDisposed: { print("disposed") }
        )
        .disposed(by: bag)
}

這個的打印會和我們所想的稍有不同

---------- doOn ----------
do: ??
??
do: ??
??
do: ??
??
do: ??
??
do Completed
completed
disposed
do dispose

可以看到 do dispose 是最后調用的，這個從他們的單詞拼寫上就能看出點端倪，不過這也無傷大雅，了解一下就可以了。

既然介紹了do，那就把debug也順帶提及一下，do可以監(jiān)聽on的事件，那么debug就是詳細的信息，這個在我們調試的時候，可以給我們不小的幫助

debug: 輸出一些詳細的信息

example("debug") {
    let bag = DisposeBag()
    
    Observable.of("??", "??", "??", "??")
        .debug()
        .subscribe(
            onNext: { print($0) },
            onError: { print("error \($0)") },
            onCompleted: { print("completed") },
            onDisposed: { print("disposed") }
        )
        .disposed(by: bag)
}

其打印信息如下：

---------- debug ----------
2018-09-17 22:34:33.492: Create.swift:212 (init()) -> subscribed
2018-09-17 22:34:33.525: Create.swift:212 (init()) -> Event next(??)
??
2018-09-17 22:34:33.525: Create.swift:212 (init()) -> Event next(??)
??
2018-09-17 22:34:33.525: Create.swift:212 (init()) -> Event next(??)
??
2018-09-17 22:34:33.526: Create.swift:212 (init()) -> Event next(??)
??
2018-09-17 22:34:33.526: Create.swift:212 (init()) -> Event completed
completed
disposed
2018-09-17 22:34:33.526: Create.swift:212 (init()) -> isDisposed

至此，Observable中的Create Operators就了解的差不多了

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

友情鏈接更多精彩內容