就像我们平时在 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 函数,有了一个新的理解.
如有错误,请留言指正.
网友评论