RXSwift 初次探索

时间 2019-11-07

标签 rxswift 初次探索繁體版

原文原文链接

RXSwift的最初探索

iOS 中咱们经常使用到的函数式编程 oc中的RAC 和 swift中的RXSwift 是很是有影响力的，最近也是尝试着查看RXSwift的相关信息，今天就从rxswif 入手：编程

rxswift 的使用方式

例如咱们常见使用的观察者模式：在swift 中的使用方式是：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 中的代码块是这样子的api

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

这样能实现以上观察者模式相同的代码内容，完成业务需求。同理，咱们能够执行一些其余的对象rx的使用方式：bash

// 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 咱们继续下去dom

在全部的对象文件rx 文件中，咱们能看到public protocol ReactiveCompatible,那么咱们就能能理解为，rxswift 在对每一个对象，作到了协议而后关联到了对象上面，那么rxswift 是怎么去关联的呢？ide

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 方法发送信号呢？ui

继续...

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点了睡觉有问题的你们帮我找下我好纠正个人观点