map

将源Observable的每个元素，通过提供的方法转换，然后返回含有转换后元素的Observable

Observable.of(1,2,3)
    .map{
        $0 * 10
    }
    .subscribe(onNext:{
        print($0)
    })
    .disposed(by: bag)

/// 打印结果：
/// 10
/// 20
/// 30

flatMap

对源Observable的每一个元素应用一个转换方法，将他们转换成Observable，然后将这些Observable的元素合并之后再发送出来，即将其降维成一个Observable序列

/// 通过flatMap降维，获取内部的元素值
Observable.of(1,2,3)
    .map { value in
        return Observable.just(value * 10)
    }
    .flatMap({
        return $0
    })
    .subscribe(onNext:{
        print($0)
    })
    .disposed(by: bag)

    }

/// 打印结果：
/// 10
/// 20
/// 30

更多用法参考：文章

flatMapLatest

当源序列有新的事件发生的时候，flatMapLatest会自动取消上一个是事件的订阅，转到新的事件的订阅上面，而flatMap则会订阅全部

share(replay:scope:)作用

解决有多个订阅者的情况下，避免事件转换操作符(比如：map、flatMap、flatMapLatest等等)被多次执行的问题

普通的可观察序列

let seq = PublishSubject()
let ob = seq.map { (i) -> Int in
    print("map 被调用 ：---\(i)")
    return i * 2
}

let _ = ob.subscribe(onNext: { (num) in
    print("--第一次订阅--\(num)")
}, onError: nil, onCompleted: nil, onDisposed: nil)


let _ = ob.subscribe(onNext: { (num) in
    print("--第二次订阅--\(num)")
}, onError: nil, onCompleted: nil, onDisposed: nil)

seq.onNext(1)

/// 打印结果：
/// map 被调用 ：---1
/// --第一次订阅--2
/// map 被调用 ：---1
/// --第二次订阅--2

操作符 share(replay:scope:)

let seq = PublishSubject()
let ob = seq.map { (i) -> Int in
    print("map 被调用 ：---\(i)")
    return i * 2
}
.share(replay: 0, scope: .forever)

let _ = ob.subscribe(onNext: { (num) in
    print("--第一次订阅--\(num)")
}, onError: nil, onCompleted: nil, onDisposed: nil)

let _ = ob.subscribe(onNext: { (num) in
    print("--第二次订阅--\(num)")
}, onError: nil, onCompleted: nil, onDisposed: nil)

seq.onNext(1)

/// 打印结果：
/// map 被调用 ：---1
/// --第一次订阅--2
/// --第二次订阅--2

Filter

用法跟Swift的.filter一样，符合条件的才会发送给订阅者

Observable.of(1, 2, 3, 4, 5)
    .debug("A")
    .filter { $0 % 2 == 1 }
    .debug("B")
    .subscribe()
    .disposed(by: disposeBag)

skip

会跳过前两个元素

Observable.of(1, 2, 3, 4, 5)
    .skip(2)
    .debug("B")
    .subscribe()
    .disposed(by: disposeBag)

skipWhile

跳过符合条件的元素，直到遇到不符合條条的元素（即 false），就停止跳过

skipUntil

跳过元素，直到另一個Observable发送元素，就停止跳过，跟前面两种相比，前面两种是静态的设定过滤条件，skipUntil则是可以基于另一个Observable 去动态过滤元素

let subject = PublishSubject()
let trigger = PublishSubject()

subject
    .skipUntil(trigger)
    .debug("B")
    .subscribe()
    .disposed(by: disposeBag)

subject.onNext("1")
subject.onNext("2")
trigger.onNext(())
subject.onNext("3")
subject.onNext("4")
// 打印是这样的
B -> subscribed
B -> Event next(3)
B -> Event next(4)

Take

take跟skip是相反的存在
take是取的n个元素，skip是跳过n个元素，同樣的，它也有takeWhile跟takeUntil

CombineLatest

只会合并最新的元素，不同的是它并不是收到元素就发送，而是结合最新的一起发送

let one = PublishSubject()
let two = PublishSubject()

let result = Observable.combineLatest(one, two) { str, number in
    return "\(str), \(number)"
}

result
    .subscribe(onNext: {
        print($0)
    })
    .disposed(by: disposeBag)

one.onNext("Koala")
two.onNext(2)
one.onNext("Penguin")
one.onNext("Monkey")
two.onNext(7)

/// 执行结果
Koala, 2
Penguin, 2
Monkey, 2
Monkey, 7

Merge

let one = PublishSubject()
let two = PublishSubject()
let three = PublishSubject()

let result = Observable.merge(one, two, three)

result
    .subscribe(onNext: {
        print("\($0)")
    })
    .disposed(by: disposeBag)

one.onNext("Koala")
two.onNext("Lion")
three.onNext(“Panda”)

/// 结果
Koala
Lion
Panda

Zip

zip跟merge和combineLatest很相似，不同在于发出的时机，zip发出的时机是相同位置的元素一同发送，1st对应1st、2nd对应2nd、依此类推

let one = PublishSubject()
let two = PublishSubject()

let result = Observable.zip(one, two) { str, number in
    return "\(str), \(number)"
}

result
    .subscribe(onNext: {
        print($0)
    })
    .disposed(by: disposeBag)

one.onNext("Koala")
two.onNext(2)
one.onNext("Penguin")
one.onNext("Monkey")
two.onNext(7)

执行结果

Koala, 2
Penguin, 7

Koala跟数字2都是Observable的第一个元素，所以被配在一起
Penguin跟数字7都是2nd，尽管中中间还有Monkey，也不受影响

Merge、CombineLatest和Zip的区别

相同处
都可以合并多个Observable
不同处

merge需是相同类型，combineLatest和zip可以是不同类型
merge只要其中有一个Observable有发送元素，就成立，而combineLatest和zip需要每一个都至少发送过一个元素后才成立

资料1
资料2

RxSwift 操作符

map