06RxSwift的高阶函数Map 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(_ transform: @escaping (Element) throws -> Result) -> Observable { return self.asObservable().composeMap(transform) } ----------transform就是闭包 number+2------------- internal func composeMap(_ transform: @escaping (Element) throws -> Result) -> Observable { return _map(source: self, transform: transform) } ---------self为Observable，transform为闭包--------------

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

核心部分 internal func _map(source: Observable, transform: @escaping (Element) throws -> Result) -> Observable { return Map(source: source, transform: transform) }final private class Map: Producer { typealias Transform = (SourceType) throws -> ResultTypeprivate let _source: Observableprivate let _transform: Transforminit(source: Observable, transform: @escaping Transform) { self._source = source self._transform = transform#if TRACE_RESOURCES _ = increment(_numberOfMapOperators) #endif }override func composeMap(_ selector: @escaping (ResultType) throws -> Result) -> Observable { let originalSelector = self._transform return Map(source: self._source, transform: { (s: SourceType) throws -> Result in let r: ResultType = try originalSelector(s) return try selector(r) }) }override func run(_ 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)

【06RxSwift的高阶函数Map】由源序列（self._source=ob）去订阅了一下，为什么要用源序列去订阅，原因是：ob源序列，提供响应1，2，3，4；因为响应是源序列提供的，必须由原序列去接收；
self._source.subscribe(sink)其中的sink是一个观察者，为什么是观察者，因为subscribe函数后面的传参就是传一个观察者0.0，必须的，没得商量那种。这个观察者记为观察者2??；为什么sink可以做观察者，因为继承了ObserverType；

总结一下就是：

源序列发送了响应；

原序列创建了一个Map序列（中间层，也叫中间者模式）并且通过.subscribe{print("\($0)”}订阅，创建了一个观察者1??，保存了闭包；

Map序列的run方法中，让源序列去订阅，而观察者却是sink，这个sink记为观察者2??；以上的这一波骚操作叫做 “观察者移交”。

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

inal private class MapSink: Sink, ObserverType { typealias Transform = (SourceType) throws -> ResultTypetypealias ResultType = Observer.Element typealias Element = SourceTypeprivate let _transform: Transforminit(transform: @escaping Transform, observer: Observer, cancel: Cancelable) { self._transform = transform super.init(observer: observer, cancel: cancel) }func on(_ event: Event) { 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 { event in#if DEBUG synchronizationTracker.register(synchronizationErrorMessage: .default) defer { synchronizationTracker.unregister() } #endifswitch 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)")}打印输出，完美。