RxSwift 源码解析02：Observable 不同创建方式

本文主要是介绍 Observable 不同的创建方式

基本名词解析

Observable

• 可监听序列
• 是事件的生产者

举例：温度是一个序列，然后检测温度，并对这个值做出响应

• 当温度达到 33 度事，打开空调降温

Observable 也分为 有限观察序列 和 无限观察序列，这里以 timer 为例

• 有限观察序列：观察之前就已经明确观察的次数，例如 just、of、from等
• 无限观察序列：观察次数不明确

这里以 timer 为例

• 有限的timer（不加period）：只观察一次

let ob = Observable<Int>.timer(.seconds(1), scheduler: MainScheduler.instance)
ob.subscribe { num **in**
    print(num)
}onCompleted: {
    print("done")
}.disposed(by: disposeBag)

//打印
done

• 无限的timer（加period）：会一直观察下去

let ob = Observable<Int>.timer(.seconds(1), period: .seconds(2), scheduler: MainScheduler.instance)
ob.subscribe { num **in**
    print(num)
}onCompleted: {
    print("done")
}.disposed(by: disposeBag)

//打印
done
done
...
done

Observer

• 观察者
• 用来监听事件，并对事件最初响应

监听当前室内温度，当高于33度时，打开空调降温
打开空调降温就是观察者

RxSwift 创建方式

Observable 序列的创建有以下一些方式

创建方式	说明
empty	创建一个空的序列，但是只能订阅到 complete
just	创建一个只有一个元素的 Observable 队列，订阅完信息自动 complete
of	创建一个固定数量元素的 Observable 序列
from	从一个序列（如 Array/Dictionary/Set）中创建一个 Observable 序列
deferred	为每一个订阅者创建一个新的 Observable 序列
generate	创建一个 Observable 序列，只需提供的条件值为 true 就可以生成值
error	创建一个不会发送任何条目并且立即终止错误的 Observable 序列
range	创建一个 Observable 序列，它会发出一系列的整数，然后终止
timer	获取计时器 Observable 序列
interval	底层就是 timer
repeatElement	创建一个可以无限发出给定元素Event 的 Observable 序列，即永不终止
never	创建一个永远不会发出Event（也不会终止）的 Observable 序列

empty 创建

• 创建一个空的序列

原本序列事件是Int类型的，但这里调用emty函数 ，即没有序列，只能走 complete

let emtyOb = Observable<Int>.empty()
_ = emtyOb.subscribe(onNext: { num in
    print(num)
}, onError: { error in
    print(error)
}, onCompleted: {
    print("完成")
}, onDisposed: {
    print("释放")
})

//-------打印--------
完成
释放

just 创建

• 单个信号序列创建(例如：viewModel/VC建立依赖关系)

let array = ["Lily", "Tom"]
Observable<[String]>.just(array)
    .subscribe { event in
        print(event)
    }
    .disposed(by: disposeBag)

//-------打印--------
next(["Lily", "Tom"])
completed

of 创建

• 多个元素 ，即针对序列处理

Observable<String>.of("Lily", "Tom")
    .subscribe { event in
        print(event)
    }
    .disposed(by: disposeBag)


//-------打印--------
next(Lily)
next(Tom)
completed

• 数组

Observable<[String]>.of(["Lily", "Tom"])
    .subscribe { event in
        print(event)
    }
    .disposed(by: disposeBag)

//-------打印--------
next(["Lily", "Tom"])
completed

• 字典

Observable<[String: Any]>.of(["name1": "Tom", "name2": "Lily"])
    .subscribe { event in
        print(event)
    }
    .disposed(by: disposeBag)

//-------打印--------
next(["name2": "Lily", "name1": "Tom"])
completed

from 创建

• 从集合中获取序列：数组，集合，set 获取序列

有可选项处理 - 更安全

Observable<[String]>.from(optional: ["Lily", "Tom"])
    .subscribe { event in
        print(event)
    }
    .disposed(by: disposeBag)


//-------打印--------
next(["Lily", "Tom"])
completed

deferred 创建

• 使用deferred()方法延迟Observable序列的初始化，通过传入的block来实现Observable序列的初始化并且返回。
• 使用场景：登录/注册属于同一个页面时，动态判断不同逻辑

需求：动态序列 - 根据外界的标识 - 动态输出

var isOdd = true
_ = Observable<Int>.deferred({ () -> Observable<Int> in
    // 设计的序列
    isOdd = !isOdd
    if isOdd {
        return Observable.of(1, 3, 5, 7, 9)
    }
    return Observable.of(0, 2, 4, 6, 8)
})
.subscribe({ event in
    print(event)
})


//-------打印--------
next(0)
next(2)
next(4)
next(6)
next(8)
completed

generate 创建

• 该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。
• 初始值给定 --> 然后判断条件1 --> 再判断条件2 --> 会一直递归下去，直到条件1或者条件2不满足
• 类似 数组遍历循环

Observable.generate(initialState: 0, //初始值
                        condition: { $0 < 10}, //条件1
                        iterate: { $0 + 2 }) //条件2
    .subscribe { event in
        print(event)
    }
    .disposed(by: disposeBag)


//-------打印--------
next(0)
next(2)
next(4)
next(6)
next(8)
completed

• 数组遍历

let arr = ["1", "2", "3", "4"]
Observable.generate(initialState: 0,// 初始值
                    condition: { $0 < arr.count}, // 条件1
                    iterate: { $0 + 1 })  // 条件2 +2
.subscribe(onNext: {
    print("遍历arr:", arr[$0])
}).disposed(by: disposeBag)


//-------打印--------
遍历arr: 1
遍历arr: 2
遍历arr: 3
遍历arr: 4

error 创建

• 对消费者发出一个错误信号

Observable<String>.error(NSError.init(domain: "lgerror", code: 10086, userInfo: ["reason": "unknow"]))
    .subscribe { event in
        print("订阅:", event)
    }
    .disposed(by: disposeBag)

range 创建

• range：生成指定范围内的可观察整数序列。

Observable.range(start: 2, count: 5)
    .subscribe { event in
        print(event)
    }
    .disposed(by: disposeBag)


//-------打印--------
next(2)
next(3)
next(4)
next(5)
next(6)
completed

timer创建

• 第一次参数：第一次响应距离现在的时间
• 第二个参数：时间间隔
• 三个参数：线程
• 如果没有指定期限 period，故认定为一次性
• 使用场景：需要自定义定时器

Observable<Int>.timer(.seconds(5), period: .seconds(2), scheduler: MainScheduler.instance)
    .subscribe { event in
        print(event)
    }
    .disposed(by: disposeBag)

// 因为没有指定期限period，故认定为一次性
Observable<Int>.timer(.seconds(1), scheduler: MainScheduler.instance)
    .subscribe { event in
        print("111111111 \(event)")
    }
    

interval 创建

• 封装好的定时器

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

repeatElement 创建

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

Observable<Int>.repeatElement(5)
    .subscribe { event in
        // print("订阅:", event)
    }
    .disposed(by: disposeBag)

never 创建

• 该方法创建一个永远不会发出 Event（也不会终止）的 Observable 序列。
• 这种类型的响应源 在测试或者在组合操作符中禁用确切的源非常有用

Observable<String>.never()
    .subscribe { event in
        print("886", event)
    }
    .disposed(by: disposeBag)