RxSwift (5) 条件运算符

filter

将信号元素 筛选 符合条件的 继续发送，不符合的舍弃

    func rx_filter(){
        let disposBag = DisposeBag()

        Observable.from(["美腿","丝袜","超短裙"])
            .filter{x in x=="美腿"}
            .subscribe{print($0)}
            .addDisposableTo(disposBag)



        print("------------------------------")
        Observable.of("萝莉","御姐","萌萌哒")
            .scan("I Like Play", accumulator: {(last,current) in last+current})
            .filter{ $0 == "I Like Play萝莉御姐"}
            .subscribe{print($0)}
            .addDisposableTo(disposBag)

    }

打印结果
next(美腿)
completed
------------------------------
next(I Like Play萝莉御姐)
completed

distinctUntilChanged

舍弃连续并且重复的信号

func rx_distinctUntilChanged(){
        let disposBag = DisposeBag()

        Observable.of("a","b","b","c","b","b","d","a")
            .distinctUntilChanged()
            .subscribe{print($0)}
            .addDisposableTo(disposBag)

    }

打印结果
next(a)
next(b)
next(c)
next(b)
next(d)
next(a)
completed

elementAt

等同于 数组的 objectAt，取第几次发出的信号

func rx_elementAt(){
        let disposeBag = DisposeBag()

        Observable.of("释放","洪荒","之力")
        .elementAt(2)
        .subscribe{print($0)}
        .addDisposableTo(disposeBag)
    }


next(之力)
completed

single

有条件:筛选条件，如果有多个满足条件的元素，满足条件的第一个元素发送，然后发送error；无条件:发送第一个元素

func rx_single(){
        let disposeBag = DisposeBag()

        print("---------缺省条件就发出第一个元素-----------")
        // 缺省条件就发出第一个元素
        Observable.of("1", "2", "3", "4", "5", "6")
            .single()
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)

        print("---------发送符合条件的元素-----------")
        Observable.of("1", "2", "3", "4", "5", "6")
            .single { $0 == "4" }
            .subscribe { print($0) }
            .disposed(by: disposeBag)


        print("---------有多个符合条件的元素-----------")
        Observable.of("1", "2", "3", "4", "5", "6")
            .single { $0 == "2" }
            .subscribe { print($0) }
            .disposed(by: disposeBag)

        print("---------没有符合条件的元素-----------")
        Observable.of("1", "2", "3", "4", "5", "6")
            .single { $0 == "7" }
            .subscribe { print($0) }
            .disposed(by: disposeBag)
    }


打印结果
---------缺省条件就发出第一个元素-----------
1
---------发送符合条件的元素-----------
next(4)
completed
---------有多个符合条件的元素-----------
next(2)
error(Sequence contains more than one element.)
---------没有符合条件的元素-----------
error(Sequence doesn't contain any elements.)

take

从序列开头的元素 ，发出指定数量的元素，就是发送几次

func rx_take(){
        let disposeBag = DisposeBag()

        Observable.of("a", "b", "c", "d", "e", "f")
            .take(4)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
    }

打印结果
a
b
c
d

takeLast

发送 倒数 指定数量的元素，先进先出

func rx_takeLast(){
        let disposeBag = DisposeBag()

        Observable.of("a", "b", "c", "d", "e", "f")
            .takeLast(4)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
    }


打印结果
c
d
e
f

takeWhile

从序列开头筛选 满足条件的信号发送，只要不满足，回收序列

func rx_takeWhile(){
        let disposeBag = DisposeBag()

        print("--------开头不满足退出无打印----------")
        Observable.of("猪", "牛", "过膝袜", "绝对领域", "马", "二次元")
            .takeWhile{x in x.characters.count>1}
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)


        print("--------开始满足条件----------")
        Observable.of(1, 2, 3, 4, 5, 6)
            .takeWhile { $0 < 4 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
    }


--------开头不满足退出无打印----------
--------开始满足条件----------
1
2
3

takeUntil

本序列a 被另一个序列b关闭，当b开始发送信号的时候

func rx_takeUntil(){
let disposeBag = DisposeBag()

    let aSequence = PublishSubject<String>()
    let bSequence = PublishSubject<String>()

    sourceSequence
        .takeUntil(referenceSequence)
        .subscribe { print($0) }
        .disposed(by: disposeBag)

    sourceSequence.onNext("1")
    sourceSequence.onNext("2")
    sourceSequence.onNext("3")

    referenceSequence.onNext("0")

    sourceSequence.onNext("4")
    sourceSequence.onNext("5")
    sourceSequence.onNext("6")
    }


next(1)
next(2)
next(3)
completed

skip

从序列开头 跳过指定数量的元素

func rx_skip() {
    let disposeBag = DisposeBag()

    Observable.of("1", "2", "3", "4", "5", "6")
        .skip(2)
        .subscribe(onNext: { print($0) })
        .disposed(by: disposeBag)
}


3
4
5
6

skipWhile

从序列开头,跳过 连续并且同时满足条件的信号，否则 发送信号

func rx_skipWhile(){
        let disposeBag = DisposeBag()

        print("----开头连续并且满足----")
        Observable.of(1, 2, 3, 4, 5, 6)
            .skipWhile { $0 < 4 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)

        print("----开头不满足----")
        Observable.of(9, 2, 3, 4, 5, 6)
            .skipWhile { $0 < 4 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)


        print("----开头满足不连续----")
        Observable.of(1, 9, 3, 4, 5, 6)
            .skipWhile { $0 < 4 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
    }


----开头连续并且满足----
4
5
6
----开头不满足----
9
2
3
4
5
6
----开头满足不连续----
9
3
4
5
6

skipWhileWithIndex

跟skipWhile 效果一样，只是多了一个参数 index下标，可以根据index下标来设置条件

 func rx_skipWhileWithIndex(){
        let disposeBag = DisposeBag()

        print("----开头连续并且满足----")
        Observable<Int>.create{observe in
            observe.onNext(1)
            observe.onNext(2)
            observe.onNext(3)
            observe.onNext(4)
            observe.onNext(5)
            observe.onNext(6)

            return Disposables.create()
            }
            .skipWhileWithIndex {element,index in  element < 4 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)

        print("----开头不满足----")
        Observable.of(9, 2, 3, 4, 5, 6)
            .skipWhileWithIndex {element,index in  element < 4 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)


        print("----开头满足不连续----")
        Observable.of(1, 9, 3, 4, 5, 6)
            .skipWhileWithIndex {element,index in  element < 4 }
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)
    }


----开头连续并且满足----
4
5
6
----开头不满足----
9
2
3
4
5
6
----开头满足不连续----
9
3
4
5
6

skipUntil

屏蔽发射的信号，直到 参照的序列发出信号

func rx_skipUntil(){
        let disposeBag = DisposeBag()

        let sourceSequence = PublishSubject<String>()
        let referenceSequence = PublishSubject<String>()

        sourceSequence
            .skipUntil(referenceSequence)
            .subscribe(onNext: { print($0) })
            .disposed(by: disposeBag)

        sourceSequence.onNext("1")
        sourceSequence.onNext("2")
        sourceSequence.onNext("3")

        referenceSequence.onNext("0")

        sourceSequence.onNext("4")
        sourceSequence.onNext("5")
        sourceSequence.onNext("6")

    }


打印结果
4
5
6