RxSwift之Observable、创建可观察序列

Observable

Observable<T>就是可观察序列，可以异步地产生一系列的event。

• 一个Observable<T>对象会随着时间推移不定期地发出event( element: T )；
• Event可以携带数据，它的泛型<T>用来指定Event携带的数据的类型；
• 有了可观察序列，还需要有一个Observer来订阅它，这样订阅者才能收到Observable<T>不时发出的Event。

Event

Event是一个枚举，表示Observable发出的事件，共有三种类型：

public enum Event<Element> {
    /// Next element is produced.
    case next(Element)
 
    /// Sequence terminated with an error.
    case error(Swift.Error)
 
    /// Sequence completed successfully.
    case completed
}

• next：next事件就是可以携带数据<T>的事件，表示一个正常的事件；
• error：error事件表示一个错误，它可以携带具体的错误内容，一旦Observable发出了error event，这个Observable就终止了，以后它再也不会发出event了；
• completed：completed事件表示Observable发出的事件正常地结束了，一旦Observable发出了completed event，这个Observable就终止了，以后再也不会发出event了。

Observable与Sequence

联系：一个Observable( ObservableType)相当于一个序列Sequence(SequenceType)，ObservableType.subscribe(_:)方法相当于SequenceType.generate()

区别：

• swift中的SequenceType是同步的循环，而Observable是异步的；
• Observable对象会在有任何Event的时候，自动将Event作为一个参数通过ObservableType.subscribe(_:)发出，并不需要使用next方法。

创建Observable序列的方法

just()：通过传入一个默认值来初始化

let observable = Observable<Int>.just(5)//可以指定类型，也可以通过类型推断

of()方法：接收可变数量的参数（同类型）

let observable = Observable.of("A","B","C")

from()：通过一个数组进行初始化

let observable = Observable.from(["A","B","C"])

empty()：创建一个空内容的Observable序列

let observable = Observable<Int>.empty()

never()：创建一个永远不会发出event，也不会终止的Observable序列

let observable = Observable<Int>.never()

error()：创建一个直接发送一个错误的Observable序列

enum MyError: Error {
  case A,B
}
let observable = Observable<Int>.error(MyError.A)

range()：通过指定起始和结束数值，创建一个以这个范围内所有值所谓初始值的Observable序列

let observable = Observable.range(start:1, count:5)
// 等价于
let observable = Observable.of(1,2,3,4,5)

repeatElement()：创建一个可以无限发出给定元素的Event和Observable序列（永不终止）

let observable = Observable.repeatElement(1)

generate()：创建一个只有当提供的所有判断条件都为true的时候，才会给出动作的Observable序列

let observable = Observable.generate(
initialState:0,
condition:{ $0 <= 10 },
iterate:{ $0 + 2 }
)
// 等价于
let observable = Observable.of(0,2,4,6,8,10)

create():接收一个block参数，对每一个过来的订阅进行处理

//当订阅者订阅一个Observable对象时，会将订阅者作为参数传入block
let observable = Observable<String>.create { observer in
	//对订阅者发出.next事件，且携带了一个数据“next事件数据”
	observer.onNext("next事件数据")                  
	// 对订阅者发出了.completed事件
	observer.onCompleted()
	// 订阅行为需要一个Disposable类型的返回值
	return Disposables.create()
}
observable.subscribe{
  print($0)
}
// 运行结果：
next("next事件数据")
completed

deferred()

该方法相当于创建一个Observable工厂，通过传入一个block来执行延迟Observable序列创建的行为，这个block是真正的实例化序列对象的地方。

let isOdd = false//判断奇偶的标记
let factory : Observable<Int> = Observable.deferred {
  isOdd = !isOdd
  if isOdd {
    return Observable.of(1,3)
  }else {
    return Observable.of(2,4)
  }
}
// 第一次订阅
factory.subscribe { event in
  print("\(isOdd)", event)
}
// 第二次订阅
factory.subscribe { event in
  print("\(isOdd)", event)
}
// 运行结果：
true next(1)
true next(3)
true completed
false next(2)
false next(4)
false completed

interval()方法

该方法创建的Observable序列每隔一段设定的时间，会发出一个索引数的元素，而且会一直发送下去

// 在主线程上每隔1秒发送一次
let observable = Observable<Int>.interval(1,scheduler:MainScheduler.instance)
observable.subscribe { event in
  print(event)
}
// 运行结果
next(0)
next(1)
next(2)
...

timer()

• 用途1：创建的Observable序列在经过设定的时间后产生一个唯一的元素

  let observable = Observable<Int>.timer(5, scheduler:MainScheduler.instance)
  observable.subscribe { event in
    print(event)
  }
  // 运行结果:5秒后打印
  next(0)
  completed

• 用途2：创建的Observable序列在经过设定的时候后，每隔一段时间产生一个元素

  let observable = Observable<Int>.timer(5, period:1, scheduler:MainScheduler.instance)
  observable.subscribe { event in
    print(event)
  }
  // 运行结果：5秒后开始打印
  next(0)
  next(1)
  next(2)
  ...