RxSwift 类结构概览

Every subscriber upon subscription usually generates it’s own separate sequence of elements. Operators are stateless by default. There is vastly more stateless operators then stateful ones.
每一个已订阅的订阅者 都会产生自己的一个序列。
RxSwift 中很多的operator(可以称之为操作函数) 默认情况下都是无状态的
这里的无状态 就是后续运用的operator对前面的operator的结果没有影响，只要是不subscribe ，所有subscriber 所产生的序列元素都是相同的。(我觉得可以理解为不保留之前的值)
例如：A ->map -> filter -> subscribe --->B
A1 ->... --->B1
操作序列每次都会从头开始运行map ，filter .... 一个接一个,一直到最后，并且subscriber 后会产生单独的序列，不会影响之前的subscribe 的序列

在熟悉 RxSwift 代码结构之前先了解几个小知识点。

• 尾随闭包

map 函数的定义如下：

  public func map<T>(@noescape transform: (Self.Generator.Element) throws -> T) rethrows -> [T]

使用

let numbers = [16, 58, 510]
let strings = numbers.map {
            (var number) -> String in
            var output = ""
            while number > 0 {
                output = digitNames[number % 10]! + output
                number /= 10
            }
            return output
        }

屏幕快照 2016-01-21 15.35.10.png 屏幕快照 2016-01-21 15.36.22.png

在使用过程中没有了( ) ，改map 函数使用一个闭包作为参数，该闭包需要包含一个参数 并返回一个参数。

再看一个例子：

 public func subscribe(on: (event: Event<E>) -> Void)
        -> Disposable {
        let observer = AnonymousObserver{ e in
            on(event: e)
        }
        return self.subscribeSafe(observer)
    }

AnonymousObserver 的初始化其实就是用了一个尾随闭包

class AnonymousObserver<ElementType> : ObserverBase<ElementType> {
    typealias Element = ElementType    
    typealias EventHandler = Event<Element> -> Void
    private let _eventHandler : EventHandler
  
    init(_ eventHandler: EventHandler) {
#if TRACE_RESOURCES
        AtomicIncrement(&resourceCount)
#endif
        _eventHandler = eventHandler
    }

    override func onCore(event: Event<Element>) {
        return _eventHandler(event)
    }
    
#if TRACE_RESOURCES
    deinit {
        AtomicDecrement(&resourceCount)
    }
#endif
}