实战RxSwift中的Observable, subscribe, dispose, filter

可观察的生命周期

在上图中，可观察到的发射了9个元素。当一个可观察对象发出一个元素时，它会在下一个事件中发出它。

Observable发出三个轻击事件，然后结束。这称为completed事件。

可观察对象发出error包含错误的事件。如果一个可观察对象发出一个error事件，则它也将终止并且不能再发出其他任何事件。

一个observable发出next包含元素的事件。

初始化环境

创建一个项目命名为RXSwiftDemo，在命令行pod init, 在podfile 中填写如下内容，并运行pod install.

# Uncomment the next line to define a global platform for your project
# platform :ios, '9.0'

target 'RXSwiftDemo' do
  # Comment the next line if you don't want to use dynamic frameworks
  use_frameworks!

  # Pods for RXSwiftDemo
  pod 'RxSwift', '6.1.0'
  pod 'RxCocoa', '6.1.0'

  target 'RXSwiftDemoUITests' do
    pod 'RxBlocking', '6.1.0'
    pod 'RxTest', '6.1.0'
  end

end

打开workspace就可以进行实战。

创建observable

just恰当地命名，因为它所做的只是创建一个包含just单个元素的可观察序列。

在操作者从元件的规则阵列创建一个可观察到的个体类型实例的from。

您可以of用来创建observable的数组或创建单个类型的可观察的数组。

下面的示例可以辨别just，of和from。

 let one = 1
  let two = 2
  let three = 3
  /// This is a singe element observable
  let observable: Observable<Int> = Observable<Int>.just(one)
  
  /// This is an observable of individual type instances from a array
  let observable2 = Observable.of(one, two, three)
  
  /// This is an observables array using of to create
  let observable3 = Observable.of([one, two, three])
  
  /// This is an observable of individual type instances from a array
  let observable4 = Observable.from([one, two, three])

订阅观察值subscribe

观察者 是用来监听事件，然后它需要这个事件做出响应。例如：弹出提示框就是观察者，它对点击按钮这个事件做出响应。

订阅RxSwift可观察对象是非常相似的；您称观察为可观察的subscribing。

因此addObserver()，您可以使用代替subscribe()。

与NotificationCenter开发人员通常仅使用其.default单例实例不同，Rx中的每个可观察实例都不同。

更重要的是，observable只有拥有订阅者才能发送事件。
遵守可观察变量的例子

let one = 1
  let two = 2
  let three = 3
  /// This is an observable of individual type instances from a array
  let observable = Observable.of(one, two, three)
  
  /// Subscribes an element handler
  observable.subscribe(onNext: {
    
     element in
    print(element) // Result will be: 1,2,3
  })
  
  /// Subscribes an event handler to an observable sequence.
  observable.subscribe {
    
     event in
    print(event) // Result will be: next(1) next(2) next(3) completed
  }

的empty操作者创建具有零个元素的空可观察序列。它只会发出一个.completed事件。

let observable = Observable<Void>.empty()
    observable
      .subscribe(
        onNext: {
    
     element in
          print(element)
      },
        /// When empty an observable, it will go to completed block
        onCompleted: {
    
    
          print("Completed")
      }
    )

在never操作创建一个可观察到的不排放任何东西，从来没有终止

/// If never an observable, it will not emit anything
let observable = Observable<Any>.never()
    observable
      .subscribe(
        onNext: {
    
     element in
          print(element)
      },
        onCompleted: {
    
    
          print("Completed")
      }
    )

处置和终止dispose

要明确取消订阅，请调用dispose()它。取消订阅或取消订阅后，dispose当前示例中的observable将停止发出事件

let observable = Observable.of("A", "B", "C")
  let subscription = observable.subscribe {
    
     event in
    print(event)
  }
  /// When dispose, the observable can not emit anything
  subscription.dispose()

单独管理每个订阅将很乏味，因此RxSwift包含一个DisposeBag类型。处置袋可容纳通常使用此.disposed(by: disposeBag)方法添加的一次性用品，并dispose()在处置袋即将被释放时将呼叫每个处置袋。

let disposeBag = DisposeBag()
        Observable.of("A", "B", "C")
            .subscribe {
    
    
            print($0)
            }.disposed(by: disposeBag)

该create运营商有一个名为一个参数subscribe。它的工作是提供可观察的调用订阅的实现。
使用create定制的可观察

let disposeBag = DisposeBag()
Observable<String>.create {
    
     (observer) -> Disposable in
            observer.onNext("1")
            observer.onNext("?")
            
            return Disposables.create()
        }.subscribe(
            onNext: {
    
     print($0) },
            onError: {
    
     print($0) },
            onCompleted: {
    
     print("Completed") })
        .disposed(by: disposeBag)

Operator - 操作符 - Filter

操作符可以帮助大家创建新的序列，或者变化组合原有的序列，从而生成一个新的序列。

我们之前在输入验证例子中就多次运用到操作符。例如，通过 map 方法将输入的用户名，转换为用户名是否有效。然后用这个转化后来的序列来控制红色提示语是否隐藏。我们还通过 combineLatest 方法，将用户名是否有效和密码是否有效合并成两者是否同时有效。然后用这个合成后来的序列来控制按钮是否可点击。

这里 map 和 combineLatest 都是操作符，它们可以帮助我们构建所需要的序列。现在，我们再来看几个例子：

filter - 过滤

let disposeBag = DisposeBag()
let rxTemperature: Observable<Double> = Observable.of(10.0, 11.0, 20.0, 35.0, 40.0)
        rxTemperature.filter {
    
     temperature in
            temperature > 33
        }.subscribe(onNext: {
    
     temperature in
            print("high temperature \(temperature)°")
        }).disposed(by: disposeBag)

建立可观察的工厂

deferred 延迟读取值直到订阅.

deferred有一个需要记住的特征。每次有新观察者时，deferred都会从其关闭中创建Observable。这意味着订阅2次将创建2个可观察对象。它会影响性能，但不太可能发生
deferred订阅长计算功能时会有所帮助（如果使用create或，则会阻塞just）

let disposeBag = DisposeBag()
var flip = false
        
        let factory: Observable<Int> = Observable.deferred {
    
     () -> Observable<Int> in
            flip = !flip
            
            if flip {
    
    
                return Observable.of(1, 2, 3)
            } else {
    
    
                return Observable.of(4, 5, 6)
            }
        }
        
        for _ in 0...1 {
    
    
            factory.subscribe(onNext: {
    
    
                print($0, terminator: " ... ")
            }).disposed(by: disposeBag)
            print()
        }

参考

https://medium.com/@duydtdev/observables-in-rxswift-f2f451df49b7

https://beeth0ven.github.io/RxSwift-Chinese-Documentation/content/rxswift_core/observable.html

https://github.com/ReactiveX/RxSwift