所有文章

RxSwift 探索之旅 · 07

Combining Operators 與選擇指南

reduce、scan、startWith、concat、merge、combineLatest、zip、withLatestFrom 等 Combining operators,以及容易混用時怎麼選。

本篇目錄 · 16 個章節

我們常常要合併多個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)

執行結果

1
4
9
16
25

所以,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 -> subscribed
Concat -> 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 completed
Concat -> isDisposed

ConcatMap

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")

執行結果

Koala
Panda
Tiger
Cow

Merge

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”)

執行結果

Koala
Lion
Panda

CombineLatest

從語意上了解,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, 2
Penguin, 2
Monkey, 2
Monkey, 7
  1. 直得注意的是,one跟two的資料型態不同,combineLatest是少數可以合併不同資料型態的operator。
  2. 第一次Koala並沒有被發出來,因為這時的two尚未有元素,必須兩邊都有元素,combineLatest才會發出第一個合併的元素!如果有需要的話,可以搭配startWith() 給定預設值,讓combineLatest更早地發出元素。
  3. 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, 2
Penguin, 7
  1. Koala跟數字2都是Observable的第一個元素,所以被配再一起了
  2. Penguin跟數字7都是2nd,儘管中間還有Monkey,也不會受影響
  3. 一樣可以省略closure,執行結果就會變這樣
("Koala", 2)
("Penguin", 7)

WithLatestFrom

withLatestFrom也是去合併最新的元素,就以這概念來說,跟combineLatest有點像,但不同之處在於, withLatestFrom是以一條Observable為主,去接收另一條Observable最新的值,常見情境就是button的tap事件去合併某Observable,藉此取的最新元素作為參數,再去呼叫 API,大概會像這樣

// ViewController
button.rx.tap.bind(to: viewModel.observer)
// ViewModel
let 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")

圖解如下

  1. 以one為主,當發出Koala的時候,這時會去合two的最新元素,但two還沒發出任何元素,所以這時並不會發生任何事情
  2. 當two發出數字2的時候,也不會發生任何事情
  3. 當發出Penguin,這時會去合併two的最新元素數字2
  4. 當發出Monkey,這時還是去合併two的最新元素數字2
  5. 當發出Chicken,這時的two最新元素是數字7,所以合併數字7

執行結果如下

Penguin, 2
Monkey, 2
Chicken, 7

Amb

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")

執行結果

A
B
C

SwitchLatest

另外一個切換方式是switchLatest,不像amb,switchLatest不侷限有只有兩條,要切換不同的Observable ,只要發送型態相同的Observable給Xource subject,就可以了,下面展示簡單範例

let one = PublishSubject<String>()
let two = PublishSubject<String>()
let three = PublishSubject<String>()
// 1
let source = PublishSubject<Observable<String>>()
// 2
source.switchLatest()
.subscribe(onNext: {
print($0)
})
.disposed(by: disposeBag)
// 3
source.onNext(one)
one.onNext("A")
two.onNext("1")
three.onNext("Koala")
// 4
source.onNext(two)
one.onNext("B")
two.onNext("2")
one.onNext("Penguin")
source.onNext(three)
three.onNext("Monkey")
three.onNext("Chicken")
two.onNext("3")
  1. 建立一個名為source的Observable,他的元素必須也要是Observable<T>才行,這裡為Observable<String>
  2. 訂閱source.switchLatest(),來查看現在切換到的Observable的元素
  3. 當source接收到one時,現在只會接收one發送過來的元素
  4. 當source接收到two時,現在只會接收two發送過來的元素,依此類推

執行結果

A
2
Monkey
Chicken

講到這,switchLatest跟flatMapLatest很像啊?看書才知道原來flatMapLatest就是map跟switchLatest的結合,不過我基本上我都是使用flatMapLatest就是了。

怎麼選擇 Operator

上面幾個operator看起來都很相似,我一開始學的時候,flatMapLatest、combineLatest和withLatestFrom都亂用。下面統整它們的差異,並分享過去犯錯的範例,給大家借鏡。

Merge、CombineLatest和Zip

相同之處

  1. 都可以合併多個Observable

不同之處

  1. merge需要是相同型態,combineLatest和zip可以是不同型態
  2. merge只要其中有一條Observable有發送元素,就成立,而combineLatest和zip則需要每一條都至少發送過一個元素後才成立

使用時機

  1. merge:當需要統合多個resources
  2. combineLatest:當resources只取最新的
  3. zip:當resources需要一起出現

CombineLatest和WithLatestFrom

相同之處

  1. 都是合併最新的元素

不同之處

  1. combineLatest可合併多個Observable
  2. withLatestFrom是一個Observable為主,去取另一個Observable最新元素,共兩個

使用時機

  1. withLatestFrom:當一個事件觸發時,去結合另一個resource

自身錯誤範例 這是我翻很久之前跟學長對話的訊息發現的,剛好拿出來當作錯誤範例

情境大概像這樣,我想要點了按鈕去『取得』另一個Observable『最新』的資料,簡化後的程式大概像下面這樣

// 錯誤示範
let subject = PublishSubject<String>()
let resultObservable = Observable.combineLatest(button.rx.tap, subject)
resultObservable
.debug("Result")
.subscribe()
.disposed(by: disposeBag)

現在看起來,錯,錯的離譜,錯的荒唐,不過我當初確實這樣寫,這樣寫跟預期的結果有落差

  1. 正常情況下,若subject已有元素,我點擊按鈕,確實resultObservable能做到『取得』subject『最新』的元素,元素可能像這樣((), "A")
  2. 但當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)
}

這樣會出什麼問題呢?

  1. 你點第一下、第二下…都會是正常的
  2. 當改變了selectedItem,像這樣selectedItem.accept("Item B"),也會使resultObservable發出元素,因為flatMapLatest特性,第一次Refresh時,就把元素投影到selectedItem,並將結果合併到另一條Observable,也就是resultObservable,所以,當selectedItem持續發出元素,其結果都會到resultObservable

所以還是要用withLatestFrom,把他修改成

let resultObservable = refreshSubject.withLatestFrom(selectedItem)

就符合我們預期的了!