RxSwift 系列(一) -- Observables

为什么使用RxSwift?

我们编写的代码绝大多数都涉及对外部事件的响应。当用户点击操作时，我们需要编写一个@IBAction事件来响应。我们需要观察通知，以检测键盘何时改变位置。当网络请求响应数据时，我们必须提供闭包来执行。我们使用KVO来检测变量的变化。所有这些不同的系统使我们的代码增加了不必要地复杂。如果有一个一致的系统来处理我们的所有的调用/响应代码，难道不是更好吗?Rx就是这样一个系统。

RxSwift是用于大多数主要语言和平台的响应扩展(即Rx)的正式实现。

概念

每一个Observable的实例都是一个序列

Observable序列相比于Swift序列的关键优势点在于它能够异步地接收元素。这是RxSwift精髓所在，其他的一切都扩展了这个概念。

• Observable(ObservableType)等效于Sequence
• observableType.subscribe(_:)方法等效于Sequence.makeIterator()
• ObservableType.subscribe(_:)接收一个观察者ObserverType参数,它将被订阅自动接收由可观察到的序列事件和元素，而不是在返回的生成器上手动调用next()

如果一个Observable发出一个next事件(Event.next(Element)),它还能够继续发出更多的事件。但是，如果一个Observable发出一个error事件(Event.error(ErrorType))或者一个completed事件(Event.completed)，那么这个Observable序列就不能给订阅者发送其他的事件了。

Observables and Observers(又名subscribers -- 订阅者)

除非有订阅者，否则Observable不会执行它们的闭包。
在下面的例子中，Observable的闭包将不会被执行，因为没有订阅者订阅。

_ = Observable<String>.create({ (observingString) -> Disposable in
        print("the code will not be executed")
        observingString.onNext("😁")
        observingString.onCompleted()
        return Disposables.create()
    })

在下面的例子中，Observable的闭包将会被执行，因为有订阅者订阅。

_ = Observable<String>.create({ (observingString) -> Disposable in
        print("the code will be executed")
        observingString.onNext("😁")
        observingString.onCompleted()
        return Disposables.create()
    }).subscribe({ (event) in
        print(event)
    })

我们现在不必担心上面例子中的Observable是怎样被创建出来，我会和大家一步一步深入学习。

subscribe(_:)返回一个一次性的实例，该实例表示一个可使用的资源，如订阅。在前面的简单示例中，它被忽略了，但是应该正常地处理它。这通常意味着将它添加到一个DisposeBag实例中。

Creating and Subscribing to Observables

有几种方式创建和订阅Observables:

• never
  创建一个永不终止且不发出任何事件的序列。更多详情

  let disposeBag = DisposeBag()
  Observable<String>.never().subscribe({ (_) in
      print("this will never be printed")
  }).disposed(by: disposeBag)
  

• empty
  创建一个只发送completed事件的空Observable序列。更多详情

  let disposeBag = DisposeBag()
  Observable<Int>.empty().subscribe({ (event) in
      print(event)
  }).disposed(by: disposeBag)
  

• just
  创建一个只有一个元素的Observable序列。更多详情

  let disposeBag = DisposeBag()
  Observable.just("单一元素").subscribe({ (event) in
      print(event)
  }).disposed(by: disposeBag)
  

• of
  创建一个固定数量元素的Observable序列。

  let disposeBag = DisposeBag()
  Observable.of("元素1","元素2","元素3","元素4","元素5").subscribe(onNext: { (element) in
      print(element)
  }).disposed(by: disposeBag)
  

  注意：此处用到了subscribe(onNext:)的便利构造方法，有部分参数使用的是默认值。

• from
  从一个序列(如Array/Dictionary/Set)中创建一个Observable序列。

  let disposeBag = DisposeBag()
  Observable.from(["元素1","元素2","元素3","元素4","元素5"]).subscribe(onNext: {
      print($0)
  }).disposed(by: disposeBag)
  

  注意：这个例子使用了默认参数$0而不是显式地命名参数。

• create
  创建一个自定义的Observable序列。更多详情

  let disposeBag = DisposeBag()
  let myjust = { (element: String) -> Observable<String> in
      return Observable.create{ observer in
          observer.on(.next(element))
          observer.on(.completed)
          return Disposables.create()
      }
  }
  
  myjust("篮球").subscribe({ (element) in
      print(element)
  }).disposed(by: disposeBag)
  
  

• range
  创建一个Observable序列，它会发出一系列连续的整数，然后终止。更多详情

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

• repeatElement
  创建一个Observable序列，它可以无限地释放给定元素。更多详情

  let disposeBag = DisposeBag()
  Observable.repeatElement("🏀").take(3).subscribe(onNext: {print($0)}).disposed(by: disposeBag)
  

  上述例子中take操作符从一个序列开始返回指定数量的元素。

• generate
  创建一个Observable序列，只要提供的条件值为true就可以生成值。

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

• deferred
  为每一个订阅者创建一个新的Observable序列。更多详情

  let disposeBag = DisposeBag()
  var count = 1
  let defferedSequen = Observable<String>.deferred {
      print("count = \(count)")
      count += 1
      
      return Observable.create({ (observer) -> Disposable in
          observer.onNext("山羊")
          observer.onNext("野猪")
          observer.onNext("小猫")
          
          return Disposables.create()
      })
  }
  
  defferedSequen.subscribe(onNext: {print($0)}).disposed(by: disposeBag)
  defferedSequen.subscribe(onNext: {print($0)}).disposed(by: disposeBag)
  

• error
  创建一个不会发送任何条目并且立即终止错误的Observable序列。

  let disposeBag = DisposeBag()
  Observable<Int>.error(TestError.test).subscribe { print($0) }.disposed(by: disposeBag)
  

• do
  为每个发出的事件调用一个副作用操作，并返回(通过)原始事件。更多详情

  let disposeBag = DisposeBag()
  Observable.of(["元素1","元素2","元素3"]).do(onNext: {print("next:\($0)")}, onError: {print("error:\($0)")}, onCompleted: { 
      print("completed")
  }).subscribe(onNext: {print($0)}).disposed(by: disposeBag)
  

致谢

若发现有错误的地方，欢迎各位评论，感谢！同时也希望能够帮助到有需要的同学。