RxSwift 速查手册

本文档内容来自于 RxSwift 的 Playground。记录大多数 ReactiveX 的概念和操作符。

为什么使用 RxSwift?

我们写的很多代码实际上是为了解决和响应外部事件。当用户操作一个控件的时候，我们需要使用 @IBAction 来响应事件。我们需要观察通知来检测键盘改变位置。当 URL Sessions 带着响应的数据返回时，我们需要提供闭包来执行我们的操作。我们还需要使用 KVO 来检测变量的值改变。这些大量的编写机制使得我们的代码结构变的更加复杂。如果有一种统一的编写机制来完成所有的这些调用 / 响应代码是不是更棒呢？Rx 就是为解决这些问题而生的。

Observable

理解 RxSwift 的关键是理解 Observable 的概念。要理解它的创建，操作以及为了对变化做出响应操作而进行的订阅（subscribe）。

创建和订阅 Observable

要理解本框架，第一步需要理解如何创建 Observable。有很多函数可以创建 Observable。

创建 Observable 之后，如果没有订阅者订阅该 observable，那么什么事情也不会发生，所以我们将同时解释创建和订阅。

empty

empty 创建一个空的序列。它仅发送 .Completed 消息。


example("empty") {
    let emptySequence = Observable<Int>.empty()

    let subscription = emptySequence
        .subscribe { event in
            print(event)
        }
}

运行结果：


--- empty example ---
Completed

never

never 创建一个序列，该序列永远不会发送消息，.Completed 消息也不会发送。


example("never") {
    let neverSequence = Observable<Int>.never()

    let subscription = neverSequence
        .subscribe { _ in
            print("This block is never called.")
        }
}

运行结果：

just

just 代表只包含一个元素的序列。它将向订阅者发送两个消息，第一个消息是其中元素的值，另一个是 .Completed。


example("just") {
    let singleElementSequence = Observable.just(32)

    let subscription = singleElementSequence
        .subscribe { event in
            print(event)
        }
}

运行结果：


--- just example ---
Next(32)
Completed

sequenceOf

sequenceOf 通过固定数目的元素创建一个序列


example("sequenceOf") {
    let sequenceOfElements = Observable.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

    let subscription = sequenceOfElements
        .subscribe { event in
            print(event)
        }
}

运行结果：


--- sequenceOf example ---
Next(0)
Next(1)
Next(2)
Next(3)
Next(4)
Next(5)
Next(6)
Next(7)
Next(8)
Next(9)
Completed

toObservable

toObservable 在一个数组的基础上创建一个序列


example("toObservable") {
    let sequenceFromArray = [1, 2, 3, 4, 5].toObservable()

    let subscription = sequenceFromArray
        .subscribe { event in
            print(event)
        }
}

运行结果：


--- toObservable example ---
Next(1)
Next(2)
Next(3)
Next(4)
Next(5)
Completed

create

create 使用 Swift 闭包来创建一个序列。该例子中，创建了 just 操作符的自定义版本。


example("create") {
    let myJust = { (singleElement: Int) -> Observable<Int> in
        return Observable.create { observer in
            observer.on(.Next(singleElement))
            observer.on(.Completed)

            return NopDisposable.instance
        }
    }

    let subscription = myJust(5)
        .subscribe { event in
            print(event)
        }
}

运行结果：


--- create example ---
Next(5)
Completed

generate

generate 创建的序列可以自己生成它的值，并且在之前值的基础上来判断什么时候结束。


example("generate") {
    let generated = Observable.generate(
        initialState: 0,
        condition: { $0 < 3 },
        iterate: { $0 + 1 }
    )

    let subscription = generated
        .subscribe { event in
            print(event)
        }
}

运行结果：


--- generate example ---
Next(0)
Next(1)
Next(2)
Completed

error

创建一个不发送任何 item 的 Observable，以 error 中指


example("error") {
    let error = NSError(domain: "Test", code: -1, userInfo: nil)

    let erroredSequence = Observable<Int>.error(error)

    let subscription = erroredSequence
        .subscribe { event in
            print(event)
        }
}

运行结果：


--- error example ---
Error(Error Domain=Test Code=-1 "(null)")

deferred

直到 observer 订阅之后才创建 Observable，并且为每一个 observer 创建一个全新的 Observable do not create the Observable until the observer subscribes, and create a fresh Observable for each observer

RxSwift 速查手册

为什么使用 RxSwift?

Observable

创建和订阅 Observable

empty

never

just

sequenceOf

toObservable

create

generate

error

deferred

PublishSubject

ReplaySubject

BehaviorSubject

Variable

变换操作

map / select

flatMap

scan

过滤操作

filter

distinctUntilChanged

take

结合操作 (Combination operators)

startWith

combineLatest

zip

merge

switchLatest

Error Handling Operators

catchError

retry

Observable Utility Operators

subscribe

subscribeNext

subscribeCompleted

subscribeError

doOn

条件和布尔操作（Conditional and Boolean Operators）

takeUntil

takeWhile

算数和聚合 (Mathematical and Aggregate Operators)

concat

reduce

`map` / `select`

`flatMap`

`scan`

`filter`

`distinctUntilChanged`

`take`

`startWith`

`combineLatest`

`zip`

`merge`

`switchLatest`

`catchError`

`retry`

`subscribe`

`subscribeNext`

`subscribeCompleted`

`subscribeError`

`doOn`

`takeUntil`

`takeWhile`

`concat`

`reduce`