什么是RXSwift？
- RX（ReactiveX），一种跨平台的标准，目前很多开发语言都有Rx的库，包括RxJava、RxJS、Rx.NET、RXSwift等。
- RxSwift是Swift函数响应式编程的一个开源库，它主要是提供了一种在Swift语言下可以轻易写出响应式函数式的功能实现。
理解：之前传递事件方式有：delegate、notification、kvo、target-action等等，这些方式中有需要写代理协议，有些需要注册通知，有些需要新建一些类。RxSwift和RxCocoa的出现改变了这一套。RxSwift最基础的实现，是基于Observable，就像一条数据流，当新的数据出现，它就会通知它的Subscriber去做对应的处理，使得事件传递全部替换成 rx 的信号链。
Observable介绍
Observable，中文翻译过来是 可观察的，它实质上是一个Sequence(序列)，所以称它为可观察序列。
序列分为有穷序列和无穷序列，主要就是用来形成一条数据流。有穷序列，比如通过网络来获取一张图片这一个过程，数据是有限的，图片下载完了，序列也就迎来闭合了。无穷序列，比如我们对UI的监测可能是无穷的，比如某个手势、某次按钮的点击、横竖屏切换等等。
Observable<T>是一个观察者模式中被观察的对象，相当于一个事件序列，它会异步地产生一系列Event，并发送给它订阅者。
Observable的三种事件
Observable里有三种事件——next, completed, error：
next事件主要是当Observable里出现新的数据时会发出的事件，同时该事件会携带新的数据对象。
completed事件是当Observable不再有新的数据出现，Observable被标记完成，并且将数据流终结。
-
error事件是指当数据流遇到了错误会发出的事件，该事件也会导致Observable被终结。被终结的Observable不会再有任何的事件发出。
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创建
- empty
empty 创建空的序列，只发送 .completed 事件。
func emptyObservable() {
let emptySequence = Observable<Int>.empty()
_ = emptySequence.subscribe { event in
print(event)
}
}
运行结果：
completed
- never
never 创建的序列，永远不会发送消息， .completed 事件也不会发送。
func neverObservable() {
let neverSequence = Observable<Int>.never()
_ = neverSequence.subscribe { event in
print(event)
}
}
运行结果：
- error
error 创建的序列，不做任何操作，直接发出 .error 事件。注意：Error这边是个协议。
enum BaseError: Error {
case ABC
case BCD
}
//error
func errorObservable() {
let errorSequence = Observable<Int>.error(BaseError.ABC)
_ = errorSequence.subscribe { event in
print(event)
}
}
运行结果：
error(ABC)
- just
just 根据传入的一个参数来创建序列，它会向订阅者发送两个事件，第一个发送带元素数据的 .next事件，第二个发送 .completed 事件。
func justObservable() {
let justSequence = Observable<Int>.just(1)
_ = justSequence.subscribe { event in
print(event)
}
}
运行结果：
next(1)
completed
- of
of 根据传入的多个元素来创建序列（必须是同类型的）。它会依次发出.next事件，最后发出.completed 事件。
func ofObservable() {
let ofSequence = Observable<Int>.of(1,2)
_ = ofSequence.subscribe { event in
print(event)
}
}
运行结果：
next(1)
next(2)
completed
- from
from 根据传入的集合来创建序列。它会依次发出.next事件，最后发出.completed 事件。结果和of()一样。
func fromObservable() {
let fromSequence = Observable<Int>.from([1,2])
_ = fromSequence.subscribe { event in
print(event)
}
}
运行结果：
next(1)
next(2)
completed
- create
create 根据闭包来创建序列，在闭包里面可自定义事件。
func createObservable() {
let createSequence = Observable<Int>.create { observer -> Disposable in
observer.on(.next(1))
observer.on(.completed)
return Disposables.create()
}
_ = createSequence.subscribe { event in
print(event)
}
}
运行结果：
next(1)
completed
- generate
generate 根据条件来创建序列，满足条件的事件才会发出
func generateObservable() {
let generateSequence = Observable<Int>.generate(
initialState: 0,
condition: {$0 < 5},
iterate: {$0 + 1}
)
_ = generateSequence.subscribe { event in
print(event)
}
}
运行结果：
next(0)
next(1)
next(2)
next(3)
next(4)
completed
- deferred
deferred 延时创建序列，直到 observer 订阅之后才创建 Observable，并且为每一个 observer 创建一个全新的 Observable
func deferredObservable() {
let deferredSequence = Observable<Int>.deferred {
return Observable.of(1,2,3)
}
_ = deferredSequence.subscribe { event in
print(event)
}
_ = deferredSequence.subscribe { event in
print(event)
}
}
运行结果：
next(1)
next(2)
next(3)
completed
next(1)
next(2)
next(3)
completed
- interval
interval 创建的序列，每隔一段时间会发出一个带索引数元素的事件，一直下去
func intervalObservable() {
let intervalObservable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
_ = intervalObservable.subscribe { event in
print(event)
}
}
运行结果：
next(0)
next(1)
next(2)
next(3)
next(4)
...
- timer
timer创建的序列，延时一段时间后发出事件
func timerObservable() {
//延时5秒钟，发出唯一一个带0元素事件
let timerObservable = Observable<Int>.timer(5, scheduler: MainScheduler.instance)
_ = timerObservable.subscribe { event in
print(event)
}
print("----")
//延时5秒钟，每个1秒发出一个事件
let timerObservable2 = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
_ = timerObservable2.subscribe { event in
print(event)
}
}
运行结果：
next(0)
completed
next(0)
next(1)
next(2)
next(3)
next(4)
...
