RxSwift 中关于Map 闭包中是否需要使用 weak

写一段示例代码：

class ViewController: UIViewController {
    
    let publish = PublishSubject<Int>()
    
    let disposeBag = DisposeBag()

    override func viewDidLoad() {
        super.viewDidLoad()
        test()
    }

    func test() {
       let mapObservable =  publish.map { value in
            "\(value)"
        }
        
        mapObservable.subscribe { value in
            print(value)
        }
        .disposed(by: disposeBag)
        
        publish.onNext(1)
        
    }
}

这段代码最终将订阅返回的 dispose 加入到 disposeBag 中，只要 disposeBag 可以释放，map 闭包就可以不关心引用问题，注意点在：不能因为map闭包而引起 disposeBag 不能释放。

把其中一段代码修改成如下:

        let mapObservable =  publish.map { value in
            "\(self): \(value)"
        }

闭包中引用self，而造成 disposeBag 不能被释放，这里会造成内存泄漏。

再来做一次修改：

       let mapObservable =  publish.map { value in
            "\(self): \(value)"
        }
        
        let dispose = mapObservable.subscribe { value in
            print(value)
        }
        
        dispose.dispose()

这里不会内存泄漏，因为订阅后的dispose调用了 dispose()方法。

部分源码：

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> {
        Map(source: self.asObservable(), transform: transform)
    }
}

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

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

MapSink 对象最终持有了 transform 闭包，MapSink 对象 和 订阅后返回的 dispose 相互引用。dispose 只要 调用 dispose() 方法，就会将 MapSink 对象 设置为 nil。打破 MapSink 对象 和 订阅后返回的 dispose 相互引用。MapSink 对象 置nil 后，就没有任何对象引用 transform 闭包。