函数响应编程&RxSwift（一）

    RxSwift安装：

    CocoPod导入：

  pod 'RxSwift'
  pod 'RxCocoa'

一.函数式编程

    函数式编程是种编程范式，它需要我们将函数作为参数传递，或者作为返回值返还。我们可以通过组合不同的函数来得到想要的结果。
 

用数学表达式来表示：

函数 y = f(x) 

x参数可以是一个函数    x = f(x)    例如：2 = 1+1 = 0+2

将以上的函数作为参数传入第一个函数中

y = f(f(x))  

//例1:
//遍历数组（要求：1.首先获取 > 3的数字；2.获取的数字之后 + 1；3.所有数字中的偶数；4.可读性 清晰度）

let array = [1,2,3,4,5,6,7]

//普通处理方式：
        for num in array{
            if num > 3{
                let number = num + 1
                if (number % 2 == 0) {
                    print(number)
                }
            }
        }
//函数式:
array.filter{ $0 > 3}
     .filter{ ($0+1) % 2 == 0 }
     .forEach { print($0) }

    它使我们可以通过组合不同的方法，以及不同的函数来获取目标结果。传统的 for 循环来完成相同的逻辑，是一件多么繁琐的事情。所以函数试编程的优点是显而易见的：

• 灵活
• 高复用
• 简洁
• 易维护
• 适应各种需求变化

二.函数响应式编程

    将函数式编程来操作序列的方式升华一下。例如：把一个按钮的点击事件看作是一个序列：

//例2:
//传统写法
var button: UIButton
...
//初始化
button = UIButton()
button.addTarget(self, action: #selector(text), for: .touchUpInside)
....
   
@objc func text() {
   print("Button clicked！")
}

   可以看出业务逻辑可功能模块分开了，随着代码量的增多，维护更新成本增加。引用RxSwift之后：

...
let bag = DisposeBag()
....

self.button.rx.tap    //序列
            .subscribe(onNext: { () in   //订阅
                print("Button clicked！")
            }, onError: { (error) in
                print("错误信息")
            }, onCompleted: {
                print("订阅完成")
            })
            .disposed(by: bag)    //销毁

 

    这里 taps 就是按钮点击事件的序列。然后我们通过打印“Button clicked！”，来对每一次点击事件做出响应。这种编程方式叫做响应式编程。我们结合函数式编程以及响应式编程就得到了函数响应式编程。通过不同的构建函数，来创建所需要的数据序列。最后通过适当的方式来响应这个序列。这就是函数响应式编程。

三.RxSwift

    1.例2中，为什么button可以“.rx”？

    查看rx的源码：

/// A type that has reactive extensions.
public protocol ReactiveCompatible {    //定义了一个协议，意味着实现了协议的都会有rx
    /// Extended type
    associatedtype CompatibleType  

    /// Reactive extensions.
    static var rx: Reactive<CompatibleType>.Type { get set }

    /// Reactive extensions.
    var rx: Reactive<CompatibleType> { get set }
}

extension NSObject: ReactiveCompatible { }    //因为NSObject遵循了以上协议，所以NSObject及其子类都可以 .rx

    2.Observable - 可监听序列

  Observable 可以用于描述元素异步产生的序列，所有的事物都可以看作是序列，生活中许多事物都可以通过它来表示。

              序列图（坐标：时间，异步发生的，事件：1、2、3...）

//例3: 创建一个序列
//1:创建序列
 let ob = Observable<Any>.create { (observer) -> Disposable in
            // 3:发送信号
            obserber.onNext("????")
            obserber.onCompleted()
//            obserber.onError(NSError.init(domain: "error！", code: 10087, userInfo: nil))
            return Disposables.create()

//2:订阅信息
 let _ = ob.subscribe(onNext: { (text) in
            print("订阅到:\(text)")    //text从哪里来的？
        }, onError: { (error) in
            print("error: \(error)")    //error从哪里来的？
        }, onCompleted: {
            print("完成")
        }) {
            print("销毁")
        }

    思考：订阅信号中的onNext闭包里面的“text”、onError闭包里面的“error”从哪里来的呢？

    从订阅中心observer，一直在用的序列，序列内部的代码是不曾看到的。为什么从序列闭包里面的发出信号，订阅信号的闭包里面能够订阅到？

四.RxSwift核心逻辑

    1.源码分析

     创建序列的方法：

/**
         Creates an observable sequence from a specified subscribe method implementation.
    
         - seealso: [create operator on reactivex.io](http://reactivex.io/documentation/operators/create.html)
    
         - parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
         - returns: The observable sequence with the specified implementation for the `subscribe` method.
         */    
public static func create(_ subscribe: @escaping (RxSwift.AnyObserver<Self.E>)
    -> Disposable) -> RxSwift.Observable<Self.E>

    源码实现：

 public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
        return AnonymousObservable(subscribe)
    }

    查看creat的源码发现，方法返回了一个AnonymousObservable（匿名序列）。

//AnonymousObservable类
final private class AnonymousObservable<Element>: Producer<Element> {
    typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable

    let _subscribeHandler: SubscribeHandler

    init(_ subscribeHandler: @escaping SubscribeHandler) {
        self._subscribeHandler = subscribeHandler    //带参数进行初始化，subscrib回调的记录，保存了这个闭包，函数式编程思想
    }

    override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
        let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
        let subscription = sink.run(self)
        return (sink: sink, subscription: subscription)
    }
}

//Producer类，包含了subscribe方法
class Producer<Element> : Observable<Element> {
    override init() {
        super.init()
    }

    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        if !CurrentThreadScheduler.isScheduleRequired {
            // The returned disposable needs to release all references once it was disposed.
            let disposer = SinkDisposer()
            let sinkAndSubscription = self.run(observer, cancel: disposer)    //具体的实现交给子类
            disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

            return disposer
        }
        else {
            return CurrentThreadScheduler.instance.schedule(()) { _ in
                let disposer = SinkDisposer()
                let sinkAndSubscription = self.run(observer, cancel: disposer)    //具体的实现交给子类
                disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

                return disposer
            }
        }
    }

    func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
        rxAbstractMethod()
    }
}

  

    查看订阅信息的subscribe的源码，发现，方法内创建了一个AnonymousObserver类型的observer。

    public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
        -> Disposable {
            let disposable: Disposable
            
          ...
            
            let observer = AnonymousObserver<E> {  event in   //创建observer，event从AnonymousObserver构建而来
                
                #if DEBUG
                    synchronizationTracker.register(synchronizationErrorMessage: .default)
                    defer { synchronizationTracker.unregister() }
                #endif
                
                switch event {    //对next、error、completed、disposed四个闭包进行初始化
                case .next(let value):    //只要观察者调用了.next事件，就会调用订阅事件.onNext
                    onNext?(value)
                case .error(let error):
                    if let onError = onError {
                        onError(error)
                    }
                    else {
                        Hooks.defaultErrorHandler(callStack, error)
                    }
                    disposable.dispose()
                case .completed:
                    onCompleted?()
                    disposable.dispose()
                }
            }
            return Disposables.create(
                self.asObservable().subscribe(observer),    /*回调了当前序列（即ob）的_subscribeHandler闭包，
AnonymousObservable类里面没有subscrib方法，去他的父类Producer中查找，调用子类的实现*/
                disposable
            )
    }

//AnonymousObserver类
final class AnonymousObserver<ElementType> : ObserverBase<ElementType> {
    typealias Element = ElementType
    
    typealias EventHandler = (Event<Element>) -> Void
    
    private let _eventHandler : EventHandler
    
    init(_ eventHandler: @escaping EventHandler) {
#if TRACE_RESOURCES
        _ = Resources.incrementTotal()
#endif
        self._eventHandler = eventHandler    //保存了包含事件的闭包
    }

    override func onCore(_ event: Event<Element>) {
        return self._eventHandler(event)
    }
    
#if TRACE_RESOURCES
    deinit {
        _ = Resources.decrementTotal()
    }
#endif
}

//asObservable方法定义
 public func asObservable() -> Observable<E> {
     return self
 }

//Producer类
class Producer<Element> : Observable<Element> {
    override init() {
        super.init()
    }

    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        if !CurrentThreadScheduler.isScheduleRequired {
        ...
}