本文链接： https://blog.csdn.net/sdefzhpk/article/details/73322741

RxSwift基本使用（二）

变换操作

map flatMap

map、flatMap用于把流内容映射成新的内容，但flatMap用于其内容还是流事件

    Observable.of(1,2,3).map { (num) -> Int in
        num + 10
        }.subscribe(onNext: {print($0)}).addDisposableTo(bag)
    /**
     11
     12
     13
     **/

    let bs1 = BehaviorSubject(value: "A")
    let bs2 = BehaviorSubject(value: "B")
    let variable = Variable(bs1)
    variable.asObservable().flatMap({$0}).subscribe(onNext: {print($0)}).addDisposableTo(bag)
    variable.value = bs2

    /**
     A
     B
     */

    //如果把上面flatMap换成map,结果如下

    /**
     let variable = Variable(bs1)
     variable.asObservable().map({$0}).subscribe(onNext: {print($0)}).addDisposableTo(bag)
     variable.value = bs2

     //RxSwift.BehaviorSubject<Swift.String>
     //RxSwift.BehaviorSubject<Swift.String>
     **/

scan

scan就是给一个初始化的数，然后不断的拿前一个结果和最新的值进行处理操作。

    Observable.of(10, 100, 1000)
        .scan(10) { aggregateValue, newValue in
            /**
             aggregateValue:10 newValue:10
             aggregateValue:20 newValue:100
             aggregateValue:120 newValue:1000

             */
            aggregateValue + newValue
        }
        .subscribe(onNext: { print($0) })
        .addDisposableTo(bag)
    /**
     20
     120
     1120
     */

过滤和约束

filter

根据自身需求过滤掉一些不用的值

    Observable.of(10,20,5,9,12,8,6,28).filter { (num) -> Bool in

        num >= 10
        }.subscribe(onNext: {print($0)}).addDisposableTo(bag)

    // 10 20 12 28

distinctUntilChanged

用于当下一个事件与前一个事件是不同事件的事件才进行处理操作

    Observable.of(10,20,20,9,9,9,6,7).distinctUntilChanged().subscribe(onNext: {print($0)}).addDisposableTo(bag)

    //10 20 9 6 7

elementAt

处理在指定位置的事件索引从0开始

    Observable.of(1,2,3,4,5).elementAt(2).subscribe(onNext: {print($0)}).addDisposableTo(bag)
    //3

take

只处理前几个信号

    Observable.of(10,20,30,40,50).take(2).subscribe(onNext: {print($0)}).addDisposableTo(bag)
    //10 20 （个数，所以这里只显示两个数字）

takeLast

只处理后几个信号

    Observable.of(10,20,30,40,50).takeLast(2).subscribe(onNext: {print($0)}).addDisposableTo(bag)
    // 40 50

takeWhile

满足条件才处理一旦不满足即使后面出现满足的条件也不会发出事件了

    Observable.of(50,30,20,40,60).takeWhile({ (num) -> Bool in
        num > 20
    }).subscribe(onNext: {print($0)}).addDisposableTo(bag)
    // 50 30

takeuntil

接收事件消息，直到另一个sequence发出事件消息的时候才终止

    let sequence1 = PublishSubject<Int>()
    let sequence2 = PublishSubject<Int>()
    sequence1.takeUntil(sequence2).subscribe(onNext: {print($0)}).addDisposableTo(bag)
    sequence1.onNext(10)
    sequence1.onNext(15)
    sequence2.onNext(100)
    sequence1.onNext(5)
    sequence1.onNext(20)
    // 10 15

skip

忽略前面几次事件

    Observable.of("A","B","C","D","E").skip(2).subscribe(onNext: {print($0)}).addDisposableTo(bag)
    // C D E

skipWhile

忽略满足条件的

    Observable.of(20,29,3,8,17,15).skipWhile({$0 > 10}).subscribe(onNext: {print($0)}).addDisposableTo(bag)
    // 3 8

skipWhileWithIndex

满足条件的都被取消，传入的闭包同skipWhile有点区别而已

    Observable.of(10,11,12,13,14,15).skipWhileWithIndex { (element, index) -> Bool in
        index < 3
        }.subscribe(onNext: {print($0)}).addDisposableTo(bag)
    // 13 14 15

skipUntil

直到某个sequence发出了事件消息，才开始接收当前sequence发出的事件消息

    let s1 = PublishSubject<String>()
    let s2 = PublishSubject<String>()
    s1.skipUntil(s2).subscribe(onNext: { print($0) }).addDisposableTo(bag)
    s1.onNext("1")
    s1.onNext("2")
    s2.onNext("A")
    s1.onNext("3")
    s1.onNext("4")
    s2.onNext("B")
    s1.onNext("5")

    //3 4 5

数学操作

toArray

将sequence转换成一个array，并转换成单一事件信号，然后结束

    Observable.range(start: 1, count: 5).toArray().subscribe(onNext: {print($0)}).addDisposableTo(bag)
    //[1, 2, 3, 4, 5]

reduce

用一个初始值，对事件数据进行累计操作。reduce接受一个初始值，和一个操作符号

    Observable.of(1,10,20).reduce(5, accumulator: +).subscribe(onNext: {print($0)}).addDisposableTo(bag)
    //36

concat

concat会把多个sequence和并为一个sequence,只有前一个sequence发出了completed事件，才会开始下一个sequence的事件，否则下一个发出的事件将全被忽略，但最后发出的那个事件不会被忽略，该事件会在前一个sequence发出completed事件后被接收。

    let subject1 = BehaviorSubject(value: 10)
    let subject2 = BehaviorSubject(value: 20)

    let variable = Variable(subject1)
    variable.asObservable().concat().subscribe(onNext: {print($0)}).addDisposableTo(bag)

    subject1.onNext(11)
    subject1.onNext(12)

    variable.value = subject2

    subject2.onNext(21) //1完成前，会被忽略
    subject2.onNext(22) //会被接收
    subject1.onCompleted()
    subject2.onNext(13)

    //10 11 12 22 13