【RXSwift】系列一 Observable创建

什么是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是一个观察者模式中被观察的对象，相当于一个事件序列，它会异步地产生一系列Event，并发送给它订阅者。

---

Observable的三种事件

Observable里有三种事件——next, completed, error：

• next事件主要是当Observable里出现新的数据时会发出的事件，同时该事件会携带新的数据对象。

• completed事件是当Observable不再有新的数据出现，Observable被标记完成，并且将数据流终结。

• error事件是指当数据流遇到了错误会发出的事件，该事件也会导致Observable被终结。被终结的Observable不会再有任何的事件发出。

  public enum Event {
  /// Next element is produced.
  case next(Element)

    /// Sequence terminated with an error.
    case error(Swift.Error)
  
    /// Sequence completed successfully.
    case completed
  

  }

---

Observable创建

1. empty

empty 创建空的序列，只发送 .completed 事件。

    func emptyObservable() {
        let emptySequence = Observable.empty()
        _ = emptySequence.subscribe { event in
            print(event)
        }
    }

运行结果：

completed

2. never

never 创建的序列，永远不会发送消息， .completed 事件也不会发送。

    func neverObservable() {
        let neverSequence = Observable.never()
        _ = neverSequence.subscribe { event in
            print(event)
        }
    }

运行结果：

3. error

error 创建的序列，不做任何操作，直接发出 .error 事件。注意：Error这边是个协议。

    enum BaseError: Error {
        case ABC
        case BCD
    }
    
    //error
    func errorObservable() {
        let errorSequence = Observable.error(BaseError.ABC)
        _ = errorSequence.subscribe { event in
            print(event)
        }
    }

运行结果：

error(ABC)

4. just

just 根据传入的一个参数来创建序列，它会向订阅者发送两个事件，第一个发送带元素数据的 .next事件，第二个发送 .completed 事件。

    func justObservable() {
        let justSequence = Observable.just(1)
        _ = justSequence.subscribe { event in
            print(event)
        }
    }

运行结果：

next(1)
completed

5. of

of 根据传入的多个元素来创建序列（必须是同类型的）。它会依次发出.next事件，最后发出.completed 事件。

    func ofObservable() {
        let ofSequence = Observable.of(1,2)
        _ = ofSequence.subscribe { event in
            print(event)
        }
    }

运行结果：

next(1)
next(2)
completed

6. from

from 根据传入的集合来创建序列。它会依次发出.next事件，最后发出.completed 事件。结果和of()一样。

    func fromObservable() {
        let fromSequence = Observable.from([1,2])
        _ = fromSequence.subscribe { event in
            print(event)
        }
    }

运行结果：

next(1)
next(2)
completed

7. create

create 根据闭包来创建序列，在闭包里面可自定义事件。

    func createObservable() {
        let createSequence = Observable.create { observer -> Disposable in
            observer.on(.next(1))
            observer.on(.completed)
            return Disposables.create()
        }
        _ = createSequence.subscribe { event in
            print(event)
        }
    }

运行结果：

next(1)
completed

8. generate

generate 根据条件来创建序列，满足条件的事件才会发出

    func generateObservable() {
        let generateSequence = Observable.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

9. deferred

deferred 延时创建序列，直到 observer 订阅之后才创建 Observable，并且为每一个 observer 创建一个全新的 Observable

    func deferredObservable() {
        let deferredSequence = Observable.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

10. interval

interval 创建的序列，每隔一段时间会发出一个带索引数元素的事件，一直下去

  func intervalObservable() {
        let intervalObservable = Observable.interval(1, scheduler: MainScheduler.instance)
        
        _ = intervalObservable.subscribe { event in
            print(event)
        }
    }

运行结果：

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

11. timer

timer创建的序列，延时一段时间后发出事件

    func timerObservable() {
        //延时5秒钟，发出唯一一个带0元素事件
        let timerObservable = Observable.timer(5, scheduler: MainScheduler.instance)
        _ = timerObservable.subscribe { event in
            print(event)
        }
        print("----")
        //延时5秒钟，每个1秒发出一个事件
        let timerObservable2 = Observable.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)
...