其他操作符：delay、delaySubscription 、m

• delay

  该操作符会将 Observable 的所有元素都先拖延一段设定好的时间，然后才将它们发送出来

Observable.of(1, 2, 1)
        .delay(3, scheduler: MainScheduler.instance) //元素延迟3秒才发出
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)

• delaySubscription

  使用该操作符可以进行延时订阅。即经过所设定的时间后，才对 Observable 进行订阅操作

Observable.of(1, 2, 1)
            .delaySubscription(3, scheduler: MainScheduler.instance) //延迟3秒才开始订阅
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)

• materialize

  该操作符可以将序列产生的事件，转换成元素
  通常一个有限的 Observable 将产生零个或者多个 onNext 事件，最后产生一个 onCompleted 或者 onError 事件。而 materialize 操作符会将 Observable 产生的这些事件全部转换成元素，然后发送出来

Observable.of(1, 2, 1)
            .materialize()
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)

• dematerialize

  该操作符的作用和 materialize 正好相反，它可以将 materialize 转换后的元素还原为事件

Observable.of(1, 2, 1)
            .materialize()
            .dematerialize()
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)

• timeout

使用该操作符可以设置一个超时时间。如果源 Observable 在规定时间内没有发出任何元素，就产生一个超时的 error 事件

//定义好每个事件里的值以及发送的时间
let times = [
    [ "value": 1, "time": 0 ],
    [ "value": 2, "time": 0.5 ],
    [ "value": 3, "time": 1.5 ],
    [ "value": 4, "time": 4 ],
    [ "value": 5, "time": 5 ]
]
         
//生成对应的 Observable 序列并订阅
Observable.from(times)
    .flatMap { item in
        return Observable.of(Int(item["value"]!))
            .delaySubscription(Double(item["time"]!), scheduler: MainScheduler.instance)
            }
    .timeout(2, scheduler: MainScheduler.instance) //超过两秒没发出元素，则产生error事件
    .subscribe(onNext: { element in
        print(element)
    }, onError: { error in
        print(error)
    })
    .disposed(by: disposeBag)

• using

  使用 using 操作符创建 Observable 时，同时会创建一个可被清除的资源，一旦 Observable 终止了，那么这个资源就会被清除掉了

//一个无限序列（每隔0.1秒创建一个序列数 ）
let infiniteInterval$ = Observable<Int>
    .interval(0.1, scheduler: MainScheduler.instance)
    .do(
        onNext: { print("infinite$: \($0)") },
        onSubscribe: { print("开始订阅 infinite$")},
        onDispose: { print("销毁 infinite$")}
    )
         
//一个有限序列（每隔0.5秒创建一个序列数，共创建三个 ）
let limited$ = Observable<Int>
    .interval(0.5, scheduler: MainScheduler.instance)
    .take(2)
    .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()