RXSwift之Map映射函数原理

就像我们平时在 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) 而 _transform 是 init时带进来的也就是我们原先 Map 里存储的
$0 + 2.

总结:

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

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

如有错误,请留言指正.