本章節(jié)將繼續(xù)為大家介紹Rx 的方法使用。
map
將變量A轉(zhuǎn)換為變量B
let originalSequence = Observable.of(Character("A"),Character("B"),Character("C"))
_ = originalSequence.map{ char in
return char.hashValue
}.subscribeNext({ (vc) -> Void in
print(vc);
})
}
/*
4799450059485597671
4799450059485597672
4799450059485597677
使用subscribe的輸出結(jié)果：
**Next(4799450059485597671)**
**Next(4799450059485597672)**
**Next(4799450059485597677)**
**Completed**
*/
flatMap
transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable
** The FlatMap operator transforms an Observable by applying a function that you specify to each item emitted by the source Observable, where that function returns an Observable that itself emits items. FlatMap then merges the emissions of these resulting Observables, emitting these merged results as its own sequence.
This method is useful, for example, when you have an Observable that emits a series of items that themselves have Observable members or are in other ways transformable into Observables, so that you can create a new Observable that emits the complete collection of items emitted by the sub-Observables of these items.
Note that FlatMap merges the emissions of these Observables, so that they may interleave.
In several of the language-specific implementations there is also an operator that does not interleave the emissions from the transformed Observables, but instead emits these emissions in strict order, often called ConcatMap or something similar.*
將sub-Observables 的結(jié)果合并到flatmap的sequence 中
func flattenMap(){
let sequenceInt = Observable.of(1, 2, 3)
let sequenceString = Observable.of("A", "B", "C", "D", "E", "F", "--")
_ = sequenceInt
.flatMap { (x:Int) -> Observable<String> in
print("from sequenceInt \(x)")
return sequenceString
}
.subscribe {
print($0)
}
/*
from sequenceInt 1
Next(A)
Next(B)
Next(C)
Next(D)
Next(E)
Next(F)
Next(--)
from sequenceInt 2
Next(A)
Next(B)
Next(C)
Next(D)
Next(E)
Next(F)
Next(--)
from sequenceInt 3
Next(A)
Next(B)
Next(C)
Next(D)
Next(E)
Next(F)
Next(--)
Completed
*/
}
scan
給observable的每一個(gè)item 運(yùn)用一個(gè)function ，并返回結(jié)果
scan(0)初始值 和一個(gè)accumulator
- parameter seed: The initial accumulator value.
- parameter accumulator: An accumulator function to be invoked on each element.
- returns: An observable sequence containing the accumulated values.
*/
@warn_unused_result(message="http://git.io/rxs.uo")
public func scan<A>(seed: A, accumulator: (A, Self.E) throws -> A) -> RxSwift.Observable<A>
func scan(){
//
let sequenceToSum = Observable.of(0, 1, 2, 3, 4, 5)
_ = sequenceToSum
.scan(0) { acum, elem in
acum + elem
}
.subscribe {
print($0)
}
}
/*
Next(0)
Next(1)
Next(3)
Next(6)
Next(10)
Next(15)
Completed
*/
distinctUntilChanged
控制連續(xù)重復(fù)的item，如果連續(xù)的item相同，則不輸出
let subscription = Observable.of(1, 2, 3, 1, 1, 4)
.distinctUntilChanged()
.subscribe {
print($0)
}
take
只取前n 項(xiàng)
let subscription = Observable.of(1, 2, 3, 4, 5, 6)
.take(3)
.subscribe {
print($0)
}
startWith
在輸出序列之前，在序列前添加指定的序列項(xiàng)
// 在序列前依次添加序列項(xiàng) 0 ，1，2，3
func startWith(){
let _ = Observable.of(4, 5, 6, 7, 8, 9)
.startWith(3)
.startWith(2)
.startWith(1)
.startWith(0)
.subscribe {
print($0)
}
}
/*
**Next(0)**
**Next(1)**
**Next(2)**
**Next(3)**
新添加的項(xiàng)
**Next(4)**
**Next(5)**
**Next(6)**
**Next(7)**
**Next(8)**
**Next(9)**
**Completed**
*/
combinlatest
func combinlasted(){
let intOb1 = PublishSubject<String>()
let intOb2 = PublishSubject<Int>()
_ = Observable.combineLatest(intOb1, intOb2) {
"\($0) \($1)"
}
.subscribe {
print($0)
}
intOb1.on(.Next("A"))
// intOb2.on(.Next(1))
intOb1.on(.Next("B"))
intOb2.on(.Next(2))
/*
Next(A 1)
Next(B 1)
Next(B 2)
// 注銷 intOb2.on(.Next(1))
Next(B 2)
*/
}
另一版本
func combinLastedVer2(){
let intOb1 = Observable.just(2)
let intOb2 = Observable.of(0, 1, 2, 3, 4)
_ = Observable.combineLatest(intOb1, intOb2) {
"\($0) \($1)"
}
.subscribe {
print($0)
/*
Next(2 0)
Next(2 1)
Next(2 2)
Next(2 3)
Next(2 4)
Completed
*/
}
}
func combinLastedVer3(){
let intOb1 = Observable.just(2)
let intOb2 = Observable.of(0, 1, 2, 3)
let intOb3 = Observable.of(0, 1, 2, 3, 4)
_ = Observable.combineLatest(intOb1, intOb2, intOb3) {
"\($0) \($1) \($2)"
}
.subscribe {
print($0)
/*
Next(2 3 0)
Next(2 3 1)
Next(2 3 2)
Next(2 3 3)
Next(2 3 4)
Completed
*/
}
}
zip
將多個(gè)observable 的結(jié)果組合成一個(gè)并返回，但是必須每一個(gè)observable的item 要對(duì)應(yīng)
func zip1(){
let intOb1 = PublishSubject<String>()
let intOb2 = PublishSubject<Int>()
_ = Observable.zip(intOb1, intOb2) {
"\($0) \($1)"
}
.subscribe {
print($0)
}
intOb1.on(.Next("A"))
intOb2.on(.Next(1))
intOb1.on(.Next("B"))
intOb1.on(.Next("C"))
intOb2.on(.Next(2))
/*
Next(A 1)
Next(B 2)
*/
}
func zip2(){
let intOb1 = Observable.just(2)
let intOb2 = Observable.of(0, 1, 2, 3, 4)
_ = Observable.zip(intOb1, intOb2) {
"\($0) \($1)"
}
.subscribe {
print($0)
/*
Next(2 0)
Completed
*/
}
}
func zip3(){
let intOb1 = Observable.of(0, 1)
let intOb2 = Observable.of(0, 1, 2, 3)
let intOb3 = Observable.of(0, 1, 2, 3, 4)
_ = Observable.zip(intOb1, intOb2, intOb3) {
"\($0) \($1) \($2)"
}
.subscribe {
print($0)
}
/*
Next(0 0 0)
Next(1 1 1)
Completed
*/
}
merge
將Observable的item合并為一個(gè)
let subject1 = PublishSubject<Int>()
let subject2 = PublishSubject<Int>()
_ = Observable.of(subject1, subject2)
.merge()
.subscribeNext { int in
print(int)
}
subject1.on(.Next(20))
subject1.on(.Next(40))
subject1.on(.Next(60))
subject2.on(.Next(1))
subject1.on(.Next(80))
subject1.on(.Next(100))
subject2.on(.Next(1))
func merge2(){
let subject1 = PublishSubject<Int>()
let subject2 = PublishSubject<Int>()
_ = Observable.of(subject1, subject2)
.merge(maxConcurrent: 1)// 如果2 則結(jié)果與上述相同
.subscribe {
print($0)
}
subject1.on(.Next(20))
subject1.on(.Next(40))
subject1.on(.Next(60))
subject2.on(.Next(1))
subject1.on(.Next(80))
subject1.on(.Next(100))
subject2.on(.Next(1))
/*
Next(20)
Next(40)
Next(60)
Next(80)
Next(100)
*/
}
switchlatest
Switch subscribes to an Observable that emits Observables. Each time it observes one of these emitted Observables, the Observable returned by Switch unsubscribes from the previously-emitted Observable begins emitting items from the latest Observable. Note that it will unsubscribe from the previously-emitted Observable when a new Observable is emitted from the source Observable, not when the new Observable emits an item. This means that items emitted by the previous Observable between the time the subsequent Observable is emitted and the time that subsequent Observable itself begins emitting items will be dropped (as with the yellow circle in the diagram above)
func switchLatest(){
let var1 = Variable(0)
let var2 = Variable(200)
// var3 is like an Observable<Observable<Int>>
let var3 = Variable(var1.asObservable())
let d = var3
.asObservable()
.switchLatest()
.subscribe {
print($0)
}
var1.value = 1
var1.value = 2
var1.value = 3
var1.value = 4
var3.value = var2.asObservable()
var2.value = 201
var1.value = 5
var1.value = 6
var1.value = 7
/*
Next(0)
Next(1)
Next(2)
Next(3)
Next(4)
Next(200)
Next(201)
Completed
*/
}
