RxSwift - Filtering Operators过滤运

Ignoring operators

1. 当您只想通过.completed或.error事件终止observable时才能通知ignoreElements, 使用下面的方式. 1,2,3都不会执行, 只有strikes.onCompleted()才会打印

    let strikes = PublishSubject<String>()
    let disposeBag = DisposeBag()
    strikes
        .ignoreElements()
        .subscribe { _ in
            print("You're out!")
        }
        .addDisposableTo(disposeBag)
    
    strikes.onNext("1")
    strikes.onNext("2")
    strikes.onNext("3")
    strikes.onCompleted()

2. 可能有时候，您只想处理由可观察者发出的第n（序数）元素，例如第三次敲击。 为此，您可以使用elementAt，它使用要接收的元素的索引，并忽略其他元素。 elementAt的索引为1，因此它只允许通过第二个元素。

example(of: "elementAt") {
    // 1
    let strikes = PublishSubject<String>()
    let disposeBag = DisposeBag()
    // 2
    strikes
        .elementAt(1)
        .subscribe(onNext: {
            print($0)
        })
        .addDisposableTo(disposeBag)
    
    strikes.onNext("1")
    strikes.onNext("2")
    strikes.onNext("3")
}

3. ignoreElements和elementAt是由observable发出的过滤元素。 当您的过滤需求不是所有或不是某一个，可以使用过滤器, 过滤器采用谓词闭包，只有满足条件的元素才被允许通过.
   只有2和4通过，因为过滤器的谓词只允许被2整除的的元素。

    let disposeBag = DisposeBag()
    Observable.of(1, 2, 3, 4)
        .filter { integer in
            integer % 2 == 0
        }
        .subscribe(onNext: {
            print($0)
        })
        .addDisposableTo(disposeBag)

Skipping operators

1. skip

如果你想跳过某些元素, 可以使用skip(), 如下图所示, skip(2)则会跳过前两个元素, 只会处理第三个元素

屏幕快照 2017-08-15 上午10.35.00.png

example(of: "skip") {
    let disposeBag = DisposeBag()
    Observable.of("1", "2", "3", "4")
        .skip(2)
        .subscribe(onNext: {
            print($0) })
        .addDisposableTo(disposeBag)
}

上面的会跳过1和2, 只打印3和4

2. skipWhile

在skipWhile闭包的谓词匹配中, 返回true的将被跳过, 分会false的将会被通过, 并且从第一个被通过的元素开始, 以后的元素无论结果是返回true还是false都会被通过, 如下图所示, 1满足条件, 则不被通过, 2不满足条件, 则被通过, 虽然3不满足天剑, 但是他已经不是第一个不被通过的元素, 所以也被通过.

屏幕快照 2017-08-15 上午11.07.03.png

    let disposeBag = DisposeBag()
    Observable.of("1", "2", "3", "4")
        .skip(2)
        .subscribe(onNext: {
            print($0) })
        .addDisposableTo(disposeBag)

打印1和2

3. skipUntil

    let disposeBag = DisposeBag()
    // 1创建主题, subject用于触发事件,trigger用于跳过事件
    let subject = PublishSubject<String>()
    let trigger = PublishSubject<String>()
    subject
        // 2 在trigger为触发事件之前, 所有的subject事件都将被跳过
        .skipUntil(trigger)
        .subscribe(onNext: {
            print($0) })
        .addDisposableTo(disposeBag)
    
    //3 这两个事件将被跳过
    subject.onNext("A")
    subject.onNext("B")
    //4 结束跳过, 自此之后的所有事件将会被捕捉到
    trigger.onNext("X")
    //5 这次事件将不会被跳过
    subject.onNext("C")

Taking operators

1. take

与skip相反, take是要获取元素, 如下图所示, take(2)的话会获取2之前并且包括2的所有元素, 之后的则会被舍弃掉

屏幕快照 2017-08-15 上午11.27.30.png

    let disposeBag = DisposeBag()
    Observable.of(1, 2, 3, 4, 5, 6).take(3).subscribe(onNext: {
        print($0)
    }).addDisposableTo(disposeBag)

打印1,2,3

2. takeWhile

takeWhile操作符与skipWhile类似，他是使用，而不是跳过。 takeWhileWithIndex, 在谓词解析为true时需要，会传递元素的索引。在下图中，该值需要大于1，并且索引大于1，因此即使2满足第一个要求值大于1，但其索引为1，因此它不满足第二个要去, 一样不会被通过。满足条件的只有3

屏幕快照 2017-08-15 上午11.36.15.png

    let disposeBag = DisposeBag()
    Observable.of(2, 2, 4, 4, 6, 6)
        .takeWhileWithIndex { integer, index in
            integer % 2 == 0 && index < 3
        }
        .subscribe(onNext: {
            print($0)
        })
        .addDisposableTo(disposeBag)

打印2,2,4

3. takeUntil

像skipUntil一样，有一个takeUntil操作符，从第一个元素到哪一个元素截止。
下图的takeUntil在2之后, 所以只有1和2会被发出, 2之后的将会被丢弃

屏幕快照 2017-08-15 下午1.17.08.png

 let disposeBag = DisposeBag()
    let subject = PublishSubject<String>()
    let trigger = PublishSubject<String>()
    subject
        .takeUntil(trigger)
        .subscribe(onNext: {
            print($0) })
        .addDisposableTo(disposeBag)
    subject.onNext("1")
    subject.onNext("2")
    
    trigger.onNext("X")
    subject.onNext("3")

只会打印1和2, 3将会被丢弃

Distinct operators

DistinctUntil

防止连续重复的元素通过, 如下图所示, 第二个2不被通过, 但是第二个1则被通过, 因为第二个1不是连续的重复

屏幕快照 2017-08-15 下午1.26.54.png

example(of: "distinctUntilChanged") {
    let disposeBag = DisposeBag()
    // 1
    Observable.of("A", "A", "B", "B", "A")
        // 2
        .distinctUntilChanged()
        .subscribe(onNext: {
            print($0) })
        .addDisposableTo(disposeBag)
}

打印A,B,A, 第二个A和第二个B不会被打印, 因为他们是连续的重复, 第三个A则会被打印, 因为他不是连续的重复