preface
In RxSwift, higher-order functions can also be operators, which can help us create new sequences or combine existing sequences to generate a new sequence.
Conversion operator
1. map
The Map operator converts the original Observable sequence into a new Observable by passing in a function closure. The Map function converts all elements of the source sequence and returns a new sequence.
Example:
let disposeBag = DisposeBag()
Observable.of(1, 2, 3)
.map { $0 * 100}
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: 100 200 300Copy the code2. flatMap
Map is prone to “raise dimensions” during transformation. That is, after the transformation, you go from a sequence to a sequence of sequences. The flatMap operator, on the other hand, applies a transform method to each element of the source Observable, converting them to Observables. The elements of the Observables are then merged and sent out. Reduces the dimension to an Observable sequence.
Observable
Observable
Observables
Example:
let disposeBag = DisposeBag()
let Henry = BehaviorSubject(value: 1)
let Jeannie = BehaviorSubject(value: 2)
let Henry_Subject = BehaviorSubject(value: Henry)
Henry_Subject.asObservable()
.flatMap { $0 }
.subscribe(onNext: { print($0) }) .disposed(by: OnNext (3) henry_subject.onNext (Jeannie) Henry. OnNext (5) Jeannie. OnNext (6) // Result 1 3 2 5 6Copy the code3. flatMapLatest
The flatMapLatest operator converts Observable elements to other Observables and fetches the latest of these Observables.
flatMapLatest
Observable
Observables
Observable
Observables
flatMapLatestwithflatMapThe only difference is:flatMapLatestOnly the latest ones will be acceptedvalueEvents.flatMapLatestIs, in fact,mapandswitchLatestA combination of operators- There are
flatMapLatestThere will beflatMapFirst.flatMapFirstwithflatMapLatestOn the contrary:flatMapFirstOnly the original will be acceptedvalueEvents. (This operator prevents repeated requests: clicking a button to send a request, for example, should not continue until the request is complete. Can be usedflatMapFirstOperator.
Example:
let disposeBag = DisposeBag()
let Henry = BehaviorSubject(value: 1)
let Jeannie = BehaviorSubject(value: 2)
let Henry_Subject = BehaviorSubject(value: Henry)
Henry_Subject.asObservable()
.flatMapLatest{ $0 }
.subscribe(onNext: { print($0) }) .disposed(by: OnNext (3) henry_subject.onNext (Jeannie) Jeanny.onnext (5) henry.onNext (6) // Result: 1 3 2 5Copy the code4. concatMap
The concatMap operator converts Observable elements to other Observables, and then concatenates them
concatMap
Observable
Observables
Observables
concatMap与flatMapThe only difference is: the current oneObservableAfter the element is sent, the last oneObservableBefore you can start emitting elements. Wait for the previous oneObservableThe last one is generated after the completion eventObservableSubscribe.
Example:
let disposeBag = DisposeBag()
let Henry = BehaviorSubject(value: 1)
let Jeannie = BehaviorSubject(value: 2)
let Henry_Subject = BehaviorSubject(value: Henry)
Henry_Subject.asObservable()
.concatMap{ $0 }
.subscribe(onNext: { print($0) }) .disposed(by: OnNext (5) Jeannie. OnNext (6) Henry. OnCompleted () // Result: 1 3 6Copy the code5. scan
The Scan operator continuously converts Observable and emits the result of each function return
scan
scan
Example:
let disposeBag = DisposeBag()
Observable.of(1, 2, 3, 4, 5)
.scan(0) { acum, elem in
acum + elem
}
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result 1 3 6Copy the code6. reduce
The reduce operator is somewhat similar to the scan operator in that the reduce operator applies a function to the first element. The result is then filled in as an argument to the second element’s application function. And so on, until the final result is emitted after iterating through all the elements.
Example:
let disposeBag = DisposeBag()
Observable.of(10, 20, 30)
.reduce(0, accumulator: +)
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: 60Copy the code7.toArray
The toArray operator converts a sequence into an array, sends it as a single event, and then terminates.
Example:
let disposeBag = DisposeBag()
Observable.of(1, 2, 3)
.toArray()
.subscribe(onNext: { print($0Disposed (by: disposeBag) // result: [1,2,3]Copy the codeCombinatorial operator
1. merge
The merge operator merges Observables into one Observable. By using the Merge operator, multiple Observables can be merged into one Observables. When an Observable emits an element, it emits that element.
Observable
onError
Observable
onError
It is worth noting that the sequence elements to be merged here must be of the same type.
Example:
let disposeBag = DisposeBag()
let Henry = PublishSubject<Int>()
let Jeannie = PublishSubject<Int>()
Observable.of(Henry, Jeannie)
.merge()
.subscribe(onNext: { print($0) }) .disposed(by: disposeBag) Henry.onNext(1) Henry.onNext(2) Jeannie.onNext(100) Henry.onNext(3) Henry.onNext(4) Jeannie.onNext(1000) // Result: 1 2 100 3 4 1000Copy the code2. startWith
The startWith operator inserts event elements into the Observable header. The pre-inserted event elements are emitted before the emitted event elements of an Observable.
Observable
Observable
Example:
let disposeBag = DisposeBag()
Observable.of("1"."2")
.startWith("A")
.startWith("B")
.startWith("a"."b")
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: A B Ba 1 2Copy the code3. zip
The ZIP operator compresses elements from multiple Observables, and it waits until each Observable element event corresponds to it before merging, and then emits the resulting element for each combination.
zip
Observables
Observable
Observables
Observables
Observables
Observables
Example:
let disposeBag = DisposeBag()
let Henry = PublishSubject<String>()
let Jeannie = PublishSubject<String>()
Observable.zip(Henry, Jeannie) { $0 + The $1 }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Henry.onNext("1")
Jeannie.onNext("A")
Henry.onNext("2")
Jeannie.onNext("B")
Jeannie.onNext("C")
Henry.onNext("3")
Henry.onNext("4") // Result: 1A 2B 3CCopy the codeThe ZIP operator is often used to consolidate network requests. For example, if we want to send two requests at the same time, only after both requests are successful, we can combine the results of the two requests and continue processing. This can be done with zip.
4. combineLatest
The combineLatest operator also merges multiple Observables sequence elements. But different from ZIP, it merges the latest event element of each Observable sequence and sends the combined element whenever a new event is emitted by any Observable. (That is, if these Observables have ever emitted elements).
Example:
let disposeBag = DisposeBag()
let Henry = PublishSubject<String>()
let Jeannie = PublishSubject<String>()
Observable.combineLatest(Henry, Jeannie) { $0 + The $1 }
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
Henry.onNext("1")
Jeannie.onNext("A")
Henry.onNext("2")
Jeannie.onNext("B")
Jeannie.onNext("C")
Henry.onNext("3")
Henry.onNext("4") // Results: 1A 2A 2B 2C 3C 4CCopy the code5. concat
The concat operator concatenates Observables in sequence, and the next Observable will not be sent until a completed event is emitted from the previous Observable.
Example:
let disposeBag = DisposeBag()
let Henry = BehaviorSubject(value: 1)
let Jeannie = BehaviorSubject(value: 2)
let Henry_Subject = BehaviorSubject(value: Henry)
Henry_Subject.asObservable()
.concat()
.subscribe(onNext: { print($0) }) .disposed(by: disposeBag) Henry.onNext(3) Henry_Subject.onNext(Jeannie) Jeannie.onNext(5) Jeannie.onNext(6) Henry.onCompleted() Jeanny.onnext (7) // Result: 1 3 6 7Copy the codeThe concat operator is similar to the concatMap operator in that it does not send the next Observable until a completed event is emitted from the previous Observable.
6. withLatestFrom
The withLatestFrom operator combines the two Observables’ latest elements in a function that sends the combined element out when the first Observable emits an element.
Example:
let disposeBag = DisposeBag()
let firstSubject = PublishSubject<String>()
let secondSubject = PublishSubject<String>()
firstSubject
.withLatestFrom(secondSubject) {
(first, second) in
return first + second
}
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
firstSubject.onNext("A ️")
secondSubject.onNext("1")
firstSubject.onNext("B"// Result: B1Copy the codeFilter condition operator
1. filter
The filter operator is used to filter out undesirable events, emitting only Observable elements that pass detection.
Example:
let disposeBag = DisposeBag()
Observable.of(11, 22, 3, 8, 2, 1)
.filter { $0 > 10 }
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: 11 22Copy the code2. take
The take operator emits only n elements from the Observable, automatically sending a.completed event when that number is satisfied.
Example:
let disposeBag = DisposeBag()
Observable.of(1, 2, 3, 4, 5, 6)
.take(3)
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: 1 2 3Copy the code3. takeLast
The takeLast operator is similar to the take operator in that it sends only the last n elements of the Observable sequence and ignores the preceding elements.
Example:
let disposeBag = DisposeBag()
Observable.of(1, 2, 3, 4, 5, 6)
.takeLast(3)
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: 4 5 6Copy the code4. takeWhile
The takeWhile operator determines in turn whether each value of the Observable sequence satisfies a given condition. It completes automatically when the first value that does not meet the condition appears.
Example:
let disposeBag = DisposeBag()
Observable.of(2, 3, 4, 5, 6)
.takeWhile { $0 < 4 }
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: 2 3Copy the code5. takeUntil
The takeUntil operator ignores elements emitted after the second Observable generates the event. That is, the takeUntil operator looks at the source Observable, which also looks at the second Observable. Once the second Observable emits an element or a termination event, the source Observable automatically completes and stops sending events.
Example:
let disposeBag = DisposeBag()
let Henry = PublishSubject<String>()
let Jeannie = PublishSubject<String>()
Henry
.takeUntil(Jeannie)
.subscribe { print($0) }
.disposed(by: disposeBag)
Henry.onNext("Good")
Henry.onNext("Lucky")
Jeannie.onNext("Bug")
Henry.onNext("Tnanks")
Henry.onNext("a lot"// Result: Next (Good) Next (Lucky) completedCopy the code6. skip
The skip operator skips the first n element events emitted by the source Observable sequence.
Example:
let disposeBag = DisposeBag()
Observable.of(1, 2, 3, 4)
.skip(2)
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: 3 4Copy the code7. skipWhile
The skipWhile operator lets you ignore the first few events that satisfy the condition in the source Observable.
Example:
let disposeBag = DisposeBag()
Observable.of(2, 3, 4, 5, 6)
.skipWhile { $0 < 5 }
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: 5 6Copy the code8. skipUntil
In addition to subscribing to the source Observable, skipUntil can also be used to monitor another Observable. The skipUntil operator skips the first elements of an Observable until another Observable emits an element.
Example:
let disposeBag = DisposeBag()
let Henry = PublishSubject<Int>()
let Jeannie = PublishSubject<Int>()
Henry
.skipUntil(Jeannie)
.subscribe(onNext: { print($0) }) .disposed(by: OnNext (0) henry.onnext (3) henry.onnext (4) // Still receiving messages Jeanny.onnext (0) Henry. OnNext (5) // Result: 3 4 5Copy the code9. elementAt
The elementAt operator emits only the NTH element of an Observable, which handles only element events in a given location
Example:
let disposeBag = DisposeBag()
Observable.of(1, 2, 3, 4)
.elementAt(2)
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result: 3Copy the code10. distinctUntilChanged
The distinctUntilChanged operator is used to filter out consecutive duplicate events. If the latter element is the same as the previous one, the element will not be emitted. If the latter element is not the same as the previous one, the element will be emitted.
Example:
let disposeBag = DisposeBag()
Observable.of(1, 2, 1, 1, 1, 3)
.distinctUntilChanged()
.subscribe(onNext: { print($0Disposed (by: disposeBag) // Result 1 2 1 3Copy the code11.amb
The amB operator takes the first Observable that emitted an element or generated an event in multiple Observables. The event can be a Next, error, or completed event, and emits only the Observable element event. Ignore the other Observables.
Example:
let disposeBag = DisposeBag()
let subject1 = PublishSubject<Int>()
let subject2 = PublishSubject<Int>()
let subject3 = PublishSubject<Int>()
subject1
.amb(subject2)
.amb(subject3)
.subscribe(onNext: { print($0) })
.disposed(by: disposeBag)
subject2.onNext(1)
subject1.onNext(20)
subject2.onNext(2)
subject1.onNext(40)
subject3.onNext(0)
subject2.onNext(3)
subject1.onNext(60)
subject3.onNext(0)
subject3.onNext(0)
//结果：
1
2
3
Copy the codeconclusion
This is the summary of the higher order functions of RxSwift. From these simple examples, these operators can be very helpful when working with sequences and are simple to use. Learn RxSwift well and go anywhere.
Thanks for RxSwift Chinese documentation