函数式编程

• 响应式编程(Reactive Programming,简称 RP)
• 也是一种范式编程
• 一般与函数式融合一起,所以也叫函数响应式编程(Functiona Reactive Programming,简称 FRP)

ReactiveX

• 有很多种编程语言,如RxJava RxSwift...
• 安装

  # Podfile
  use_frameworks!
  
  target 'YOUR_TARGET_NAME' do
      pod 'RxSwift', '~> 5'
      pod 'RxCocoa', '~> 5'
  end
  
  # RxTest and RxBlocking make the most sense in the context of unit/integration tests
  target 'YOUR_TESTING_TARGET' do
      pod 'RxBlocking', '~> 5'
      pod 'RxTest', '~> 5'
  end
  

RxSwift 核心角色

• Observable: 负责发送实践的 (Event)

• Observer: 负责订阅 Observable ,监听 Observable 发送的事件(Event)

  public enum Event<Element> {
      
      case next(Element) ` 携带数据 `
      
      case error(Swift.Error)  `遵守 swift error 协议,后面消息不发送`
      
      case completed  ` 观察者终止行动 `
  }
  
  

Observable 发布消息

• 代码

  let obs = Observable<Int>.create{ observer in
  
      observer.onNext(11)
      observer.onNext(22)
      observer.onNext(33)
      observer.onCompleted() `完成监听`
      return Disposables.create()
  }
  

subscribe 监听消息

• 代码

  import RxCocoa
  import RxSwift
  
  let bag = DisposeBag() // 回收袋
  
  //第一种方法
      obs.subscribe { event in
          
          switch event {
          case .next(let element):
              print("next", element)
          case .error(let error):
              print("error", error)
          case .completed:
              print("completed")
          }.disposed(by: bag)
      }
      
      
  // 第二种方法
  
      obs.subscribe(onNext: { (element) in
              print("next", element)
          }, onError: { (error) in
              print("error", error)
          }, onCompleted: {
              print("completed")
          })        
          
      
      // 定时器功能
      let obs = Observable<Int>.timer(.seconds(3), period: .seconds(5), scheduler: MainScheduler.instance)
      // 3 秒后启动定时器,每间隔 5 秒,在 主线程上发一次消息
      
  

Disposable 释放 obs

• 每当 Observable 被订阅时,都会返回一个 Disposable 实例,当调用 Disposable 的 dispose , 就相当于取消订阅

• 在不需要再接收事件时,建议取消订阅,释放资源,常见有三种取消订阅方式

  // 第一种
  obs.subscribe { event in
        // do something  
  }.dispose()  //立即取消订阅
  
  
  // 第二种, 
  obs.subscribe { event in
        // do something  
  }.dispose(by: bag)  //bag 回收袋,controller 销毁, bag 销毁,obs 调用取消订阅接口
  
  
  //第三种
  obs
  .takeUntil(self.rx.deallocated) //直到 控制器调用 deallocated 方法,取消订阅
  .subscribe { event in
      // do something
  }
  

创建 Observer

• 通过 AnyObserver 类型创建 obs

      let obs = AnyObserver<Int>.init { event in
          switch event {
              case .next(let element):
                  print("next", element)
              case .error(let error):
                  print("error", error)
              case .completed:
                  print("completed")
          }
      }
          
      // 只调用一次,发送消息内容为 5
      Observable.just(5).subscribe(obs).dispose()           
  
  

• 通过 Observable 类型创建 obs

      let obs = Observable<Int>.create{ observer in
          observer.onNext(33)
          observer.onCompleted()
          return Disposables.create()
      }        
          
      //监听
      obs.subscribe(onNext: { (element) in
              print("next", element)
          }, onError: { (error) in
              print("error", error)
          }, onCompleted: {
              print("completed")
      }).disposed(by: bag)    
          
      obs.subscribe { event in
          switch event {
              case .next(let element):
                  print("next", element)
              case .error(let error):
                  print("error", error)
              case .completed:
                  print("completed")
          }
      }.dispose()    
      
  

• 通过 bind 创建

      
      let binder = Binder<String>(label) { label, text in
          label.text = text
      }
       
      // 监听
      Observable.just(1).map{ "数值: \($0)" }.subscribe(binder).dispose()
      Observable.just(1).map{ "数值: \($0)" }.bind(to:binder).dispose()
      
  

持续更新中...