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；
总结一下就是：
- 源序列发送了响应；
- 原序列创建了一个
Map序列（中间层，也叫中间者模式）并且通过.subscribe{print("\($0)”}订阅，创建了一个观察者1️⃣，保存了闭包；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也就理解了。
