| 操作符 | 描述 |
|---|---|
| interval | 每隔一段时间，发出一个索引数，将发出无数个元素 |
| timer | 在一段延时后，每隔一段时间产生一个元素 |
| timeout | 在一段时间内没有产生元素，timeout 操作符将使它发出一个 error 事件 |
| delay | 将 Observable 的每一个元素拖延一段时间后发出 |
| delaySubscription | 操作符将在经过所设定的时间后，才对 Observable 进行订阅操作。 |
| materialize | 该操作符可以将序列产生的事件，转换成元素 |
| dematerialize | 操作符将 materialize 转换后的元素还原 |
| deferred | 订阅发生时，为每位订阅者创建全新的 Observable,保证拿到的数据都是最新的。起到一个延迟创建的作用 |
| using | using 使用 using 操作符创建 Observable 时，同时会创建一个可被清除的资源，一旦 Observable 终止了，那么这个资源就会被清除掉了。 |
-
interval
创建一个 Observable 每隔一段时间，发出一个索引数，将发出无数个元素。
let _ = Observable<Int>.interval(DispatchTimeInterval.seconds(1), scheduler: MainScheduler())
.subscribe(onNext: { print($0, terminator: " ") })
.disposed(by: disposeBag)
//输出：0 1 2 3 4 5 6 7 8 9 10 ...
-
timer
创建一个 Observable 在一段延时后，每隔一段时间产生一个元素
//*** timer 创建一个 Observable 在一段延时后，产生唯一的一个元素
let observable = Observable<Int>.timer(DispatchTimeInterval.seconds(1), period: DispatchTimeInterval.seconds(3), scheduler: MainScheduler())
observable.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
//输出：延时1S 间隔3S 0 1 2 3 4 5 6 7 8 9 10 ...
-
timeout
timeout 如果 Observable 在一段时间内没有产生元素，timeout 操作符将使它发出一个 error 事件
let subject = PublishSubject<Int>()
subject
.timeout(DispatchTimeInterval.seconds(5), scheduler: MainScheduler())
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
// delay(4) {
// subject.onNext(1)
// }
输出：
// Unhandled error happened: Sequence timeout.
// subscription called from:
-
delay
将 Observable 的每一个元素拖延一段时间后发出
_ = Observable.of(1, 2, 3)
.delay(DispatchTimeInterval.seconds(3), scheduler: MainScheduler())
.subscribe(onNext: { print($0, terminator: " ") })
.disposed(by: disposeBag)
}
//3S 后输出：1 2 3
-
delaySubscription
操作符将在经过所设定的时间后，才对 Observable 进行订阅操作。
_ = Observable.of(1, 2, 3)
.delaySubscription(DispatchTimeInterval.seconds(3), scheduler: MainScheduler())
.subscribe(onNext: { print($0, terminator: " ") })
.disposed(by: disposeBag)
//3S 后输出：1 2 3
//delay： 延时发出 delaySubscription：延时订阅
-
materialize
该操作符可以将序列产生的事件，转换成元素 ，通常一个有限的 Observable 将产生零个或者多个 onNext 事件，最后产生一个 onCompleted 或者 onError 事件。而 materialize 操作符会将 Observable 产生的这些事件全部转换成元素，然后发送出来。
_ = Observable.of(1, 2, 3)
.materialize()
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
// 输出：
// next(1)
// next(2)
// next(3)
// completed
-
dematerialize
操作符将 materialize 转换后的元素还原
_ = Observable.of(1, 2, 3)
.materialize()
.dematerialize()
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
// 输出：
// 1
// 2
// 3
-
deferred
deferred 直到订阅发生，才创建 Observable，并且为每位订阅者创建全新的 Observable, 直到订阅时才创建 Observable 是可以保证拿到的数据都是最新的。起到一个延迟创建的作用
let observable = Observable<Int>
.deferred{() -> Observable<Int> in
let newOb = Observable<Int>.create({ (ob) -> Disposable in
ob.onNext(1)
ob.onNext(2)
ob.onCompleted()
return Disposables.create()
})
return newOb
}
observable
.subscribe(onNext: { print($0, terminator: " ") })
.disposed(by: disposeBag)
// 输出：1 2
-
using
using 使用 using 操作符创建 Observable 时，同时会创建一个可被清除的资源，一旦 Observable 终止了，那么这个资源就会被清除掉了。
class AnyDisposable: Disposable {
let _dispose: () -> Void
init(_ disposable: Disposable) {
_dispose = disposable.dispose
}
func dispose() {
_dispose()
}
}
//一个无限序列
let infiniteInterval = Observable<Int>
.interval(DispatchTimeInterval.seconds(1), scheduler: MainScheduler())
.do(
onNext: { print("infinite: \($0)") },
onSubscribe: { print("开始订阅 infinite")},
onDispose: { print("销毁 infinite")}
)
//一个有限序列
let limited = Observable<Int>
.interval(DispatchTimeInterval.seconds(5), scheduler: MainScheduler())
.take(3)
.do(
onNext: { print("limited: \($0)") },
onSubscribe: { print("开始订阅 limited")},
onDispose: { print("销毁 limited$")}
)
//使用using操作符创建序列
let o: Observable<Int> = Observable.using({ () -> AnyDisposable in
return AnyDisposable(infiniteInterval.subscribe())
}, observableFactory: { _ in return limited }
)
_ = o.subscribe()
// 开始订阅 infinite
// 开始订阅 limited
// infinite: 0
// infinite: 1
// infinite: 2
// infinite: 3
// infinite: 4
// limited: 0
// infinite: 5
// infinite: 6
// infinite: 7
// infinite: 8
// infinite: 9
// limited: 1
// infinite: 10
// infinite: 11
// infinite: 12
// infinite: 13
// infinite: 14
// limited: 2
// 销毁 limited$
// 销毁 infinite
