阅读 3451

RxSwift-高阶函数

首发地址: www.ljcoder.com/16080130499…

RxSwift操作符

操作符可以帮助大家创建新的序列,或者变化组合原有的序列,从而生成一个新的序列。比如filter过滤,map转换等,具体可参考文档Operator - 操作符

filter,map等操作符都是高阶函数,高阶函数接受一个或多个函数作为输入,最后输出一个函数。下面我们就以map为例进行分析。

map原理分析

先来一段最简单的map使用代码

let ob = Observable.of(1,2,3,4)
ob.map { (number) -> Int in
        return number+2
    }
    .subscribe{
        print("\($0)")
    }
    .disposed(by: disposeBag)
复制代码

查看map函数,在注释部分,可以看到,具体实现在map文件中

// Map.swift

extension ObservableType {
    public func map<Result>(_ transform: @escaping (Element) throws -> Result)
        -> Observable<Result> {
        return Map(source: self.asObservable(), transform: transform)
    }
}
复制代码

创建了一个Map类,它是Producer的子类,是不是突然很熟悉,在RxSwift-核心逻辑分析中,AnonymousObservable也是Producer的子类,它们应该有一些相似之处,我们来分析一下差别。

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)
    }
}
复制代码
  • 多了source属性,用来存储原来的队列,transform存储变换逻辑,也就是.map后面的闭包return number+2
  • sink也由AnonymousObservableSink变成了MapSink
  • subscriptionsourcesubscribe返回值。

根据RxSwift-核心逻辑分析,我们已经知道,最后会调用MapSinkon(_:)方法。

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

复制代码

我们主要看看.next的处理,此时element是源序列的元素,也就是(1,2,3,4)的元素,再调用transform,也就是number+2,最后经过transform后的元素发送出去,这样,map就完成了。

// 假如此时的序列元素是1,经过number+2后,变成了3
let mappedElement = try self.transform(element)
// 把3发送出去,订阅到的元素就变成3了
self.forwardOn(.next(mappedElement))
复制代码

总结

  • 高阶函数的订阅和响应逻辑和普通的序列是一样的。
  • 不同的高阶函数逻辑由不同的Producer子类和不同的Sink子类进行处理,保证了序列的灵活性和可扩展性。
文章分类
iOS
文章标签