06RxSwift的高阶函数Map

map映射（A中的元素，B中都有唯一的元素与之对应，称为A到B的映射）:

let ob = Observable.of(1,2,3,4)
        ob.map { (number) -> Int in
            return number+2
            }
            .subscribe{
                print("\($0)")
            }
            .disposed(by: disposeBag())

通过搜索Map.swift，查看.map方法的具体实现：

 public func map<Result>(_ transform: @escaping (Element) throws -> Result)
        -> Observable<Result> {
        return self.asObservable().composeMap(transform)
    }
----------transform就是闭包 number+2-------------

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

进入到_map核心方法内查看：

核心部分
internal func _map<Element, Result>(source: Observable<Element>, transform: @escaping (Element) throws -> Result) -> Observable<Result> {
    return Map(source: source, transform: transform)
}

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

#if TRACE_RESOURCES
        _ = increment(_numberOfMapOperators)
#endif
    }

    override func composeMap<Result>(_ selector: @escaping (ResultType) throws -> Result) -> Observable<Result> {
        let originalSelector = self._transform
        return Map<SourceType, Result>(source: self._source, transform: { (s: SourceType) throws -> Result in
            let r: ResultType = try originalSelector(s)
            return try selector(r)
        })
    }

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

  ...
}

以上梳理一下就是：

1. 通过.map最后创建了一个Map序列；Map是一个继承了Produce的序列，保存了原序列（source）和 闭包（transform）；
2. ob源序列，提供响应 1，2，3，4；
3. 通过ob.map { (number) -> Int in return number+2}产生一个新的中间序列Map后，通过.subscribe{print("\($0)")去实现订阅；
4. Map序列实现订阅（.subscribe），并不是ob进行的订阅，这里要搞清楚！！！（ob序列里面嵌套了一个Map序列）；同时subscribe方法会创建一个观察者，记为观察者1️⃣

接着上面的run方法中的内容：

let subscription = self._source.subscribe(sink)

由源序列（self._source=ob）去订阅了一下，为什么要用源序列去订阅，原因是：ob源序列，提供响应1，2，3，4；因为响应是源序列提供的，必须由原序列去接收；

self._source.subscribe(sink)其中的sink是一个观察者，为什么是观察者，因为subscribe函数后面的传参就是传一个观察者0.0，必须的，没得商量那种。这个观察者记为观察者2️⃣；为什么sink可以做观察者，因为继承了ObserverType；

总结一下就是：

1. 源序列发送了响应；
2. 原序列创建了一个Map序列（中间层，也叫中间者模式）并且通过.subscribe{print("\($0)”}订阅，创建了一个观察者1️⃣，保存了闭包；
3. Map序列的run方法中，让源序列去订阅，而观察者却是sink，这个sink记为观察者2️⃣；以上的这一波骚操作叫做 “观察者移交”。

self._source.subscribe(sink)这里原序列的订阅，最后必然执行观察者on方法（RXSwift的基本核心逻辑），也就是如下代码：

inal private class MapSink<SourceType, Observer: ObserverType>: Sink<Observer>, ObserverType {
    typealias Transform = (SourceType) throws -> ResultType

    typealias ResultType = Observer.Element 
    typealias Element = SourceType

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

这里 case .next(let element):传进来的element一定是源序列的1，2，3，4，不确定的可以lldb打印一下；而后面再执行 self.forwardOn(.next(mappedElement))也就是MapSink.forwardOn,会调用Map的观察者的on方法，最后执行观察者后面的闭包：

let observer = AnonymousObserver<Element> { event in
                
                #if DEBUG
                    synchronizationTracker.register(synchronizationErrorMessage: .default)
                    defer { synchronizationTracker.unregister() }
                #endif
                
                switch event {
                case .next(let value):
                    onNext?(value)
                case .error(let error):
                    if let onError = onError {
                        onError(error)
                    }
                    else {
                        Hooks.defaultErrorHandler(callStack, error)
                    }
                    disposable.dispose()
                case .completed:
                    onCompleted?()
                    disposable.dispose()
                }
            }

最后调用{print("\($0)")}打印输出，完美。

map高阶函数了解上比较费劲的其实就是ob序列里面嵌套了一个Map序列，采用了中间者模式，然后进行了观察者的移交，这样这里能够理解，map也就理解了。