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

https://juejin.im/post/5e0409536fb9a0164a10d7c2

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论