Observable

简介

Observable也是一个序列，其中心便是异步操作

Observable的生命周期:

1. Observable发射包括元素的事情
2. 它能够一直发射事情直到停止事情产生，比如发射完结信号或许错误信号
3. 一旦序列被停止了，它就不能再发射任何事情了

其中事情Event在源码中是被包装成枚举

“/// Represents a sequence event.
///
/// Sequence grammar: 
/// **next\* (error | completed)**
public enum Event<Element> {
    /// Next element is produced.
    case next(Element)
    /// Sequence terminated with an error.
    case error(Swift.Error)
    /// Sequence completed successfully.
    case completed
}”

Observable的快速创立办法

just

just将传入的item转化为发射item的Observable

just有些类似于from,可是from会深入数组、迭代器或许类似的目标中将其中的内容作为要发射的item提取出来,而just仅仅简略的发射你传入的item

留意，假如你将null传递给just，它将回来一个宣布null作为item的Observable。不要错误地以为这将回来一个空的可调查目标(一个底子不宣布任何item的目标)

let one = 1
let two = 2
let three = 3
let observable = Observable<Int>.just(one)
observable.subscribe { event in
    print(event)
}.disposed(by: disposeBag)
----打印成果-----
next(1)
completed

of

of能够传多个同类型参数

let observable2 = Observable.of(one, two, three)
observable2.subscribe { event in
    print(event)
}.disposed(by: disposeBag)
----打印成果-----
next(1)
next(2)
next(3)
completed

let observable3 = Observable.of([one, two, three], ["12333"])
observable3.subscribe { element in
    print(element)
}
onCompleted: {
    print("完结")
}
onDisposed: {
    print("observable3 disposed")
}.disposed(by: disposeBag)
----打印成果-----
[1, 2, 3]
["12333"]
完结
observable3 disposed

from

from将各种其他目标和数据类型转换为 Observable

当你运用可调查目标时，假如你想要运用的一切数据都能够表示为可调查目标，而不是可调查目标和其他类型的混合，这样会更便利。这允许你运用一组操作符来办理数据流的整个生命周期。经过清晰的转换一些目标将它们变为可调查的，你将允许它们与其它可调查目标进行平等的交互。

出于这个原因，大多数ReactiveX完结都有允许你将某些特定于语言的目标和数据结构转换为Observables的办法

例如，可迭代目标能够被以为是一种同步的可调查目标;未来作为一种总是发射单个item的可调查目标

let observable4 = Observable.from([one, two, three])
observable4.subscribe { event in
    print(event)
}.disposed(by: disposeBag)
----打印成果-----
next(1)
next(2)
next(3)
completed

总结:

• just仅支持单个参数传递，而且传递什么订阅后便得到什么
• of能够传递多个同类型的参数，相同也是传递什么订阅后便得到什么
• from传递数组，可是它会将数组中的元素拿出来

empty

//empty没有类型能揣度，所以有必要显示的写明void
let observable = Observable<Void>.empty()
observable.subscribe { _ in
    print("next")
} onError: { error in
    print(error)
} onCompleted: {
    print("完结")
} onDisposed: {
    print("disposed")
}.disposed(by: disposeBag)
----打印成果-----
完结
disposed

假如你想得到一个立即停止或许你有意想要0个值的可调查行列，你就能够运用empty

never

与empty不同，never创立的可调查序列不会宣布任何信号，也不会停止。它能够用来表示无限的持续时间

let observable = Observable<Void>.never()
observable.subscribe { e in
    print(e)
} onError: { error in
    print(error)
} onCompleted: {
    print("完结")
} onDisposed: {
    print("disposed")
}.disposed(by: disposeBag)
----打印成果-----

成果是没有任何打印，甚至连完结和毁掉也没有打印，所以怎么知道这个行列还在运行？？

Observable的源码剖析

序列的三步:

• 创立
• 订阅
• 毁掉

let ob = Observable<Any>.create { observer in
    observer.onNext("12345")
    observer.onCompleted()
    return Disposables.create()
}
ob.subscribe { text in
    print("订阅到了\(text)")
} onError: { error **in**
    print(error)
} onCompleted: {
    print("完结")
} onDisposed: {
    print("毁掉")
}.disposed(by: disposedBag)
---打印成果---
订阅到了12345
完结
毁掉

从上面代码成果来剖析很明显应当是在订阅后即subscribe的回调中先执行了上面create办法的回调,因为create办法的回调中是发送信号，只需先发送了信号在订阅中才能收到信号，可是来看到源码里

在create中仅仅创立了一个AnonymousObservable目标并且将回调当做参数发给了它

AnonymousObservable承继于Producer

在初始化办法中也仅仅是将收到的参数也便是上一步的闭包保存了而已

在create中没找到相关头绪，接下来先看看subscribe办法

能够看到这儿内部首要生成一个AnonymousObserver类型的observer目标,这儿相同是将跟随闭包存放于内部

最首要的是底下self.asObservable().subscribe(observer)这儿self是AnonymousObservable,刚说过它承继于Producer，在调用subscribe办法的时分，其实是调用其父类也便是Producer的subscribe办法

这儿会执行else的分支代码，重点在self.run这儿，self是AnonymousObservable,所以会调用自己的run办法

会调用sink.run也便是AnonymousObservableSink的run办法

这儿run办法内的调用parent便是AnonymousObservable目标，这儿便是直接调用了之前保存的回调，也便是最开始创立信号create办法后面的跟随闭包，直接调用了这个闭包

Observable中心图解如下:

Observable类剖析

方才剖析了AnonymousObservable发现它的父类是Producer，而Producer的父类是Observable，Observable是整个链条的基类，它仅仅要遵循ObservableType协议

ObservableType协议中有办法subscribe，也便是说只需遵照这个协议的目标都能够进行订阅，可是假如不是属于这个承继链的目标虽然也能够调用订阅办法，可是最好仍是运用asObservable先转换为Observable为好

例如下面代码这样写也不会报错，可是最好不要这么写

UISwitch().rx.value.subscribe { event in
    print(event)
}.disposed(by: disposedBag)

先运用asObservable转化后再订阅

UISwitch().rx.value.asObservable().subscribe { event in
    print(event)
}.disposed(by: disposedBag)

这儿的asObservable()是原先的ControlProperty类型的value转变为Observable的类型