RxSwift篇章
Observable在Rxswift中的重要性不言而喻,这个基础必须扎实.
1. empty
特点:
- 空序列,只有完成信号.
Observable<String>.empty()
.subscribe(onNext: { (info) in
print(info)
}, onError: { (err) in
print(err)
}, onCompleted: {
print("完成")
}) {
print("释放回调")
}
源码分析
class EmptyProducer<Element>: Producer<Element> {
override func subscribe<Observer: ObserverType>...{
observer.on(.completed)
return Disposables.create()
}
}
- 订阅的时候,直接发送了.completed完成信号,简洁明了.
2. just
特点:
- 单个信号序列.
- 初始化带一个参数,订阅完信息后自动执行complete.
let arr = ["1", "2"]
Observable<[String]>.just(arr)
.subscribe(onNext: { (info) in
print(info)
}, onError: { (err) in
print(err)
}, onCompleted: {
print("完成")
}) {
print("释放回调")
}
源码分析
override func subscribe<Observer: ObserverType> ...{
observer.on(.next(self._element))
observer.on(.completed)
return Disposables.create()
}
- 订阅的时候,先执行 observer.on(.next(self._element)), 发送.next 信号.
- 最后自动发送 completed 信号.
3. of
特点:
- 初始化具有可变数量的元素
- 元素可以接受可变数量的参数(参数类型一致)
Observable<[String: String]>.of(["name": "l", "age": "20"], ["name": "2", "age": "22"])
.subscribe { (event) in
print(event)
}
源码分析
final private class ObservableSequenceSink ... {
func run() -> Disposable {
return self._parent._scheduler.scheduleRecursive(self._parent._elements.makeIterator()) { iterator, recurse in
var mutableIterator = iterator
if let next = mutableIterator.next() {
self.forwardOn(.next(next))
recurse(mutableIterator)
}
else {
self.forwardOn(.completed)
self.dispose()
}
}
}
}
- 源码实现为经典结构,订阅通过 "Sink".
- 在"Sink" 中, 通过递归迭代器 recurse(mutableIterator) 发送完所有参数信号, 最后自动发送 completed 信号.
4. from
特点:
- 参数为可选型
- 订阅时有可选型处理,更安全.
Observable<[String]>.from(optional: ["111","222"])
.subscribe { (event) in
print(event)
}
源码分析
override func subscribe<Observer: ObserverType>... {
if let element = self._optional {
observer.on(.next(element))
}
observer.on(.completed)
return Disposables.create()
}
- 订阅的时候,参数存在则发送.next(element)信号,最后发送.completed完成信号.
5. deferred
特点:
- 使用deferred 通过传入的block, 可产生自定义序列.
- 在需求为动态序列时,可通过外界传入条件参数,以此实现满足不同条件的序列.
var flag = true
Observable<Int>.deferred { () -> Observable<Int> in
flag = !false
if flag{
return Observable.of(1, 3)
}else{
return Observable.of(2, 4)
}
}
.subscribe { (event) in
print(event)
}
源码分析
func run() -> Disposable {
do {
let result = try self._observableFactory()
return result.subscribe(self)
}
catch let e {
self.forwardOn(.error(e))
self.dispose()
return Disposables.create()
}
}
- self._observableFactory 保存了产生序列的block.
- 在订阅流程到 "sink" 的时候，把这段工厂闭包执行.
- result.subscribe(self) 为自定义序列,此序列在此实现订阅.
6. rang
特点:
- 生成指定范围内的可观察整数序列。
Observable.range(start: 2, count: 5).subscribe { (event) in
print(event)
}
源码分析
func run() -> Disposable {
return self._parent._scheduler.scheduleRecursive(0 as Observer.Element) { i, recurse in
if i < self._parent._count {
self.forwardOn(.next(self._parent._start + i))
recurse(i + 1)
}
else {
self.forwardOn(.completed)
self.dispose()
}
}
}
- 订阅后,根据初始值, 递归发送count个信号,参数变化为(初始值依次递增).
- 最后发送.completed完成信号.
7. generate
特点:
-
只有当提供的判断条件都为 true 的时候，才会给出动作的序列。
-
参数一initialState: 初始状态。
-
参数二 condition：终止生成的条件(返回“false”时)。
-
参数三 iterate：迭代步骤函数。
//1. 按条件规则产生信号
Observable.generate(initialState: 0,
condition: { $0 < 10},
iterate: { $0 + 2}
).subscribe { (event) in
print(event)
}
//2. 按条件规则便利集合
let generateArr = ["PL_1", "PL_2","PL_3","PL_4","PL_5"]
Observable.generate(initialState: 0,
condition: { $0 < generateArr.count },
iterate: { $0 + 1 })
.subscribe(onNext: { (index) in
print(generateArr[index])
})
源码分析
//sink类
class GenerateSink<Sequence, Observer: ObserverType>: Sink<Observer> {
typealias Parent = Generate<Sequence, Observer.Element>
private let _parent: Parent
private var _state: Sequence
...
func run() -> Disposable {
return self._parent._scheduler.scheduleRecursive(true) { isFirst, recurse -> Void in
do {
if !isFirst {
self._state = try self._parent._iterate(self._state)
}
if try self._parent._condition(self._state) {
let result = try self._parent._resultSelector(self._state)
self.forwardOn(.next(result))
recurse(false)
}
else {
self.forwardOn(.completed)
self.dispose()
}
}
catch let error {
self.forwardOn(.error(error))
self.dispose()
}
}
}
}
- 订阅时,从初始值开始执行迭代变化 self._state = try self._parent._iterate(self._state).
- 执行 self._parent._condition(self._state) 判断如果满足条件发送.next信号,否发送.completed信号.
8. timer
特点:
-
按周期响应的序列,响应时带一个值周期次数.
-
参数一: 第一次响应距离现在的时间。
-
参数二 period：时间间隔。
-
参数三 scheduler：线程。
Observable<Int>.timer(5, period: 2, scheduler: MainScheduler.instance)
.subscribe { (event) in
print(event)
}
- 订阅后,按间隔时间不断发送响应.
9. interval
特点:
- 与timer 一致.
Observable<Int>.interval(2, scheduler: MainScheduler.instance)
.subscribe { (event) in
print(event)
}
源码分析
public static func interval(_ period: RxTimeInterval, scheduler: SchedulerType)
-> Observable<Element> {
return Timer(
dueTime: period,
period: period,
scheduler: scheduler
)
}
- 调用的就是Timer序列.
10. repeatElement
特点:
- 无限重复.
Observable.repeatElement("PL")
.subscribe { (event) in
print(event)
}
源码分析
func run() -> Disposable {
return self._parent._scheduler.scheduleRecursive(self._parent._element) { e, recurse in
self.forwardOn(.next(e))
recurse(e)
}
}
- 订阅后,无限递归调用信号发送.
11. error
特点:
- 只发送error信号
Observable<String>.error(NSError.init(domain: "error", code: 10, userInfo: ["reason": "unknow"]))
.subscribe { (event) in
print(event)
}
源码分析
override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
observer.on(.error(self._error))
return Disposables.create()
}
- 订阅代码中直接发送.error事件.
12. never
特点:
- 永远不会发出信号(也不会终止)。
源码分析
class NeverProducer<Element>: Producer<Element> {
override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
return Disposables.create()
}
}
- 订阅代码中无任何事件.
13. create
特点:
-
该方法接受一个 闭包形式的参数，任务是对每一个过来的订阅进行响应处理。
-
这也是序列创建的一般方式，应用非常之多.
-
例子展示:
let observable = Observable<String>.create{observer in
//对订阅者发出了.next事件，且携带了一个数据.
observer.onNext("test")
//对订阅者发出了.completed事件
observer.onCompleted()
return Disposables.create()
}
//订阅测试
observable.subscribe {
print($0)
}
observable.subscribe {
print($0)
}
