几种常见的操作符

联合操作

联合操作就是把多个Observable流合成单个Observable流

merge

合并两个Observable流合成单个Observable流，根据时间轴发出对应的事件

     // 2.merge 合并两个Observable流合成单个Observable流，根据时间轴发出对应的事件
    func merge() {
        print("\n merge test---")
        let disposeBag = DisposeBag()
        let subject1 = PublishSubject<String>()
        let subject2 = PublishSubject<String>()

        Observable.of(subject1,subject2).merge().subscribe(onNext:{print($0)}).addDisposableTo(disposeBag)
        subject1.onNext("A")
        subject1.onNext("B")
        subject2.onNext("1")
        subject2.onNext("2")
        subject1.onNext("AB")
        subject2.onNext("3")
    }

 merge test---
 A
 B
 1
 2
 AB
 3

zip

绑定超过最多不超过8个的Observable流，结合在一起处理。注意Zip是一个事件对应另一个流一个事件。

    // 4.zip
    func zip() {
        print("\n zip test---")
        let disposeBag = DisposeBag()
        let stringSubject = PublishSubject<String>()
        let intSubject = PublishSubject<Int>()

        Observable.zip(stringSubject, intSubject) { stringElement,intElement in
            "\(stringElement) \(intElement)"
            }
            .subscribe(onNext: {print($0)})
            .addDisposableTo(disposeBag)

        // A1 B2 AB3 ABC4
        stringSubject.onNext("A")
        stringSubject.onNext("B")

        intSubject.onNext(1)
        intSubject.onNext(2)

        stringSubject.onNext("AB")

        intSubject.onNext(3)
        intSubject.onNext(4)

        stringSubject.onNext("ABC")
    }

 zip test---
 A 1
 B 2
 AB 3
 ABC 4

combineLatest

绑定超过最多不超过8个的Observable流，结合在一起处理。和Zip不同的是combineLatest是一个流的事件对应另一个流的最新的事件，两个事件都会是最新的事件。

    // 3.combineLatest
    func combineLatest() {
        print("\n combineLatest test---")
        let disposeBag = DisposeBag()
        let stringSubject = PublishSubject<String>()
        let intSubject = PublishSubject<Int>()

        Observable.combineLatest(stringSubject, intSubject) { stringElement,intElement in
            "\(stringElement) \(intElement)"
            }
            .subscribe(onNext: {print($0)})
            .addDisposableTo(disposeBag)

        // B1 B2 AB2 AB3
        stringSubject.onNext("A")
        stringSubject.onNext("B")

        intSubject.onNext(1)
        intSubject.onNext(2)

        stringSubject.onNext("AB")

        intSubject.onNext(3)
    }

 zip test---
 A 1
 B 2
 AB 3
 ABC 4

switchLatest

switchLatest可以对事件流进行转换，本来监听的subject1，我可以通过更改variable里面的value更换事件源。变成监听subject2。

    // 5.switchLatest 可以对事件流进行转换，
    // 本来监听的subject1，我可以通过更改variable里面的value更换事件源。变成监听subject2了
    func switchLatest() {
        print("\n switchLatest test---")
        let disposeBag = DisposeBag()
        let subject1 = BehaviorSubject(value: "A")
        let subject2 = BehaviorSubject(value: "B")

        // 监听的subject1
        let variable = Variable(subject1) 

        variable.asObservable()
            .switchLatest()
            .subscribe(onNext: {print($0)})
            .addDisposableTo(disposeBag)

        subject1.onNext("A1")
        subject1.onNext("A2")

        // 监听对象变为 subject2
        variable.value = subject2 
        subject1.onNext("A3")
        subject2.onNext("B1")

        // 监听对象变为 subject1
        variable.value = subject1
        subject2.onNext("B2")
        subject1.onNext("A4")
    }

 switchLatest test---
 A
 A1
 A2
 B
 B1
 A3
 A4

变换操作

map

通过传入一个函数闭包把原来的sequence转变为一个新的sequence的操作。

    func map() {
        print("\n map test---")
        let disposeBag = DisposeBag()
        Observable.of(1,2,3)
            .map { $0 * $0 }
            .subscribe(onNext:{ print($0) })
            .addDisposableTo(disposeBag)
    }

map test---
1
4
9

flatMap

将一个sequence转换为一个sequences，当你接收一个sequence的事件，你还想接收其他sequence发出的事件的话可以使用flatMap，她会将每一个sequence事件进行处理以后，然后再以一个新的sequence形式发出事件。

    // 2.flatMap
    func flatMap() {
        print("\n flatMap test---")
        let disposeBag = DisposeBag()

        struct Player {
            var score:Variable<Int>
        }

        let subject1 = Player(score: Variable(80))
        let subject2 = Player(score: Variable(90))

        let variable = Variable(subject1)
        variable.asObservable()
            .flatMap({$0.score.asObservable()})
            .subscribe(onNext: {print($0)})
            .addDisposableTo(disposeBag)

        subject1.score.value = 85
        // 监听对象变为 subject2
        variable.value = subject2  //更换了value，相当于又添加了一个sequence，两个sequence都可以接收
        subject1.score.value = 95
        subject2.score.value = 100
    }

 flatMap test---
 80
 85
 90
 95
 100

flatMapLatest

flatMapLatest同flatMap一样，也是将一个序列转换为另一个序列，flatMapLatest只会从最近的序列中发出事件，先前建立的Observable将不再被监听。

    // 3.flatMapLatest = map + switchLatest
    func flatMapLatest() {
        print("\n flatMapLatest test---")
        let disposeBag = DisposeBag()

        struct Player {
            var score:Variable<Int>
        }

        let subject1 = Player(score: Variable(80))
        let subject2 = Player(score: Variable(90))

        let variable = Variable(subject1)
        variable.asObservable()
            .flatMapLatest({$0.score.asObservable()})
            .subscribe(onNext: {print($0)})
            .addDisposableTo(disposeBag)

        subject1.score.value = 85
        subject1.score.value = 88
        // 监听对象变为 subject2
        variable.value = subject2 // 更换了value，相当于新增了一个sequence，但只有最新的sequence才能被订阅
        subject1.score.value = 95
        subject1.score.value = 99
        subject2.score.value = 100
    }

 flatMapLatest test---
 80
 85
 88
 90
 100

具体的不同，请移步这里《烧脑的map与flatmap》！

3.2 Operator