美文网首页
RXSwift之Map映射函数原理

RXSwift之Map映射函数原理

作者: lb_ | 来源:发表于2019-08-02 11:56 被阅读0次

    就像我们平时在 swift 中使用 map 函数一样, 它提供我们一个可实现修改原对象,并返回一个新对象的方法. 我们称之为映射.

    swift 中我们经常有如下写法:

    let ary = [1,2,3]
    let newAry = ary.map {$0 + 2}
    

    如上使用, 使用 map 函数得到一个新的符合需求数组.

    同样,在RxSwift中可观察序列 ObservableType 拥有一个 extension ,意味着所有序列都拥有使用 .map 函数转换为新序列的功能, 并且对新序列进行订阅时, 源序列可以接收响应

    //简单map
    let subj = PublishSubject<Int>()
    subj.map{$0 + 2}.subscribe{print("\($0)")}.disposed(by: disposeBag)
    
    subj.onNext(1)
    

    这就很神奇,因为我们原 subj 进行 map 之后并没有重新赋值给 subj , 我们是对subj 进行 .map{$0 + 2} 之后生成的新序列进行订阅的. 但是我们对 原观察者 subj 发送事件的时候 , 新序列可以接收响应.

    什么意思?
    一句话来说, map之后加上源序列. 其实是两个序列, 那么这两个序列什么时候互通了呢?

    Rx Map原理探究

    搜索 Map.swift 文件.

    extension ObservableType {
    
        /**
         Projects each element of an observable sequence into a new form.
    
         - seealso: [map operator on reactivex.io](http://reactivex.io/documentation/operators/map.html)
    
         - parameter transform: A transform function to apply to each source element.
         - returns: An observable sequence whose elements are the result of invoking the transform function on each element of source.
    
         */
        public func map<Result>(_ transform: @escaping (Element) throws -> Result)
            -> Observable<Result> {
            return self.asObservable().composeMap(transform)
        }
    }
    

    点进去 composeMap方法,经过几个中间过渡方法,依次点进进去即可.
    直接附上.不多赘述

    internal func composeMap<Result>(_ transform: @escaping (Element) throws -> Result) -> Observable<Result> {
            return _map(source: self, transform: transform)
        }
    
    internal func _map<Element, Result>(source: Observable<Element>, transform: @escaping (Element) throws -> Result) -> Observable<Result> {
        return Map(source: source, transform: transform)
    }
    

    最终我们来到 Map 类中

    final private class Map<SourceType, ResultType>: Producer<ResultType> {
        typealias Transform = (SourceType) throws -> ResultType
    
        private let _source: Observable<SourceType>
    
        private let _transform: Transform
    
        init(source: Observable<SourceType>, transform: @escaping Transform) {
            self._source = source
            self._transform = transform
    
        /*中间无关代码博主已删除,方便阅读*/
    
        override func run<Observer: ObserverType>(_ observer: Observer, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where Observer.Element == ResultType {
            let sink = MapSink(transform: self._transform, observer: observer, cancel: cancel)
            let subscription = self._source.subscribe(sink)
            return (sink: sink, subscription: subscription)
        }
    }
    

    我们看到 init 时 保存了

    • 源序列 _source (即我们定义的 PublishSubject ,附上lldb截图)
    • 映射方法 _transform (即我们定义的具体map实现 $0 + 2 )

    接着我们对 .map 之后进行 subscribe , 由于 Map 继承与 Producer , 因此 subscribe 会执行自己类中的 run 方法, 这个不对赘述, 如果有疑问的同学请阅读 RxSwift核心响应逻辑一 , RxSwift核心响应逻辑二

    run 方法中我们看到一句重点代码:

    let sink = MapSink(transform: self._transform, observer: observer, cancel: cancel)
    let subscription = self._source.subscribe(sink)
    

    我们看到这一句黑科技写法, 在对 map 之后产生新序列订阅时, 走到 run 方法这里, Rx生成一个 MapSink 自动对源序列同样进行订阅.

    那么这就意味着什么呢

    在对源序列进行 map 之后产生新序列订阅时, 会产生一个 MapSink 的观察者对源序列进行订阅

    也就是说接下来,当源序列再发送 event 时, 将由 MapSink 这个内部类去执行具体 on(_ event: Event<SourceType>) 方法.

    final private class MapSink<SourceType, Observer: ObserverType>: Sink<Observer>, ObserverType {
        private let _transform: Transform
        /*多余方法去掉,直接看重点*/
        init(transform: @escaping Transform, observer: Observer, cancel: Cancelable) {
            self._transform = transform
            super.init(observer: observer, cancel: cancel)
        }
    
        func on(_ event: Event<SourceType>) {
            switch event {
            case .next(let element):
                do {
                    let mappedElement = try self._transform(element)
                    self.forwardOn(.next(mappedElement))
                }
                catch let e {
                    self.forwardOn(.error(e))
                    self.dispose()
                }
            case .error(let error):
                self.forwardOn(.error(error))
                self.dispose()
            case .completed:
                self.forwardOn(.completed)
                self.dispose()
            }
        }
    }
    

    上面源码中, 具体 onNext 时 进行了一步 self._transform(element)_transforminit时带进来的 也就是我们原先 Map 里存储的
    $0 + 2.

    总结:

    .map 函数时产生了新的序列, 而对新序列进行订阅时, Maprun 方法中, 对源序列同样进行订阅,订阅者为内部类 MapSink. 源序列发送 event , MapSink响应前加了一步 调用用户定义的 transform 从而实现映射转换.

    至此,整个从映射新序列, 订阅, 响应流程已走完. 相信走到这里, 你 已经对 RxSwiftmap 函数,有了一个新的理解.

    如有错误,请留言指正.

    相关文章

      网友评论

          本文标题:RXSwift之Map映射函数原理

          本文链接:https://www.haomeiwen.com/subject/hzvkdctx.html