Observable

Observable生命周期

• 发出next事件，可以继续发出事件
• 发出error事件，Observable生命结束，不能继续发出事件
• 发出completed事件，Observable生命结束，不能继续发出事件

RxSwift事件定义：

/// Represents a sequence event.
///
/// Sequence grammar: 
/// **next\* (error | completed)**
public enum Event {
    /// Next element is produced.
    case next(Element)

    /// Sequence terminated with an error.
    case error(Swift.Error)

    /// Sequence completed successfully.
    case completed
}

创建Observable

• just

// 1
let one = 1
let two = 2
let three = 3
// 2
let observable: Observable = Observable.just(one)

创建一个序列，只包含一个元素。

• of

let observable = Observable.of(one, two, three)

of包含多个元素。

• from

let observable = Observable.from([one, two, three])

from包含一个集合，可以是数组，集合，字典，Observable会拆解这个数组，一个个发出元素。

• empty

let observable = Observable.empty()

empty不包含任何元素，只会发出一个Completed事件。必须指定元素类型，因为没有元素让Swift来推导类型。这里用Void类型没有实际意义，只是表示没有值而已，其他类型也可以。

• never

let observable = Observable.never()

never不发送任何事件，也永远不会结束。这里类型Any的意义和上面的Void一样。

• range

let observable = Observable.range(start: 1, count: 10)

range应该很好理解。

上面的创建Observable的方法都可以看做是方便方法，实际的定制方法是下面的create

• create

Observable.create { observer in
  // 1
  observer.onNext("1")
  // 2
  observer.onCompleted()
  return Disposables.create()
}

• deferred

let disposeBag = DisposeBag()
// 1
var flip = false
// 2
let factory: Observable = Observable.deferred {
  // 3
  flip = !flip
  // 4
  if flip {
      return Observable.of(1, 2, 3)
  } else {
      return Observable.of(4, 5, 6)
  }
}

和create不同的地方是，create会捕获外面传入的变量，而deferred不会捕获变量，会在每次订阅时，创建deferred闭包。
参考

可以不用指明元素类型，Swift可以推导出。

订阅Observable

Observable只有被订阅了才会发出事件。

这个机制就像Swift里的sequence迭代器，每次调用next()，取一个值。

let sequence = 0..<3
var iterator = sequence.makeIterator()
while let n = iterator.next() {
    print(n) 
}
/* 
Prints: 
0
1 
2 
*/

Subscribe定义：

    /**
     Subscribes an event handler to an observable sequence.
     
     - parameter on: Action to invoke for each event in the observable sequence.
     - returns: Subscription object used to unsubscribe from the observable sequence.
     */
    func subscribe(_ on: @escaping (Event) -> Void)
        -> Disposable

传入Event枚举类型

    /**
     Subscribes an element handler, an error handler, a completion handler and disposed handler to an observable sequence.
     
     - parameter onNext: Action to invoke for each element in the observable sequence.
     - parameter onError: Action to invoke upon errored termination of the observable sequence.
     - parameter onCompleted: Action to invoke upon graceful termination of the observable sequence.
     - parameter onDisposed: Action to invoke upon any type of termination of sequence (if the sequence has
     gracefully completed, errored, or if the generation is canceled by disposing subscription).
     - returns: Subscription object used to unsubscribe from the observable sequence.
     */
    public func subscribe(onNext: ((E) -> Void)? = nil, onError: ((Swift.Error) -> Void)? = nil, onCompleted: (() -> Void)? = nil, onDisposed: (() -> Void)? = nil)
        -> Disposable

直接传入元素E

Dispose

结束一个订阅，防止内存泄漏:
类似于MRC时代，内存管理中的relase，和autorelase

如果要立即释放订阅者，直接dispose()

// 1
let observable = Observable.of("A", "B", "C")
// 2
let subscription = observable.subscribe { event in
// 3
  print(event)
}
subscription.dispose()

注意，这里的dispose()会立即执行，结束订阅。真实环境中，要依情况而定。
disposeBag

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

注意，这里的disposeBag是局部变量，执行完了就会释放。真实环境中，要依情况而定。加入disposeBag里面的订阅者什么时候释放？1.在disposeBag释放的时候；2.订阅者本身结束事件发生，例如发送error，completed事件。

使用Trait

使用不同的方法实现同样的功能，目的是使代码跟可读。下面是取代Observable的对象：

• Single

只发送一次.success(value)或者.error事件。

Single.create { single in
  let disposable = Disposables.create()
  single(.error(FileReadError.fileNotFound))
  single(.success(contents))
  return disposable
}

可以用.asSingle()转Observable

• Completable

只发送一次.completed或者.error事件。

• Maybe

只发送一次发送.success(value)，.completed或者.error事件。

可以用.asMaybe()转Observable。