RxSwift（3.4.1）- Time Operators

Time Operators

RxSwift 提供了一系列的操作符允许我们处理时间。

Buffer

工作原理：周期性的收集被观察者序列发送的元素，并存储到缓存区，最后发送集合而不是单独的元素.

将一个Observable序列投影到一个缓存池，当缓存池达到最大数量或者超过指定时间时，buffer将作为一个事件被发出，注意timer运行在指定的调度器上，它的功能是周期性地收集事件然后打包发出，而不是每一个事件单独发出。Buffer操作符将一个Observable变换成了一个发送Buffer包事件的Observable序列，依据如何将源Observable事件进行打包到buffer的策略有很多Buffer操作符的变形。

 public func buffer(timeSpan: RxTimeInterval, count: Int, scheduler: SchedulerType)
        -> Observable<[E]> {
        return BufferTimeCount(source: self.asObservable(), timeSpan: timeSpan, count: count, scheduler: scheduler)
    }

方法中：第一个参数是缓冲时间，第二个参数是缓冲个数，第三个参数是线程。总体来说就是经过一定时间，将一定个数的事件组合成一个数组，一起处理，在组合的过程中，你可以选择自己的线程。

注意：当源Observable发出一个onError事件通知，Buffer不会进行继续打包而是直接将OnError通知发出

        let disposeBag = DisposeBag()
        //1
        let buffer = PublishSubject<String>()
        //2
        buffer.buffer(timeSpan: 2, count: 3, scheduler: MainScheduler.instance)
              .subscribe { print("subscribe1 : \($0)")}
              .addDisposableTo(disposeBag)
        buffer.buffer(timeSpan: 1, count: 2, scheduler: MainScheduler.instance)
            .subscribe { print("subscribe2 : \($0)")}
            .addDisposableTo(disposeBag)
        //3
        buffer.onNext("1")
        buffer.onNext("2")
        buffer.onNext("3")
        buffer.onNext("4")
        buffer.onNext("5")
        buffer.onNext("6")
        
        //4
        RunLoop.main.run(until: Date(timeIntervalSinceNow: 2))

 执行结果和分析：

         subscribe2 : next(["1", "2"])

         subscribe1 : next(["1", "2", "3"])

         subscribe2 : next(["3", "4"])

         subscribe1 : next(["4", "5", "6"])

         subscribe2 : next(["5", "6"])

         subscribe2 : next([])

         subscribe1 : next([])

        

1:创建一个PublishSubject对象

2:添加两个订阅者，并且都使用了buffer操作符，subscribe1是指定了以3个为一组进行发送，并且缓冲时间为2秒，在主线程运行。subscribe2指定了2个事件为一组，缓冲时间为1秒，同样运行在主线程

3:接下来发送6个事件

4:保持主线程运行2秒

   

由结果可知，当我们开始发送事件，订阅者会开始接受事件，随着不断的发送事件，首先subscribe2当缓存了2个事件之后，立马会发送该集合事件并继续下一次缓存。我们可以看到先打印了subscribe2 : next(["1", "2"])结果。当subscribe1缓存了3个事件之后会立马发送集合事件，所以会打印subscribe1 : next(["1", "2", "3"])。每次发送结束，订阅者会继续等待事件，并再一次缓存事件。由于我们发送了6次事件消息，所以每次到了指定的缓存个数就会发送事件。最后打印了两个空的集合事件，是因为我们保证了程序会运行2秒，在subscribe1发送完了所有的事件之后，当指定的时间到了，所以发送一个空事件。subscribe2也是一样，在2秒的时候由于没有接受事件，所以发送空事件。（注意：之所以会有后面的空集合事件，是因为之前发送事件的总时间小于我们指定的时间）

Window

跟buffer(timeSpan:count:scheduler:)非常相像，那就是window(timeSpan:count:scheduler:)。参数一样，几乎做一样的事情。唯一的区别就是它发送观察者序列作为缓冲的元素而不是发送一个集合。需要特别注意的是window方法之后， 返回的是Observable

public func window(timeSpan: RxTimeInterval, 
                   count: Int, 
                   scheduler: SchedulerType) -> RxSwift.Observable<RxSwift.Observable<Self.E>>

        let disposeBag = DisposeBag()
        let buffer = PublishSubject<String>()
        buffer.window(timeSpan: 2, count: 3, scheduler: MainScheduler.instance)
            .subscribe(onNext: { [weak self]  in
                   print("subscribe: \($0)")
                   self?.subscribeobservable($0)
              })
              .addDisposableTo(disposeBag)
        buffer.onNext("1")
        buffer.onNext("2")
        buffer.onNext("3")

subscribeobservable函数

 func subscribeobservable(_ observable: Observable<String>) {
             observable.subscribe(onNext: {
                print("value: \($0)")
             }).addDisposableTo(disposeBag)
    }

执行结果：

subscribe: RxSwift.AddRef<Swift.String>

value: 1

value: 2

value: 3

subscribe: RxSwift.AddRef<Swift.String>

Delay

/**
 Returns an observable sequence by the source observable sequence shifted forward in time by a specified delay. Error events from the source observable sequence are not delayed.
         
 - parameter dueTime: Relative time shift of the source by.
 - parameter scheduler: Scheduler to run the subscription delay timer on.
 - returns: the source Observable shifted in time by the specified delay.
 */
 public func delay(_ dueTime: RxTimeInterval, scheduler: SchedulerType) -> RxSwift.Observable<Self.E>

RxSwift中有一种类型的延迟，那就是延迟整个观察者序列（the whole sequence）,并不是订阅晚了，而是在订阅源观察者序列之后，根据具体的时间延迟每一个元素的发送.

        let disposeBag = DisposeBag()

        Observable<Int>.interval(1, scheduler: MainScheduler.instance)
            .delay(2, scheduler: MainScheduler.instance)
            .subscribe(onNext: { print($0)})
            .addDisposableTo(disposeBag)
        
        RunLoop.main.run(until: Date(timeIntervalSinceNow: 6))

执行结果：

0

1

2

3

delaySubscription

该操作符是延迟订阅,跟名字显示的意思一样。

 /**
   Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers. 
   - parameter dueTime: Relative time shift of the subscription.
   - parameter scheduler: Scheduler to run the subscription delay timer on.
   - returns: Time-shifted sequence.
  */
 public func delaySubscription(_ dueTime: RxTimeInterval, scheduler: SchedulerType) -> RxSwift.Observable<Self.E>

注意：在Rx中，有一些观察者序列（observables）被称为“cold”，其它的称为“hot”。cold的观察者序列开始发送元素是当你订阅（subscribe）它们之后。而hot观察者序列更像是永远的源，并监听着你的变化。当使用延迟订阅，它对于cold的观察者序列并没有什么变化。但是如果是hot，可能会跳过一些元素。

interval

定时器（Timer）是任意类型应用中一种普遍的需求，iOS和macOS中都有一些定时处理方法。RxSwift中提供了一种非常简单有效的方法来处理定时,那就是Interval。前面我们已经使用过了。

interval(_:scheduler:) 该操作符将产生一个无限观察者序列，在指定了interval运行的具体线程，在指定时间之后，发送Int类型的值，从0开始。

 let disposeBag = DisposeBag()
 Observable<Int>.interval(1, scheduler: MainScheduler.instance)
      .subscribe(onNext: { print($0)})
      .addDisposableTo(disposeBag)

执行结果：

0

1

2

3

4

… 一直执行下去

Timers

  /**
    Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers.
    - parameter dueTime: Relative time at which to produce the first value.
    - parameter period: Period to produce subsequent values.
    - parameter scheduler: Scheduler to run timers on.
    - returns: An observable sequence that produces a value after due time has elapsed and then each period.
    */
 public static func timer(_ dueTime: RxTimeInterval, 
                        period: RxTimeInterval? = nil, 
                        scheduler: SchedulerType) -> Observable<E> 

timer操作符是非常像interval，但是有以下特征：

1: 在订阅开始和发送第一个元素值之间,你能够指定一个到期日期的时间。

2: 重复周期是可选操作，如果你并没有指定一个，那么定时器观察者序列将发送一次，之后发送完成消息事件。如果指定了周期性的次数，那么将在每次指定时间到了之后，执行一次发送事件。

Observable<Int>.timer(2, scheduler: MainScheduler.instance)
        .subscribe(onNext: { print($0) })

执行结果：

0

因为没有周期性参数，所以在指定到期时间到了之后，会发送一个事件。如果我们指定周期性间隔，那么会按指定的周期间隔发送值。下面指定了每间隔3秒发送一次事件

 Observable<Int>.timer(1, period: 3, scheduler: MainScheduler.instance)
        .subscribe(onNext: { print($0) })

执行结果：

0

1

2

3

4

5

...