开放原子开发者工作坊

 Observable 是 Rx 的根基

官网：http://reactivex.io/

github地址：https://github.com/ReactiveX/RxSwift

 

 

• Observable<T> 这个类就是 Rx 框架的基础，我们可以称它为可观察序列。它的作用就是可以异步地产生一系列的 Event（事件），即一个 Observable<T> 对象会随着时间推移不定期地发出 event(element : T) 这样一个东西。
• 而且这些 Event 还可以携带数据，它的泛型 <T> 就是用来指定这个 Event 携带的数据的类型。
• 有了可观察序列，我们还需要有一个 Observer（订阅者）来订阅它，这样这个订阅者才能收到 Observable<T> 不时发出的 Event。

 

查看 RxSwift 源码可以发现，事件 Event 的定义如下：

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
}

官方文档如下：

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 事件了。

      /*
         （1）该方法通过传入一个默认值来初始化。
         （2）下面样例我们显式地标注出了 observable 的类型为 Observable<Int>，
         即指定了这个 Observable 所发出的事件携带的数据类型必须是 Int 类型的。
         */
        let justObservable = Observable<Int>.just(5)
        /*
         （1）该方法可以接受可变数量的参数（必需要是同类型的）
         （2）下面样例中我没有显式地声明出 Observable 的泛型类型，Swift 也会自动推断类型。
         */
        let ofObservable = Observable.of("a","b","c")
        /*
         （1）该方法需要一个数组参数。
         （2）下面样例中数据里的元素就会被当做这个 Observable 所发出 event 携带的数据内容，最终效果同上面饿 of() 样例是一样的。
         */
        let fromObservable = Observable.from(["a","b","c"])
        //该方法创建一个永远不会发出 Event（也不会终止）的 Observable 序列。
        let emptyObservable = Observable<Int>.never()
        
        //该方法创建一个不做任何操作，而是直接发送一个错误的 Observable 序列。
        enum Myerro:Error{
            case A
            case B
        }
        let erroObservable = Observable<Int>.error(Myerro.A)
        /*
         （1）该方法通过指定起始和结束数值，创建一个以这个范围内所有值作为初始值的 Observable 序列。
         （2）下面样例中，两种方法创建的 Observable 序列都是一样的。
         */
        let rangeAbservale = Observable.range(start: 1, count: 5)
        let ofObservale = Observable.of(1,2,3,4,5)
        //该方法创建一个可以无限发出给定元素的 Event 的 Observable 序列（永不终止）。
        let repeatElementObservale = Observable.repeatElement(1)
        
        /*
         （1）该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。
         （2）下面样例中，两种方法创建的 Observable 序列都是一样的。
         */
        let generrateObserval = Observable.generate(initialState: 0,
                                                    condition: {$0 <= 10},
                                                    iterate: {$0 + 2})
        let ofObservale1 = Observable<Int>.of(1,2,4,6,8,10)
        /*
         （1）该方法接受一个 block 形式的参数，任务是对每一个过来的订阅进行处理。
         （2）下面是一个简单的样例。为方便演示，这里增加了订阅相关代码。
         */
        //这个block有一个回调参数observer就是订阅这个Observable对象的订阅者
        //当一个订阅者订阅这个Observable对象的时候，就会将订阅者作为参数传入这个block来执行一些内容
        let creatObservale = Observable<String>.create { observer in
            //对订阅者发出了.next事件，且携带了一个数据"hangge.com"
            observer.onNext("mapanguan")
            //对订阅者发出了.completed事件
            observer.onCompleted()
            //因为一个订阅行为会有一个Disposable类型的返回值，所以在结尾一定要returen一个Disposable
            return Disposables.create()
        }
        
        creatObservale.subscribe{
            print($0)
        }
        
        
        /*
         （1）该个方法相当于是创建一个 Observable 工厂，通过传入一个 block 来执行延迟 Observable 序列创建的行为，而这个 block 里就是真正的实例化序列对象的地方。
         （2）下面是一个简单的演示样例：
         */
        
        var isOdd = true
        //使用deferred()方法延迟Observable序列的初始化，通过传入的block来实现Observable序列的初始化并且返回。
        let deferredObserval = Observable<Int>.deferred { () -> Observable<Int> in
            //让每次执行这个block时候都会让奇、偶数进行交替
            isOdd = !isOdd
            if isOdd{
                return Observable.of(1,3,5,7,9)
            }else{
                return Observable.of(2,4,6,8,10)
            }
        }
        
        deferredObserval.subscribe { (event) in
            print("frist",event)
        }
        
        deferredObserval.subscribe { (event) in
            print("second",event)
        }
        
        /*
         （1）这个方法创建的 Observable 序列每隔一段设定的时间，会发出一个索引数的元素。而且它会一直发送下去。
         （2）下面方法让其每 1 秒发送一次，并且是在主线程（MainScheduler）发送。
         */
        let intervalObserval = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
        intervalObserval.subscribe { (event) in
            print(event)
        }
        
        //这个方法有两种用法，一种是创建的 Observable 序列在经过设定的一段时间后，产生唯一的一个元素。相当于repeat = false
        let timerObserval = Observable<Int>.timer(5, scheduler: MainScheduler.instance)
        timerObserval.subscribe { (event) in
            print(event)
        }
        //另一种是创建的 Observable 序列在经过设定的一段时间后，每隔一段时间产生一个元素。相当于repeat = true
        let timer2Observal = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
        timer2Observal.subscribe { (event) in
            print(event)
        }