RxSwift(二) - Observable

一、Observable简介

1. Observable

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

2. Event

/// **next\* (error | completed)**
public enum Event {
    /// Next element is produced.
    case next(Element)

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

    /// Sequence completed successfully.
    case completed
}

Event枚举有三个值, 所以Observable可以发出三种Event :

• next : Observable序列产生一个新的事件,并可以携带参数
• error : 序列发生错误,返回错误信息,并终止序列
• completed : 序列的所有元素都已经成功,整个序列已经完成,并终止序列

二、创建 Observable序列

1. just()

• 传入默认值初始化
• 可以显示标明参数类型

let observable = Observable.just(5)
let observable1 = Observable.just("123")
let observable2 = Observable.just(111)// 类型不匹配,错误

2. of()

• 可以传入可变数量的同类型参数

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

3. from()

• 接收参数为数组类型

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

4. empty()

• 创建一个空内容的 Observable 序列

let observable = Observable.empty()

5. never()

• 创建一个永远不会发出 event ,也不会终止的 Observable 序列

let observable = Observable.never()

6. error()

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

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

7. range()

• 该方法通过指定起始和结束值, 创建一个以这个范围内所有值作为初始值的 Observable 序列

//下面两种方法创建的观察者序列是相同的
let observable1 = Observable.range(start: 1, count: 5)
let observable2 = Observable.of(1,2,3,4,5);

8. repeatElement()

• 创建一个无限发出给定元素 Event 的 Observable

let observable = Observable.repeatElement("repeat")

9. generate()

• 创建一个只有当提供的所有判断条件都为true的时候,才会发出 Event 的 Observable 序列

let ob1 = Observable.generate(
            initialState: 0,
            condition: { $0 <= 10},
            iterate: {$0 + 2}
        )
//等同于
let ob2 = Observable.of(0,2,4,6,8,10)

10. create()

• 该方法接收一个block参数, 任务是对每一个过来的订阅进行处理

let observable = Observable.create { (observer) -> Disposable in
    observer.onNext("test")
    observer.onCompleted()
    return Disposables.create()
}
        
observable.subscribe { (string) in
    print(string)
};

//输出
next(test)
completed

11. deferred()

• 创建一个 Observable 工厂, 通过传入一个 block 来执行延迟创建 Observable 序列

var isOdd = true
let factory : Observable = Observable.deferred {
    isOdd = !isOdd
    if isOdd {
        return Observable.of(1,3,5,7)
    }else {
        return Observable.of(2,4,6,8)
    }
}
        
factory.subscribe { event in
    print("\(isOdd)",event);
}
        
factory.subscribe { event in
    print("\(isOdd)",event);
}

//输出结果
false next(2)
false next(4)
false next(6)
false next(8)
false completed
true next(1)
true next(3)
true next(5)
true next(7)
true completed

12. interval()

• 创建一个每隔一段设定时间发出一个索引数的元素的 Observable 序列

let observable = Observable.interval(1, scheduler: MainScheduler.instance)
    observable.subscribe { event in
    print(event);
}
//输出结果
next(0)
next(1)
next(2)
next(3)
...

13. timer()

• 创建一个在经过设定的时间后产生唯一元素的 Observable 序列

let observable = Observable.timer(1, scheduler: MainScheduler.instance)
    observable.subscribe { event in
    print(event);
}

//输出结果
next(0) //产生唯一元素后就完成
completed

• 创建一个在经过设定的时间后,每隔一段时间产生一个元素

let observable = Observable.timer(5, period: 1, scheduler: MainScheduler.instance)
    observable.subscribe { event in
    print(event)
}

//输出结果 : 5秒钟之后,每隔一秒钟产生一个元素
next(0)
next(1)
next(2)
next(3)
...