Observable介绍

Observable作为RxSwift的基础，一切的根基基于此，因此，想要透彻理解RxSwift，我们也要对Observable要有一些基本的了解。

Observable<T>

1. Observable<T>这个类是RxSwift框架的基础，通常我们把它称作为可观察序列，它存在的作用就是可以异步的产生一系列的Event事件。
2. 产生的这些Event事件还可以携带数据，那么泛型<T>就是用来传递这个Event事件携带的数据的类型。
3. 那么既然有了Observable可观察序列，我们还需要一个Observer（订阅者）来订阅它，这样这个订阅者才能收到发出的Event事件

Event事件

我们进入RxSwift的源码查看，可以发现事件Eventd的定义如下：

/// 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
}

我们可以看到，Event其实就是一个枚举，因此，可以知道Observable可以发出3种不同类型的Event事件：

next：next事件就是通常携带数据<T>的事件。

屏幕快照 2019-07-28 09.34.27.png

error：error事件表示一个错误，它携带了具体错误内容，只要Observable发出了error event，Observable就会终止，不会再发出error事件了。

屏幕快照 2019-07-28 09.40.56.png

completed：completed事件表示Observable发出的事件完成了，和error一样，只要Observable发出后就终止，不在发出event事件。

屏幕快照 2019-07-28 09.46.01.png

Observable 与 Sequence比较

1. 为更好地理解，我们可以把每一个 Observable的实例想象成于一个Swift中的 Sequence：

• 即一个 Observable（ObservableType）相当于一个序列 Sequence（SequenceType）。
• ObservableType.subscribe(_:) 方法其实就相当于 SequenceType.generate()

2. 区别：

• Swift 中的 SequenceType 是同步的循环，而 Observable 是异步的。
• Observable 对象会在有任何 Event 时候，自动将 Event 作为一个参数通过 ObservableType.subscribe(_:) 发出，并不需要使用 next 方法。

创建 Observable 序列

RxSwift为我们提供了以下几种方法来创建一个Observable序列。

just()方法

1. 该方法通过传入一个默认值来初始化，构建一个只有一个元素的Observable队列，订阅完信息自动complete。
2. 下面的样例，我们显示地标注出了Observable的类型为Observable<Int>，即指定了这个 Observable 所发出的事件携带的数据类型必须是 Int 类型的。

let observable = Observable<Int>.just(5)

of()方法

1. 该方法可以接受可变数量的参数（必需要是同类型的），创建一个固定数量元素的Observable序列。
2. 下面样例中我们没有显式地声明出 Observable 的泛型类型，Swift 也会自动推断类型。

let observable = Observable.of("A", "B", "C")

from()方法

1. 该方法需要一个数组/字典/集合参数，这样的一个序列中创建一个Observable序列。
2. 下面样例中数据里的元素就会被当做这个 Observable 所发出 event 携带的数据内容，最终效果同上面of() 样例是一样的。

let observable = Observable.from(["A", "B", "C"])

empty()方法

1. 该方法创建一个空内容的 Observable 序列，但是只能订阅到complete。

let observable = Observable<Int>.empty()

never()方法

1. 该方法创建一个永远不会发出 Event（也不会终止）的 Observable 序列。

let observable = Observable<Int>.never()

error()方法

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

enum MyError: Error {
    case A
    case B
}
         
let observable = Observable<Int>.error(MyError.A)

range()方法

1. 该方法通过指定起始和结束数值，创建一个以这个范围内所有值作为初始值的 Observable 序列。
2. 下面两种方法创建的 Observable 序列都是一样的。

//使用range()
let observable = Observable.range(start: 1, count: 5)
 
//使用of()
let observable = Observable.of(1, 2, 3 ,4 ,5)

repeatElement()方法

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

let observable = Observable.repeatElement(1)

generate()方法

1. 该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。
2. 两种方法创建的 Observable 序列都是一样的。

//使用generate()方法
let observable = Observable.generate(
    initialState: 0,
    condition: { $0 <= 10 },
    iterate: { $0 + 2 }
)
 
//使用of()方法
let observable = Observable.of(0 , 2 ,4 ,6 ,8 ,10)

create()方法

1. 该方法接受一个 block形式的参数，任务是对每一个过来的订阅进行处理。
2. 下面的样例增加了订阅相关代码（订阅的内容，以后讲）。

//这个block有一个回调参数observer就是订阅这个Observable对象的订阅者
//当一个订阅者订阅这个Observable对象的时候，就会将订阅者作为参数传入这个block来执行一些内容
let observable = Observable<String>.create{observer in
    //对订阅者发出了.next事件，且携带了一个数据"hangge.com"
    observer.onNext("hangge.com")
    //对订阅者发出了.completed事件
    observer.onCompleted()
    //因为一个订阅行为会有一个Disposable类型的返回值，所以在结尾一定要returen一个Disposable
    return Disposables.create()
}
 
//订阅测试
observable.subscribe {
    print($0)
}

deferred()方法

1. 该个方法相当于是创建一个 Observable 工厂，通过传入一个 block 来执行延迟 Observable 序列创建的行为，而这个 block 里就是真正的实例化序列对象的地方。
2. 演示样例：

//用于标记是奇数、还是偶数
var isOdd = true
 
//使用deferred()方法延迟Observable序列的初始化，通过传入的block来实现Observable序列的初始化并且返回。
let factory : Observable<Int> = Observable.deferred {
     
    //让每次执行这个block时候都会让奇、偶数进行交替
    isOdd = !isOdd
     
    //根据isOdd参数，决定创建并返回的是奇数Observable、还是偶数Observable
    if isOdd {
        return Observable.of(1, 3, 5 ,7)
    }else {
        return Observable.of(2, 4, 6, 8)
    }
}
 
//第1次订阅测试
factory.subscribe { event in
    print("\(isOdd)", event)
}
 
//第2次订阅测试
factory.subscribe { event in
    print("\(isOdd)", event)
}

interval()方法

1. 这个方法创建的 Observable 序列每隔一段设定的时间，会发出一个索引数的元素。而且它会一直发送下去。那么，它的底层其实就是封装timer。
2. 下面方法让其每 1 秒发送一次，并且是在主线程MainScheduler发送。

let observable = Observable<Int>.interval(1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}

timer()方法

1. 这个方法有两种用法，一种是创建的 Observable 序列在经过设定的一段时间后，产生唯一的一个元素。

//5秒种后发出唯一的一个元素0
let observable = Observable<Int>.timer(5, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}

2. 另一种是创建的 Observable序列在经过设定的一段时间后，每隔一段时间产生一个元素。

//延时5秒种后，每隔1秒钟发出一个元素
let observable = Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance)
observable.subscribe { event in
    print(event)
}

最后，感谢一下我们的航歌。