概念

Observable 这个类是 Rx 框架的核心，我们可以称它为可观察序列，也可称它为可被监听的序列。
Rx 响应的是流(Stream)，在 RxSwift 中，我们称之为 序列(sequence), 事实上，在这里 流 和 序列 是同一样东西。

Observable 的作用就是可以异步地产生一系列的 Event（事件），即一个 Observable<T> 对象会随着时间推移不定期地发出 event(element : T) 这样一个东西。
而且这些 Event 还可以携带数据，它的泛型 <T> 就是用来指定这个 Event 携带的数据的类型。

有了可观察序列，我们还需要有一个 Observer（订阅者）来订阅它，这样这个订阅者才能收到 Observable<T> 不时发出的 Event。

Observable 的生命周期

说到 Observable 的生命周期，我们先介绍一下 event（事件）吧。

public enum Event<Element> {
    case next(Element)
    case error(Swift.Error)
    case completed
}

官方文档如下：

• onNext：An Observable calls this method whenever the Observable emits an item. This method takes as a parameter the item emitted by the Observable.

翻译：next 事件就是那个可以携带数据 <T> 的事件，可以说它就是一个“最正常”的事件。

• onError：An Observable calls this method to indicate that it has failed to generate the expected data or has encountered some other error. It will not make further calls to onNext or onCompleted. The onError method takes as its parameter an indication of what caused the error.

翻译：error 事件表示一个错误，它可以携带具体的错误内容，一旦 Observable 发出了 error event，则这个 Observable 就等于终止了，以后它再也不会发出 event 事件了。

• onCompleted：An Observable calls this method after it has called onNext for the final time, if it has not encountered any errors.

翻译：completed 事件表示 Observable 发出的事件正常地结束了，跟 error 一样，一旦 Observable 发出了 completed event，则这个 Observable 就等于终止了，以后它再也不会发出 event 事件了。

你可以合理的利用这些 Event 来实现业务逻辑。了解 Event 之后， Observable 的生命周期就很好理解了：

• 党序列发出 next事件，可以继续发出数据；
• 当序列发出 完成事件（Completed Event） 时，序列终止，不在发出数据；
• 当序列发出 错误事件（Error Event） 时，序列终止，不在发出数据。

创建Observable

可以通过以下方法创建 Observable：

• just：创建一个序列，只包含一个元素。

func test() {
        let disposeBag = DisposeBag()
        
        let justObservable = Observable.just("100")
        
        justObservable.subscribe(onNext: { (event) in
            print("onNext: \(event)")
        }, onCompleted: {
            print("onCompleted")
        }).disposed(by: disposeBag)
}

打印结果：

onNext: 100
onCompleted

• of：创建一个序列，包含多个元素。

func test() {
        let disposeBag = DisposeBag()
        
        let ofObservable = Observable.of("a", "b", "c")
        
        ofObservable.subscribe(onNext: { (event) in
            print("onNext: \(event)")
        }, onCompleted: {
            print("onCompleted")
        }).disposed(by: disposeBag)
}

打印结果：

onNext: a
onNext: b
onNext: c
onCompleted

• from：创建一个序列，该方法参数包含一个集合，可以是数组，集合，字典，Observable 会拆解这个集合，一个个发出元素。

func test() {
        let disposeBag = DisposeBag()
        
        let fromObservable = Observable.from(["f", "r", "o", "m"])
        
        fromObservable.subscribe(onNext: { (event) in
            print("onNext: \(event)")
        }, onCompleted: {
            print("onCompleted")
        }).disposed(by: disposeBag)
}

打印结果：

onNext: f
onNext: r
onNext: o
onNext: m
onCompleted

• range：通过指定起始和结束数值，创建一个以这个范围内所有值作为初始值的 Observable 序列。

func test() {
        let disposeBag = DisposeBag()
        
        let rangeObservable = Observable.range(start: 0, count: 10)
        
        rangeObservable.subscribe(onNext: { (event) in
            print("onNext: \(event)")
        }, onCompleted: {
            print("onCompleted")
        }).disposed(by: disposeBag)
}

打印结果：

onNext: 0
onNext: 1
onNext: 2
onNext: 3
onNext: 4
onNext: 5
onNext: 6
onNext: 7
onNext: 8
onNext: 9
onCompleted

• error：该方法创建一个不做任何操作，而是直接发送一个错误的 Observable 序列。

enum MyError: Error {
    case A
    case B
    var errorType: String {
        switch self {
        case .A:
            return "I am error A"
        case .B:
            return "I am error B"
        }
    }
}

func test() {
        let disposeBag = DisposeBag()
        
        let myError = MyError.A
        
        let errorObservable = Observable<Int>.error(myError)
        errorObservable.subscribe(onNext: { (event) in
            print("onNext:\(event)")
        }, onError: { (error) in
            print("onError:\((error as! MyError).errorType)")
        }, onCompleted: {
            print("onCompleted")
        }).disposed(by: disposeBag)
}

打印结果：

onError:I am error A

• empty：使用该方法创建的序列不包含任何元素，只会发出一个 Completed 事件。必须指定元素类型，因为没有元素让 Swift 来推导类型。这里用 Void 类型没有实际意义，只是表示没有值而已，其他类型也可以。

let observable = Observable<Void>.empty()

• never：不发送任何事件，也永远不会结束。这里类型 Any 的意义和上面的 Void 一样。

let observable = Observable<Any>.never()

• repeatElement：该方法创建一个可以无限发出给定元素的 Event 的 Observable 序列（永不终止）；

func test() {
        let disposeBag = DisposeBag()
        
        let repeatElementObservable = Observable.repeatElement("repeat")
        
        repeatElementObservable.subscribe(onNext: { (event) in
            print("onNext:\(event)")
        }, onCompleted: {
            print("onCompleted")
        }).disposed(by: disposeBag)
}

打印结果：

onNext:repeat
onNext:repeat
onNext:repeat
...

• create：创建序列 Observable 最直接的方法就是 create 方法，然后在构建函数里面描述元素的产生过程。 observer.onNext(0) 就代表产生了一个元素，他的值是 0。后面又产生了 4 个元素分别是 1, 2, 3, 4。最后，用 observer.onCompleted() 表示元素已经全部产生，后面再产生元素observer.onNext(5) 和 observer.onError(MyError.A)，也接收不到值了。

func test() {
        let disposeBag = DisposeBag()
        
        let obj = Observable<Any>.create { observer -> Disposable in
            observer.onNext(0)
            observer.onNext(1)
            observer.onNext(2)
            observer.onNext(3)
            observer.onNext(4)
            observer.onCompleted()
            observer.onNext(5)
            observer.onError(MyError.A)
            
            return Disposables.create()
        }
        
        obj.subscribe(onNext: { (element) in
            print(element)
        }, onError: { (error) in
            print(error)
        }, onCompleted: {
            print("onCompleted")
        }).disposed(by: disposeBag)
    }

打印结果：

0
1
2
3
4
onCompleted

• deferred：deferred 方法相当于是创建一个 Observable 工厂，通过传入一个 闭包来执行延迟 Observable 序列创建的行为，而这个闭包里才是真正的实例化 Observable 序列对象。

func test() {
        let disposeBag = DisposeBag()
        
        var isOdd = true
        let factory = Observable<Int>.deferred { () -> Observable<Int> in
            isOdd = !isOdd
            if isOdd {
                return Observable.of(0,2,4,6)
            } else {
                return Observable.of(1,3,5,7)
            }
        }
        
        factory.subscribe(onNext: { (event) in
            print("onNext:\(event)")
        }, onCompleted: {
            print("onCompleted")
        }).disposed(by: disposeBag)
    }

打印结果：

onNext:1
onNext:3
onNext:5
onNext:7
onCompleted

• generate：该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。

func test() {
        let disposeBag = DisposeBag()
        let generateSequence = Observable<Int>.generate(
            initialState: 0,
            condition: {$0 < 5},
            iterate: {$0 + 1}
        )
        
        generateSequence.subscribe { event in
            print(event)
        }).disposed(by: disposeBag)
    }

打印结果：

next(0)
next(1)
next(2)
next(3)
next(4)
completed

• interval 和 timer
  注：这两个方法已经弃用了，以下是系统提示：

'interval(_:scheduler:)' is deprecated: Use DispatchTimeInterval overload instead.
'timer(_:period:scheduler:)' is deprecated: Use DispatchTimeInterval overload instead.

Author

如果你有什么建议，可以关注我的公众号：iOS开发者进阶，直接留言，留言必回。