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<Int>()
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<Int>()
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<String>()
let trigger = PublishSubject<Void>()
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<String>()
let two = PublishSubject<Int>()
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<String>()
let two = PublishSubject<String>()
let three = PublishSubject<String>()
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<String>()
let two = PublishSubject<Int>()
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需要每一个都至少发送过一个元素后才成立
网友评论