RxSwift初步学习和探究Observable函数编程（functional programming，简称FP）的核心

RxSwift初步学习和探究Observable

RxSwift学习指南和参考

大概的使用和理解参考了这边文章 Rxswift的使用详解

什么叫函数式编程，以及函数式编程的思想

函数编程（functional programming，简称FP）的核心就是一切皆函数，函数本质是一种变换x->f(x);函数式编程是一种编程范式，如何写程序的方法论，主要的思想运算过程中写成一系列嵌套的函数。

函数编程的特点

函数是一等公民
- 可以把函数作为参数传递给另一个参数，即高阶函数
- 可以返回一个函数，有助于实现闭包和惰性计算
只用表达式，而不用语句
没有副作用
不修改状态
引用透明，函数的输出结果只依赖于输入的参数

`Rxswift`的只要研究对象

RX中signal,observer,observable,subject主要负责数据的流动，scheduler`负责执行线程相关的操作

探究`observable`

什么是`observable`

observable是可观察序列，序列是一系列相同值的集合，并且提供对这些值的迭代能力，可以为有穷序列，也可以为无穷序列。

利用序列的思维能让未来的事情随时响应，这是响应式最核心的应用。

`observable`的生命周期

有限的next
无穷的next
完成事件complete
错误的时间error
创建序列 let ob = Observable<Any>.create
订阅序列 ob.subscribe
send signal
- observer.onNext
- observer.onError
- observer.onComplete

简单探究从创建到订阅再到收到信号

以下是可观察序列的创建发送信号订阅代码

	// 1.创建序列
let ob = Observable<Any>.create { (obserber) -> Disposable in
       // 3:发送信号
       obserber.onNext("发送信号")
       obserber.onCompleted()
       obserber.onError(NSError.init(domain: "XXXX", code: 100886, userInfo: nil))
       return Disposables.create()
   }
        
// 2:订阅信号
let _ = ob.subscribe(onNext: { (text) in
	print("收到:\(text)")
}, onError: { (error) in
	print("error: \(error)")
}, onCompleted: {
	print("完成")
}) {
	print("销毁")
}

######下边的创建可观察序列的调用

extension ObservableType {

    /**
         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>
}

代码点评： 调用的部分显示这是对ObservableType的扩展，而这个ObservableType是一个继承自ObservableConvertibleType的协议，所以这就是一个协议的扩展定义。

代码注释说明create利用指定的订阅实现传建一个序列，可以参考create.swift的中的实现,即create实现了这个协议，那么就可以create的内容了。

在create.swift中我们可以看到，对其的实现


extension ObservableType {
    // MARK: create

    /**
     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 (AnyObserver<E>) -> Disposable) -> Observable<E> {
        return AnonymousObservable(subscribe)
    }
}

代码点评： 代码返回的数据是return AnonymousObservable(subscribe),即create的调用是把我们的闭包传给AnonymousObservable初始化

接下来看看AnonymousObservable的内容

这段代码将我们的闭包保存到_sunscribeHandler中，到此创建过程结束

在这里我们需要进一步探究Producer


class Producer<Element> : Observable<Element> {
    override init() {
        super.init()
    }
    override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element{...}
    func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {}// 子类具体实现

代码分析 AnonymousObservable是继承自Producer，Producer中实现了subscribe方法，这个是后边订阅会用到的，在此我们可以先Mark一下

下边是订阅的调用流程

在调用subscribe(onNext:_ , onError:_ , onCompleted:_)时发生了什么在ObservableType+Extensions.swift的文件中我们可以找到这个代码的实现，同上边的create，subscribe也是ObservableType的扩展协议


/**
Subscribes an element handler, an error handler, a completion handler and disposed handler to an observable sequence.
     
- parameter onNext: Action to invoke for each element in the observable sequence.
- parameter onError: Action to invoke upon errored termination of the observable sequence.
- parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
- parameter onDisposed: Action to invoke upon any type of termination of sequence (if the sequence has
gracefully completed, errored, or if the generation is canceled by disposing subscription).
- returns: Subscription object used to unsubscribe from the observable sequence.
*/
public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
   -> Disposable {
       let disposable: Disposable
       
       if let disposed = onDisposed {
           disposable = Disposables.create(with: disposed)
       }
       else {
           disposable = Disposables.create()
       }
       
       #if DEBUG
           let synchronizationTracker = SynchronizationTracker()
       #endif
       
       let callStack = Hooks.recordCallStackOnError ? Hooks.customCaptureSubscriptionCallstack() : []
       
       let observer = AnonymousObserver<E> { event in
           
           #if DEBUG
               synchronizationTracker.register(synchronizationErrorMessage: .default)
               defer { synchronizationTracker.unregister() }
           #endif
           
           switch event {
           case .next(let value):
               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),
           disposable
       )
}

代码分析 我们重点关注我们相关的onNext,onError,onCompleted的调用

重点分析 这里我们看到了，创建了一个观察者observer，这个观察者是AnonymousObserver的观察者，这个观察者的构造是用过尾随闭包将以上的onNext``onError``onCompleted传入的，其实现如下

再看我们的subscribe的实现中，在最后返回时调用的是

return Disposables.create(self.asObservable().subscribe(observer),disposable)

可知调用的逻辑就是

let result = self.asObservable().subscribe(observer) //这里是真正的调用observer中的闭包
return Disposables.create(result,disposable)

我们的self序列化后又订阅了一个本地的observer，这个observer包含我们外部订阅的相关信息，这次的订阅的会触发我们上边Mark的位置，即会触发subscribe的self.run运行，会调用AnonymousObservable中的run 代码如下

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

这个run操作就会触发我们原来生成序列时候保存的_subscribeHandler 至此，我们找到了具体的启动位置，此处应该给自己鼓个掌“👏👏👏👏”

画一个时序图

RxSwift初步学习和探究Observable