empty,它會發送一個 Completed 事件，創建一個不發射任何數據但是正常終止的 Observable
// empty
let emptySeq: Observable<Int> = empty()
let subscription = emptySeq.subscribe { event in
print(event)
}
// 輸出Completed
never 不會發送任何事件，創建一個不發射數據也不終止的 Observable
// never
let neverSeq: Observable<String> = never()
let subscription = neverSeq.subscribe { event in
print(event)
}
// 什么都沒用打印
just,會先發送Next(Value)，然后發送 Completed，創建一個發射指定值的 Observable。
Paste_Image.png
// just
let justSeq = just("RxSwift")
let subscription = justSeq.subscribe { event in
print(event)
}
// 打印
// Next(RxSwift)
// Completed
sequenceOf 把一系列元素轉換為事件
// sequenceOf
let sequenceElements = sequenceOf(1, 2, 3, 4)
let subscription = sequenceElements.subscribe { event in
print(event)
}
from 通過 asObservable，把其他數據類型轉換為 Observable
Paste_Image.png
// asObservable, 把序列轉換成Observable
let sequenceFromArray = [1, 2, 3, 4].asObservable()
let subscription = sequenceFromArray.subscribe { event in
print(event)
}
// 輸出
// Next(1)
// Next(2)
// Next(3)
// Next(4)
// Completed
create，通過它重新創建一個Observable,通過.on發射Next和Completed事件
Paste_Image.png
// create創建序列，通過.on添加事件
let myCreate = { (element: Int) -> Observable<Int> in
return create { observer in
observer.on(.Next(element))
observer.on(.Completed)
return NopDisposable.instance
}
}
let subscription = myCreate(1).subscribe { event in
print(event)
}
// 輸出
// Next(1)
// Completed
failWith
// failWith，只會發送Error事件
let error = NSError(domain: "error", code: 1001, userInfo: nil)
let errorSeq: Observable<Int> = failWith(error)
let subscription = errorSeq.subscribe { event in
print(event)
}
// 輸出
// Error(Error Domain=error Code=1001 "(null)")
deferred 直到有訂閱者訂閱才創建 Observable，并為每一個訂閱者創建一個新的 Observable,在某些情況下，要等到最后一分鐘才能獲取到最新的數據，就需要這樣做
Paste_Image.png
// deferred 會等到有訂閱者，訂閱它才創建Observable
let deferredSeq: Observable<Int> = deferred {
print("create")
return create { observer in
observer.on(.Next(0))
observer.on(.Next(1))
observer.on(.Next(2))
return NopDisposable.instance
}
}
deferredSeq.subscribe { event in
print(event)
}
/*
create
Next(0)
Next(1)
Next(2)
*/
Subjects
PublishSubject
// PublishSubject,會發送從訂閱者，訂閱之后的事件
let subject = PublishSubject<String>()
subject.subscribe { event in
print("1->\(event)")
}
subject.on(.Next("a"))
subject.on(.Next("b"))
subject.subscribe { event in
print("2->\(event)")
}
subject.on(.Next("c"))
// 輸出
/*
1->Next(a)
1->Next(b)
1->Next(c)
2->Next(c)
*/
Paste_Image.png
BehaviorSubject
// BehaviorSubject 它開始發射原始 Observable 最近發射的數據，然后繼續發送其他來自Observable的數據
let subject = BehaviorSubject(value: "z")
subject.subscribe { event in
print("1->\(event)")
}
subject.on(.Next("a"))
subject.on(.Next("b"))
subject.subscribe { event in
print("2->\(event)")
}
subject.on(.Next("c"))
subject.on(.Completed)
// 輸出
1->Next(a)
1->Next(b)
1->Next(c)
2->Next(c)
Paste_Image.png
ReplaySubject
// ReplaySubject,當有訂閱者，訂閱了的時候他能重發事件，bufferSize指定重發的次數,補發1次
let subject = ReplaySubject<String>.create(bufferSize: 1)
subject.subscribe { event in
print("1->\(event)")
}
subject.on(.Next("a"))
subject.on(.Next("b"))
subject.subscribe { event in
print("2->\(event)")
}
subject.on(.Next("c"))
// 輸出
/*
1->Next(a)
1->Next(b)
2->Next(b)
1->Next(c)
2->Next(c)
*/
Paste_Image.png
Transform
map
Paste_Image.png
// map,通過對Observable發射映射的函數對每一項做轉換
let originalSeq = sequenceOf(1, 2, 3)
originalSeq.map { $0 * 2 }.subscribe { print($0) }
/*
輸出
Next(2)
Next(4)
Next(6)
Completed
*/
flatMap
// flatMap將一個發射數據的Observable變換為多個Observables，然后將它們發射的數據合并后放進一個單獨的Observable
let seqInt = sequenceOf(1, 2, 3)
let seqString = sequenceOf("a", "b", "c")
seqInt.flatMap { int in seqString }.subscribe { print($0) }
/*
Next(a)
Next(b)
Next(c)
Next(a)
Next(b)
Next(c)
Next(a)
Next(b)
Next(c)
Completed
*/
scan
Paste_Image.png
// scan連續的對序列中的元素應用某一個元素。然后把結果作為下一次的輸入
let seqToSum = sequenceOf(1, 2, 3, 4)
seqToSum.scan(0) { (sum, ele) -> Int in
sum + ele
}.subscribe { print($0) }
/*
輸入
Next(1)
Next(3)
Next(6)
*/
Filtering
Paste_Image.png
// filter,過濾不符合要求的元素
let seq = sequenceOf(0, 1, 2, 3, 4, 5, 6, 7, 8)
seq.filter { $0 % 2 == 0 }
.subscribe { print($0) }
/*
輸出
Next(0)
Next(2)
Next(4)
Next(6)
Next(8)
Completed
*/
distinct
// distinct,去掉相鄰的相同元素
let seq = sequenceOf(1, 2, 2, 2, 3, 1, 1, 4, 1, 4)
seq.distinctUntilChanged().subscribe { print($0) }
/*
輸出
Next(1)
Next(2)
Next(3)
Next(1)
Next(4)
Next(1)
Next(4)
Completed
*/
take
// take保留前幾項的數據
let subscription = sequenceOf(1, 2, 3, 4 , 5).take(3).subscribe { print($0) }
/*
Next(1)
Next(2)
Next(3)
Completed
*/
Combining(組合操作)
startWith
// startWith在數據序列前出入指定數據
let subscription = sequenceOf(2, 3, 4, 5).startWith(1).subscribe { print($0) }
/*
Next(1)
Next(2)
Next(3)
Next(4)
Next(5)
Completed
*/
combineLatest
Paste_Image.png
// combineLatest，當兩個Observables中任意一個發送了數據，使用一個函數把兩個Observable中最近的數據進行結合
let stringOb = PublishSubject<String>()
let intOb = PublishSubject<Int>()
combineLatest(stringOb, intOb) {
"\($0) \($1)"
}.subscribe { print($0) }
stringOb.on(.Next("A"))
intOb.on(.Next(1))
stringOb.on(.Next("B"))
stringOb.on(.Next("C"))
/*
Next(A 1)
Next(B 1)
Next(C 1)
*/
zip
Paste_Image.png
// zip它會等到Observable中的數據一一對應結合時，再發送數據
let stringOb = PublishSubject<String>()
let intOb = PublishSubject<Int>()
zip(stringOb, intOb) { "\($0) \($1)" }.subscribe { print($0) }
stringOb.on(.Next("A"))
stringOb.on(.Next("B"))
intOb.on(.Next(1))
intOb.on(.Next(2))
merge
Paste_Image.png
// merge，合并對個Observables的發射物
let subject1 = PublishSubject<Int>()
let subject2 = PublishSubject<Int>()
sequenceOf(subject1, subject2).merge().subscribe { print($0) }
subject1.onNext(1)
subject2.onNext(2)
subject1.onNext(3)
/*
Next(1)
Next(2)
Next(3)
*/
switchLatest
// switchLatest,將一個Observable<Observable<T>>轉為為這樣的Observable,它逐個發射數據的Observable
let var1 = Variable(0)
let var3 = Variable(var1)
let d = var3.switchLatest().subscribe { print($0) }
