RxSwift Observable(观察量) subscribe(订阅)

RxSwift Observable(观察量) subscribe(订阅)

1.观察量Observable

(监听 元素一系列变化 并且 内部相应作出处理) 生成的一个方法

这个元素可以是多样化，比如array，string，button的事件，文本框的字符串变化。

特点

• Observable< E >，E代表观察的元素类型

• 转化为一个序列，本身并不会触发执行。

• 只有 被订阅的时候，才会触发执行。

• 如果是无限序列，比如按钮点击事件，在不需要的时候需要disposable

  ​

  Example

  1. Never

     产生一个观察量，但永不执行

     func rx_Observable_never(){
     // 处置管理器，相当于arc管理
     let disposBag = DisposeBag()
     Observable<String>.never().subscribe { _ in
              print("never永远不会执行")
              }.addDisposableTo(disposBag) //将这个rx资源加入管理器disposBag
     }

     //上面是函数组合调用，这里分解开来写
     func rx_Observable_never(){
      let disposeBag = DisposeBag()//处置器
      let neverSequence = Observable<String>.never()//观察量序列
     
      //订阅
      let neverSequenceSubscription = neverSequence
          .subscribe { _ in
              print("This will never be printed")
      }
     
      //回收
      neverSequenceSubscription.addDisposableTo(disposeBag)
     }

     ​

  2. empty

     空的观察量序列，就是除了完成信号，再也没有其他的了

     func rx_Observable_empty(){
      let disposeBag = DisposeBag()
     
      Observable<Int>.empty()
          .subscribe { event in
              print(event)
          }
          .addDisposableTo(disposeBag)
     }

     ​

  3. just

     观察量只有一个元素

     func rx_Observable_just(){
      let disposeBag = DisposeBag()
     
      Observable.just("��")
          .subscribe { event in
              print(event)
          }
          .addDisposableTo(disposeBag)
     }

     ​

  4. of

     固定数量的元素 转化为观察量序列

     func rx_Observable_of(){
      let disposeBag = DisposeBag()
     
      Observable.of("��","��", "��", "��", "��")
          .subscribe(onNext: { element in
              print(element)
          })
          .addDisposableTo(disposeBag)
     }

     ​

  5. from

     将数组或者字典或其他集合 转化为观察量序列

     func rx_Observable_from(){
      let disposeBag = DisposeBag()
     
      Observable.from(["��", "��", "��", "��"])
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)
     }

     ​

  6. create

     创建自定义的观察量序列

     // 传入一个数组，返回一个 观察量序列
     func rx_Observable_create(){
      let test = { (arr:[String])->Observable<String> in
              return Observable.create{ observer in
     
                  for element in arr{
                      // 订阅事件流
                      observer.onNext(element)
                  }
     
                  // 完成
                  observer.onCompleted()
     
                  // 一个订阅事件 包含一个返回的disposable 取消方法
                  return Disposables.create {
                      print("妹纸，来嘿嘿嘿吧")
                  }
              }
          }
     
      }
     
     test(arr: ["短裙","美腿","丝袜","高跟"]).subscribe(onNext: { x in
              print("哎哟这\(x)不错哦")
          }).addDisposableTo(disposeBag)
     
     }

     ​

  7. range

     创建一个 观察量序列 为连续的整数

     func rx_Observable_range(){
      let disposeBag = DisposeBag()
     
      Observable.range(start: 1, count: 10)
          .subscribe { print($0) }
          .addDisposableTo(disposeBag)
     }

  8. repeatElement

     将一个固定元素重复无限发送的 观察量序列

     func rx_Observable_repeatElement() {
      let disposeBag = DisposeBag()
     
      Observable.repeatElement("��")
          .take(3)//发送三次，这个去掉无限发送
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)
     }

     ​

  9. generate

     generate生成一个条件环境, 把再这个环境中的符合条件的信号发送出去

     func rx_Observable_generate() {
      let disposeBag = DisposeBag()
     
      Observable.generate(
              initialState: 0,
              condition: { $0 < 3 },
              iterate: { $0 + 1 }
          )
          .subscribe(onNext: { print($0) })
          .addDisposableTo(disposeBag)
     }

     ​

  10. deferred

      产生一个观察量序列，条件:只有被订阅的时候才实际的创建出来

      func rx_Observable_deferred() {
       let disposeBag = DisposeBag()
       var count = 1
      
       let deferredSequence = Observable<String>.deferred {
           print("Creating \(count)")
           count += 1
      
           return Observable.create { observer in
               print("Emitting...")
               observer.onNext("��")
               observer.onNext("��")
               observer.onNext("��")
               return Disposables.create()
           }
       }
      
       deferredSequence
           .subscribe(onNext: { print($0) })
           .addDisposableTo(disposeBag)
      
       deferredSequence
           .subscribe(onNext: { print($0) })
           .addDisposableTo(disposeBag)
      }

      ​

  11. error
      发送一个错误的观察量序列

      func rx_Observable_error() {
      let disposeBag = DisposeBag()
      
       Observable<Int>.error(TestError.test)
           .subscribe { print($0) }
           .addDisposableTo(disposeBag)
      }

  12. doOn
      对每个发出的事件调用副作用操作，并返回（传递）原始事件。

      func rx_Observable_doOn() {
       let disposeBag = DisposeBag()
      
       Observable.of("��", "��", "��", "��")
           .do(onNext: { print("Intercepted:", $0) }, onError: { print("Intercepted error:", $0) }, onCompleted: { print("Completed")  })
           .subscribe(onNext: { print($0) })
           .addDisposableTo(disposeBag)
      }

      ​

  ​

  // 传入一个数组，返回一个 观察量序列,观察的类型是泛型E    
  func test<E>(arr:[E])->Observable<E>{                
  // 返回观察量序列        
  // 创建观察量，传入一个 订阅事件，返回一个观察量序列        
  return Observable.create{ observer in                        for element in arr{                
  // 订阅事件流               
  observer.onNext(element)           
  }                        
  // 完成            
  observer.onCompleted()                        
  // 一个订阅事件 包含一个返回的disposable 取消方法            
  return Disposables.create()        
  }    
  }

  ​

---

2. 订阅 subscribe

• 触发观察量序列的执行
• 无限序列使用完订阅 记得 disposable
• 多个订阅者 订阅一个观察量序列，序列事件触发时，会通知每一个订阅者。

test(arr: ["美腿","丝袜","短裙","高跟"]).subscribe(

            // 接收的序列，传过来的什么，就是什么
            onNext: { x in
            print(x)
        }, onError: { Error in
            print(Error)
        }, onCompleted: { 
            print("完成")
        }) { 
            print("取消")
        }.dispose()// 这里是有限的序列，可以不调用，无限序列使用完毕需要调用