RXSwift 初次探索

RXSwift的最初探索

iOS 中 咱們經常使用到的函數式編程 oc中的RAC 和 swift中的RXSwift 是很是有影響力的，最近也是嘗試着查看RXSwift的相關信息，今天就從rxswif 入手：

rxswift 的使用方式

例如 咱們常見使用的觀察者模式：在swift 中的使用方式是：

self.person.addObserver(self, forKeyPath: "name", options: .new, context: nil)   
//而後 實現代理

  override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
     print("響應")
     print(change as Any)
 }

 deinit {
    self.removeObserver(self.person, forKeyPath: "name", context: nil)
        }

複製代碼

這樣去執行 而且去觀察 對象的輸出變化 可是在rxswift 中 的代碼塊是這樣子的

self.person.rx.observeWeakly(String.self, "name")
         .subscribe(onNext: { (value) in
             print(value as Any)
         })
         .disposed(by: disposeBag)
複製代碼

這樣 能實現以上觀察者模式相同的代碼內容，完成業務需求。同理，咱們能夠執行一些其餘的對象rx的使用方式：

// UItextFiled:
   self.textFiled.rx.text.orEmpty
         .subscribe(onNext: { (text) in
            print(text)
         })
         .disposed(by: disposeBag)
//UIButton:的使用方式    
     self.button.rx.tap
         .subscribe(onNext: { () in
            print("點擊來了")
        })
                   .disposed(by: disposeBag)    
         
//            
複製代碼

此時，會有疑惑，爲何多個對象都是擁有rx這個屬性的。 這個就須要進入到rx 的裏面去查詢 以button爲例子：

associatedtype CompatibleType

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

   /// Reactive extensions.
   var rx: Reactive<CompatibleType> { get set }
複製代碼

##associatedtype 拓展 定義一個協議時，有的時候聲明一個或多個關聯類型做爲協議定義的一部分將會很是有用。關聯類型爲協議中的某個類型提供了一個佔位名（或者說別名），其表明的實際類型在協議被採納時纔會被指定。 在這裏，由於做者開發大可能是用於oc 對iOS APP的開發，對於oc開發者來講，associatedtype相似於擴展和類別，實現這個的方法。 ok 咱們繼續下去

在全部的對象文件rx 文件中，咱們能看到public protocol ReactiveCompatible,那麼 咱們就能能理解爲，rxswift 在對每一個對象，作到了協議 而後關聯到了對象上面，那麼rxswift 是怎麼去關聯的呢？

extension NSObject: ReactiveCompatible { }
//萬物皆對象啊 兄弟們 /// 打個666
複製代碼

而後講講Observable

let ob = Observable<Any>.create { (obserber) -> Disposable in
            發送信號
            obserber.onNext("")
            obserber.onCompleted()
            obserber.onError(NSError.init(domain: "error info ", code: 8888, userInfo: nil))
            return Disposables.create()
        }
複製代碼

這個地方是對建立的信號序列 的建立 以及信息的發送，

let _ = ob.subscribe(onNext: { (text) in
            print("\(text)")
        }, onError: { (error) in
            print("error: \(error)")
        }, onCompleted: {
            print("完成")
        }) {
            print("銷燬")
        }
       
複製代碼

這裏 是對信息的接收 那麼 rx 內部的實現 就是對序列 信號的響應 在這裏 能夠思考下 爲何 UI層可以被rx 所捕捉到呢？ 思考：

@available(iOS 2.0, *)
open class UIControl : UIView {

   // add target/action for particular event. you can call this multiple times and you can specify multiple target/actions for a particular event.
   // passing in nil as the target goes up the responder chain. The action may optionally include the sender and the event in that order
   // the action cannot be NULL. Note that the target is not retained.
   open func addTarget(_ target: Any?, action: Selector, for controlEvents: UIControl.Event)



複製代碼

點擊controller 不難發現 咱們看到了 addTarget 在此 是否能夠理解爲 rx內部的實現 是不是有對addTarget的監聽 而後 經過selector 去執行了onNext 方法發送信號呢？

繼續...

public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
       return AnonymousObservable(subscribe)
   }
   返回一個匿名的內部類
   
   final private class AnonymousObservable<Element>: Producer<Element> {
   typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable

   let _subscribeHandler: SubscribeHandler

   init(_ subscribeHandler: @escaping SubscribeHandler) {
       self._subscribeHandler = subscribeHandler
   }

   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 的 而且 typealias SubscribeHandler = (AnyObserver<Element>) -> Disposable

   let _subscribeHandler: SubscribeHandle
複製代碼

對這個閉包 作了保存處理

那麼 繼續看subscribe

內容裏面 咱們看到 let observer = AnonymousObserver<E> 是對observer 的初始化，可是並無對應上Observable的obserber 點擊asObservable（） 發現返回的就是ob對象，而且 咱們從Observable 中 並無發現subscribe 的方法，那麼繼續 咱們根據以前的AnonymousObservable 這個匿名函數 點擊進去發現了 繼承與Producer

在點擊進去以後 有個 override func subscribe 的方法，這個裏面

let sinkAndSubscription = self.run(observer, cancel: disposer)
                disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
                
     func run(_ parent: Parent) -> Disposable {
        return parent._subscribeHandler(AnyObserver(self))
    }
                
複製代碼

是將這個交給了子類去實現 run 方法 而後子類實現就是把以前保存的
typealias Parent = AnonymousObservable<E> parent._subscribeHandler(AnyObserver(self)) 當前保存的閉包 提交了出去 ，那麼 看到的

return Disposables.create(
              self.asObservable().subscribe(observer),
              disposable
          )
複製代碼

將咱們以前ob 建立的對象內容提交到了 subscribe

也就是說 obserber.onNext("我就玩玩") 發送後 subscribe裏面的

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()
               }
           }
複製代碼

就捕捉到了信號 而後根據閉包 返回到了 咱們所須要的onnet 接收器內

目前 這就是我所理解的信號 0點了 睡覺 有問題的 你們幫我找下 我好糾正個人觀點