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