RxSwift

官方文檔結構

Introduction:

Subjects

Transforming Observables

Filtering Observables

Combining Observables

Error Handing Operators

Observable Utility Operators

Conditional and Boolean Operators

Mathematical and Aggregate Operators

Connectable Observable Operatiors

?

Observable

Observable?是觀察者模式中被觀察的對象，相當于一個事件序列(GeneratorType)， 會向訂閱者發送新產生的事件信息。

事件信息分為：?

.Next(value): 表示新的事件數據 .Completed: 表示事件序列完結 .Error: 異常導致的事件序列完結

Subjects

A Subject is a sort of bridge or proxy that is available in some implementations of ReactiveX that acts both as an observer and as an Observable.?

Subject可以看做是一種代理和橋梁。它既是訂閱者又是訂閱源，這意味著它既可以訂閱其他Observables，同時又可以對他的訂閱者發送事件

1. How To Create Observables ?

empty:?

empty creates an empty sequence. The only message it sends is the .Completed message.let emptySequence = Observable<Int>.empty()

never:

never creates a sequence that never sends any element or completes.let neverSequence = Observable<Int>.never()

just (一個元素)

just represents sequence that contains one element. It sends two messages to subscribers. The first message is the value of single element and the second message is .Completed.let singleElementSequence = Observable.just(32)

sequenceOf (一系列元素)

sequenceOf creates a sequence of a fixed number of elements.

from (將swift的序列(SequenceType) 轉換為事件序列)

from creates a sequence from SequenceTypelet sequenceFromArray = [1, 2, 3, 4, 5].toObservable()

create (通過閉包創建序列)

create creates sequence using Swift closure. This examples creates custom version of just operator.let myJust = { (singleElement: Int) -> Observable<Int> inreturn Observable.create { observer inobserver.on(.Next(singleElement))observer.on(.Completed)return NopDisposable.instance} }let subscription = myJust(5).subscribe { event inprint(event) }

generate

generate creates sequence that generates its values and determines when to terminate based on its previous values.let generated = Observable.generate(initialState: 0,condition: { $0 < 3 },iterate: { $0 + 1 } )let subscription = generated.subscribe { event inprint(event) }

failWith

create an Observable that emits no items and terminates with an errorlet error = NSError(domain: "Test", code: -1, userInfo: nil) let erroredSequence = Observable<Int>.error(error)

deferred (加載延遲， 訂閱者的內容相同而完全獨立)

do not create the Observable until the observer subscribes, and create a fresh Observable for each observer

2. How To Create Subjects

PublishSubject（發送訂閱者從訂閱之后的事件序列）

PublishSubject emits(發出) to an observer only those items that are emitted by the source Observable(s) subsequent to the time of the subscription.example("PublishSubject") {let disposeBag = DisposeBag()let subject = PublishSubject<String>()writeSequenceToConsole("1", sequence: subject).addDisposableTo(disposeBag)subject.on(.Next("a"))subject.on(.Next("b"))writeSequenceToConsole("2", sequence: subject).addDisposableTo(disposeBag)subject.on(.Next("c"))subject.on(.Next("d")) } 1 - a 1 - b 1 - c 2 - c 1 - d 2 - d

ReplaySubject (在新訂閱對象訂閱的時候會補發所有已經發送過的數據列， buffize: 是緩沖區的大小， 為1時，那么新訂閱者出現的時候就補發上一個事件，如果是2， 就補發2個 ，…)

ReplaySubject emits to any observer all of the items that were emitted by the source Observable(s), regardless of when the observer subscribes.example("ReplaySubject") {let disposeBag = DisposeBag()let subject = ReplaySubject<String>.create(bufferSize: 1)writeSequenceToConsole("1", sequence: subject).addDisposableTo(disposeBag)subject.on(.Next("a"))subject.on(.Next("b"))writeSequenceToConsole("2", sequence: subject).addDisposableTo(disposeBag)subject.on(.Next("c"))subject.on(.Next("d")) } print: 1 - a 1 - b 2 - b // 補發1個 1 - c 2 - c 1 - d 2 - d

BehaviorSubject (在新的訂閱對象訂閱的時候回發送最近發送的事件，如果沒有，則發送一個默認值)

When an observer subscribes to a BehaviorSubject, it begins by emitting the item most recently emitted by the source Observable (or a seed/default value if none has yet been emitted) and then continues to emit any other items emitted later by the source Observable(s).example("BehaviorSubject") {let disposeBag = DisposeBag()let subject = BehaviorSubject(value: "z")writeSequenceToConsole("1", sequence: subject).addDisposableTo(disposeBag)subject.on(.Next("a"))subject.on(.Next("b"))writeSequenceToConsole("2", sequence: subject).addDisposableTo(disposeBag)subject.on(.Next("c"))subject.on(.Next("d"))subject.on(.Completed) } print: 1 - z 1 - a 1 - b 2 - b 1 - c 2 - c 1 - d 2 - d 1 - com 2 - com

Variable (是基于BehaviorSubject的一層封裝， 它的優勢： 不會被顯示的終結，即：不會受到.Complete或者.Error這類終結事件，它會主動在析構的時候發送.Complete)

Variable wraps BehaviorSubject. Advantage of using variable over BehaviorSubject is that variable can never explicitly complete or error out, and BehaviorSubject can in case Error or Completed message is send to it. Variable will also automatically complete in case it"s being deallocated.example("Variable") {let disposeBag = DisposeBag()let variable = Variable("z")writeSequenceToConsole("1", sequence: variable.asObservable()).addDisposableTo(disposeBag)variable.value = "a"variable.value = "b"writeSequenceToConsole("2", sequence: variable.asObservable()).addDisposableTo(disposeBag)variable.value = "c"variable.value = "d" }

3. Transforming Observables

map/select

More info in reactive.io website

example("map") {let originalSequence = Observable.of(1, 2, 3)_ = originalSequence.map { number innumber * 2}.subscribe { print($0) } }

轉載于:https://www.cnblogs.com/Jenaral/p/5718538.html

總結

以上是生活随笔為你收集整理的RxSwift 之官方文档的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。