我們常常要合併多個Oberservable,藉此來獲得(分享)想要的資料,但Observable概念就像資料流,隨時間在走跳,所以依照情境來選擇operator是很重要的。
Combining operator有分為合併元素跟合併Observable,先從合併元素的講起。
Reduce
reduce跟swift的reduce用法相同,都是給定初始值,尋訪每個元素,去做累加的動作。
let subject = PublishSubject<Int>()
let observable = subject.reduce(0) { summary, newValue in return summary + newValue}
observable .subscribe(onNext: { value in print(value) }) .disposed(by: disposeBag)
subject.onNext(1)subject.onNext(3)subject.onNext(5)subject.onNext(7)subject.onNext(9)
subject.onCompleted()執行結果
25值得大家注意的一點是,reduce會直到接收到.Completed才會開始執行,並且,只會回傳最後的結果,這點要特別注意。
Scan
跟reduce超像,差別在於.scan不需要接收到.Completed才執行
let subject = PublishSubject<Int>()
let observable = subject.scan(0) { summary, newValue in return summary + newValue}
observable .subscribe(onNext: { value in print(value) }) .disposed(by: disposeBag)
subject.onNext(1)subject.onNext(3)subject.onNext(5)subject.onNext(7)subject.onNext(9)執行結果
1491625所以,print會將每一個步驟列印出,並且,不用收到.Completed才執行,這是跟reduce差異最大的地方,也因為這樣,通常情況下我也會使用scan,相較之下比較靈活。
StartWith
startWith就像是簡單版的concat,在Observable發送之前,給定一個預設值。
let subject = PublishSubject<Void>()
let observable = subject.asObservable().startWith(())
observable .subscribe(onNext: { print("Do something.") }) .disposed(by: disposeBag)執行結果
Do something.在沒發出任何元素的狀況下,預先發了一個預設值。
小疑惑
大家有沒有想過,我就用 BehaviorSubject 帶預設值就好啊!為什麼要用startWith?
這是我一開始學的疑惑,的確以上這情境達到的結果是一樣的,但概念上不一樣,BehaviorSubject概念是訂閱時可以拿到上一個值,startWith就只是在最一開始發出一預設值,假設我們在程式後面加上
delay(1) { observable .subscribe(onNext: { print("Do something. \($0)") }) .disposed(by: self.disposeBag)}這個情境下,BehaviorSubject仍然可以拿到上一個元素,而startWith卻拿不到,這時候結果就不一樣了。
我覺得這是Rx很妙的地方,你可能用錯operator程式當下也是好好的,但某個情境下就跑出問題,唯有瞭解每一個operator,依據情境去做選擇才是正解!
Concat
concat是一個靜態的方法,給定一個排序過的Collection,先把第一個Sequence 元素都發送完,再發第二個Sequence,依此類推,直到全部Collection 都發送完畢,看起來就像把他們元素排列後串接起來,對吧?不過,值得注意的是,形態要是相同的才能Concat哦!
let first = Observable.of("A", "B", "C")
let second = Observable.of("D", "E", "F")
let concatObservable = Observable.concat([first, second])
concatObservable.debug("Concat").subscribe().disposed(by: disposeBag)執行結果如下
Concat -> subscribedConcat -> Event next(A)Concat -> Event next(B)Concat -> Event next(C)Concat -> Event next(D)Concat -> Event next(E)Concat -> Event next(F)Concat -> Event completedConcat -> isDisposedConcatMap
concatMap跟flatMap很像,相同之處在於一樣會將元素投影到一條Observable,然後最後合併結果在發出,但concat的精髓就是順序,他會等第一條Observable發完並結束,才會進行第二元素投影到一條Observable …,所以,最後結果一定會照順序發出的。
struct Zoo { let animal: BehaviorSubject<String>}let zone1 = Zoo(animal: BehaviorSubject<String>(value: "Koala"))let zone2 = Zoo(animal: BehaviorSubject<String>(value: "Lion"))
let subject = PublishSubject<Zoo>()
subject .concatMap { $0.animal } .subscribe(onNext: { print($0) }) .disposed(by: disposeBag)
subject.onNext(zone1)
subject.onNext(zone2)
zone1.animal.onNext("Panda")
zone2.animal.onNext("Tiger")
zone1.animal.onCompleted()
zone2.animal.onNext("Cow")執行結果
KoalaPandaTigerCowMerge
merge是很常用的一個語法,它可以將相同型態的Observable合併成一個Observable,接著只要收到元素它就發出去,比如說多條Observable ,各自代表不同情境,可能是按鈕點擊、下拉更新 … 等狀況,這些情境都需要去trigger API,這時就可以把它們merge起來,只要哪個情境觸發就可以 trigger API,大概會長這樣
let triggerAPI = Observable.merge(buttonTap, pullToRefresh)
triggerAPI.flatMapLatest { API().request().asObservable().materialize() }.share()那下面展示簡單範例
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”)執行結果
KoalaLionPandaCombineLatest
從語意上了解,combineLatest是只會合併最新的元素,跟merge一樣可以將多條Observable合併,不同的是它並不是收到元素就發送,而是結合最新的一起發送,先看看下面的範例
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, 2Penguin, 2Monkey, 2Monkey, 7- 直得注意的是,
one跟two的資料型態不同,combineLatest是少數可以合併不同資料型態的operator。 - 第一次
Koala並沒有被發出來,因為這時的two尚未有元素,必須兩邊都有元素,combineLatest才會發出第一個合併的元素!如果有需要的話,可以搭配startWith() 給定預設值,讓combineLatest更早地發出元素。 combineLatest後面接了一個closure,在裡面可以合併你想要的資料型態,你也可以不寫,結果就會像下面這樣,會直接以tuple方式合併
let result = Observable.combineLatest(one, two)執行結果
("Koala", 2)("Penguin", 2)("Monkey", 2)("Monkey", 7)Zip
zip跟merge和combineLatest也很相似,不同在於發出的時機,zip發出的時機是相同位置的元素一同發送,1st對應1st、2nd對應2nd、依此類推,當你需要兩個 resource(或多個)同時出現,那就選擇zip了!
我們拿 combineLatest 範例,只將operator換成zip,來看看結果有什麼不同
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, 2Penguin, 7Koala跟數字2都是Observable的第一個元素,所以被配再一起了Penguin跟數字7都是2nd,儘管中間還有Monkey,也不會受影響- 一樣可以省略closure,執行結果就會變這樣
("Koala", 2)("Penguin", 7)WithLatestFrom
withLatestFrom也是去合併最新的元素,就以這概念來說,跟combineLatest有點像,但不同之處在於, withLatestFrom是以一條Observable為主,去接收另一條Observable最新的值,常見情境就是button的tap事件去合併某Observable,藉此取的最新元素作為參數,再去呼叫 API,大概會像這樣
// ViewControllerbutton.rx.tap.bind(to: viewModel.observer)
// ViewModellet subject = PublishSubject<Void>()observer = subject.asObserver()
subject.asObservable() .withLatestFrom(neededData) .flatMapLatest { API().request().asObservable().materialize() } .share() // Void -> neededData Element下面就先以簡單範例,來展示withLatestFrom,因為怕有點難懂,我們在附上圖解。
let one = PublishSubject<String>()let two = PublishSubject<Int>()
let result = one.withLatestFrom(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)one.onNext("Chicken")圖解如下

- 以
one為主,當發出Koala的時候,這時會去合two的最新元素,但two還沒發出任何元素,所以這時並不會發生任何事情 - 當
two發出數字2的時候,也不會發生任何事情 - 當發出
Penguin,這時會去合併two的最新元素數字2 - 當發出
Monkey,這時還是去合併two的最新元素數字2 - 當發出
Chicken,這時的two最新元素是數字7,所以合併數字7
執行結果如下
Penguin, 2Monkey, 2Chicken, 7Amb
RxSwift提供兩種方式來切換Observable,讓你在Run time的時候決定訂閱哪個Observable,第一個就是ambiguous,left.ambiguous(right)會有兩個Observable,接著,只訂閱第一個發送元素的Observable,取消訂閱另一個,ambiguous意思就是曖昧、模棱兩可、歧義的,就好像一開始你也不知道你喜歡誰,但是當第一個跟你告白的你就會接受(?)
let one = PublishSubject<String>()let two = PublishSubject<String>()
let result = one.amb(two)
result .subscribe(onNext: { print($0) }) .disposed(by: disposeBag)
one.onNext("A")two.onNext("1")one.onNext("B")one.onNext("C")two.onNext("2")two.onNext("3")執行結果
ABCSwitchLatest
另外一個切換方式是switchLatest,不像amb,switchLatest不侷限有只有兩條,要切換不同的Observable ,只要發送型態相同的Observable給Xource subject,就可以了,下面展示簡單範例
let one = PublishSubject<String>()let two = PublishSubject<String>()let three = PublishSubject<String>()
// 1let source = PublishSubject<Observable<String>>()
// 2source.switchLatest() .subscribe(onNext: { print($0) }) .disposed(by: disposeBag)
// 3source.onNext(one)one.onNext("A")two.onNext("1")three.onNext("Koala")
// 4source.onNext(two)one.onNext("B")two.onNext("2")one.onNext("Penguin")
source.onNext(three)three.onNext("Monkey")three.onNext("Chicken")two.onNext("3")- 建立一個名為source的Observable,他的元素必須也要是
Observable<T>才行,這裡為Observable<String> - 訂閱
source.switchLatest(),來查看現在切換到的Observable的元素 - 當source接收到
one時,現在只會接收one發送過來的元素 - 當source接收到
two時,現在只會接收two發送過來的元素,依此類推
執行結果
A2MonkeyChicken講到這,switchLatest跟flatMapLatest很像啊?看書才知道原來flatMapLatest就是map跟switchLatest的結合,不過我基本上我都是使用flatMapLatest就是了。
怎麼選擇 Operator
上面幾個operator看起來都很相似,我一開始學的時候,flatMapLatest、combineLatest和withLatestFrom都亂用。下面統整它們的差異,並分享過去犯錯的範例,給大家借鏡。
Merge、CombineLatest和Zip
相同之處
- 都可以合併多個Observable
不同之處
merge需要是相同型態,combineLatest和zip可以是不同型態merge只要其中有一條Observable有發送元素,就成立,而combineLatest和zip則需要每一條都至少發送過一個元素後才成立
使用時機
merge:當需要統合多個resourcescombineLatest:當resources只取最新的zip:當resources需要一起出現
CombineLatest和WithLatestFrom
相同之處
- 都是合併最新的元素
不同之處
combineLatest可合併多個ObservablewithLatestFrom是一個Observable為主,去取另一個Observable最新元素,共兩個
使用時機
withLatestFrom:當一個事件觸發時,去結合另一個resource
自身錯誤範例 這是我翻很久之前跟學長對話的訊息發現的,剛好拿出來當作錯誤範例
情境大概像這樣,我想要點了按鈕去『取得』另一個Observable『最新』的資料,簡化後的程式大概像下面這樣
// 錯誤示範let subject = PublishSubject<String>()
let resultObservable = Observable.combineLatest(button.rx.tap, subject)
resultObservable .debug("Result") .subscribe() .disposed(by: disposeBag)現在看起來,錯,錯的離譜,錯的荒唐,不過我當初確實這樣寫,這樣寫跟預期的結果有落差
- 正常情況下,若subject已有元素,我點擊按鈕,確實resultObservable能做到『取得』subject『最新』的元素,元素可能像這樣
((), "A") - 但當subject接收到新的元素,也就是說它值不一樣了,這時resultObservable同樣也會發送最新元素
((), "B")
這樣就不是我們想要的樣子了,一些情境下看起來正常,但在另一情境下就怪怪的,用錯operator就會這樣…,所以改成下面這樣
let resultObservable = button.rx.tap.withLatestFrom(subject)就能確確實實以button.rx.tap的事件去取得subject最新的元素。
FlatMapLatest和WithLatestFrom
跟上面的範例有點相似,在進行refresh時,希望它能取得目前選擇的item去call API,簡化後的程式大概像下面這樣
// 錯誤示範let selectedItem = BehaviorRelay<String>(value: "Item A")
let refreshSubject = PublishSubject<Void>()
let resultObservable = refreshSubject.flatMapLatest { selectedItem }
resultObservable .debug("Result") .subscribe() .disposed(by: disposeBag)}這樣會出什麼問題呢?
- 你點第一下、第二下…都會是正常的
- 當改變了selectedItem,像這樣
selectedItem.accept("Item B"),也會使resultObservable發出元素,因為flatMapLatest特性,第一次Refresh時,就把元素投影到selectedItem,並將結果合併到另一條Observable,也就是resultObservable,所以,當selectedItem持續發出元素,其結果都會到resultObservable
所以還是要用withLatestFrom,把他修改成
let resultObservable = refreshSubject.withLatestFrom(selectedItem)