What is an observable?
Observables are the heart of Rx. An Observable is just a sequence, with some special powers.
- 简单来说，一个
Observable对象就是一个序列Sequence，它可以每隔一定周期产生一定的事件，这个事件保留了数据值，当这个事件被发出的时候，我们就可以使用这个事件中携带的数据。
Observables序列图
Lifecycle of an observable
- .next
- .completed
- .error
Obvervable对象的订阅事件Event
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
}
Creating observables
-
just方法只能产生一个只包含一个元素的可观察序列
let one = 1
let observable: Observable<Int> = Observable<Int>.just(one)
-
of方法能产生一个包含可变数量个元素的可观察序列
// 类型为Observable<Int>，参数类型必须一致
let observable = Observable.of(one, two, three)
// 也可以是一个数组元素, 类型为Observable<[Int]>
let observable = Observable.of([one, two, three])
-
from方法只能接受一个数组类型的参数值
// 类型为Observable<Int>，类型跟数组的类型一致
let observable = Observable.from([one, two, three])
Subscribing to observables
More importantly, an observable won’t send events until it has a subscriber.
- 一般情况下，一个Observable对象创建后，需要绑定一个Subscribe订阅者才能正确捕捉到相应的事件流
let one = 1
let two = 2
let three = 3
let observable = Observable.of(one, two, three)
observable.subscribe { event in
print(event)
}
打印
- 如果要获取到
event中包含的元素值，则可以用event.element:
observable.subscribe { event in
if let element = event.element{
print(element)
}
}
打印
- 当然，默认的
subsribe方法会抛出.next、.completed、.error三个事件，如果你只需要监听.next方法获取数据时，也可以这样做：
observable.subscribe(onNext: { element in
print(element)
})
- 当然，默认情况下一个Observable对象生成是需要绑定数据的，如果你不想指定默认的数据，那么可以用
empty方法生成：
// 这种情况下，由于无法自动推断Observable对象的类型，所以你需要指定类型
let emptyObservable = Observable<Void>.empty()
// 由于一个empty的Observable对象没有任何数据，所以它只能发出一个.completed事件
emptyObservable.subscribe(onNext: { element in
print(element)
}, onCompleted: {
print("completed")
})
- 相比于
empty方法，never方法会产生一个既不会.next也不会.error和.completed的Observable对象，它会一直存在，直到项目结束
let neverObservable = Observable<Any>.never()
neverObservable.subscribe(onNext: { element in
print(element)
}, onCompleted: {
print("completed")
})
- 你可以使用
range方法生成一个Int类型的包含范围数据值的Observable对象：
let rangeObservable = Observable.range(start: 1, count: 10)
rangeObservable.subscribe(onNext: {
print($0)
})
Disposing and terminating
Remember that an observable doesn’t do anything until it receives a subscription. It’s the subscription that triggers an observable to begin emitting events, up until it emits an .error or .completed event and is terminated.
- 销毁一个Obvervable对象，可以通过给他绑定一个订阅对象，当这个对象发出.completed时，它就会被销毁，或者手动然绑定的订阅者
dispose，当然never方法生成的对象除外：
let subscription = Observable<Void>.empty().subscribe {
print($0)
}
subscription.dispose()
- 当然，如果你没创建一个Observable对象，手动dispose它的订阅对象的话，会显得很麻烦，好在RxSwift提供了一个
DisposeBag用来回收这些零散生成的Disposable类型的订阅对象，当这个bag被deinit的时候，这个bag里的Disposable对象就都会被dispose掉，有点类似于NSAutoreleasePool。
let disposeBag = DisposeBag()
let subscription = Observable<Void>.empty().subscribe {
print($0)
}
subscription.disposed(by: disposeBag)
- 你可以用
Observable.create方法创建一个Observable对象，然后订阅相应的事件：
let createObservable = Observable<Any>.create { observer -> Disposable in
observer.onNext([1, 2, 3])
observer.onCompleted()
observer.onNext("?")
return Disposables.create()
}
createObservable.subscribe(onNext: {
print($0)
}, onError: {
print($0)
}, onCompleted: {
print("Completed")
}) {
print("Disposed")
}
打印
- 上述打印可以看到，当你手动将一个observer观察者onCompleted时，就不再发出onNext事件，同样地，如果你将它onError时，onNext和onCompleted事件都不会再发出。
- 另外，如果你不将subsription对象加入disposeBag的话，它也不会发出onCompleted和onDisposed事件，导致内存泄露。
Creating observable factories
- 可以利用
deffered方法生成不同的Observable对象
let disposeBag = DisposeBag()
// 1
var flip = false
// 2
let factory: Observable<Int> = Observable.deferred {
// 3
flip = !flip
// 4
if flip {
return Observable.of(1, 2, 3)
} else {
return Observable.of(4, 5, 6)
}
}
// 批量生成Observable对象
for _ in 0...3 {
factory.subscribe(onNext: {
print($0, terminator: "")
})
.disposed(by: DisposeBag())
print()
}
这一章节到这里就结束了，原作出自Raywenderlich，下一章更新《Subjects》。
如果对你有帮助，别忘了点个赞和关注~
