原文链接:http://www.jianshu.com/p/429b5160611f
著作权归作者所有,转载请联系作者获得授权,并标注“简书作者”。
1.empty,它会发送一个Completed事件,创建一个不发射任何数据但是正常终止的Observable
// empty let emptySeq: Observable<Int> = empty() let subscription = emptySeq.subscribe { event in print(event) } // 输出Completed
2.never不会发送任何事件,创建一个不发射数据也不终止的Observable
// never let neverSeq: Observable<String> = never() let subscription = neverSeq.subscribe { event in print(event) } // 什么都没用打印
3.just,会先发送Next(Value),然后发送Completed,创建一个发射指定值的Observable。
![](https://i-blog.csdnimg.cn/blog_migrate/dbe5540d9ca2323bcd920665685a51f2.webp?x-image-process=image/format,png)
// just let justSeq = just("RxSwift") let subscription = justSeq.subscribe { event in print(event) } // 打印 // Next(RxSwift) // Completed
4.sequenceOf把一系列元素转换为事件
// sequenceOf let sequenceElements = sequenceOf(1, 2, 3, 4) let subscription = sequenceElements.subscribe { event in print(event) }
5.from通过asObservable,把其他数据类型转换为Observable
![](https://i-blog.csdnimg.cn/blog_migrate/2e6663287c3b3715629d2b5f8be68647.webp?x-image-process=image/format,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
6.create,通过它重新创建一个Observable,通过.on发射Next和Completed事件
![](https://i-blog.csdnimg.cn/blog_migrate/e78c87cb41f804387cccd6675b7809a6.webp?x-image-process=image/format,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
7
// 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)")
8.deferred直到有订阅者订阅才创建Observable,并为每一个订阅者创建一个新的Observable,在某些情况下,要等到最后一分钟才能获取到最新的数据,就需要这样做
![](https://i-blog.csdnimg.cn/blog_migrate/cc2bf8178df3f9f37a826de6fe86836c.webp?x-image-process=image/format,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) */
![](https://i-blog.csdnimg.cn/blog_migrate/3a0ca96285f6cb8e6ff046fafd1f98f7.webp?x-image-process=image/format,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)
![](https://i-blog.csdnimg.cn/blog_migrate/80fc9fe66319d3c5a01cc4c1faaefdc8.webp?x-image-process=image/format,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) */
![](https://i-blog.csdnimg.cn/blog_migrate/8d712fa82633b4eedbeb4a14d3d42dc1.webp?x-image-process=image/format,png)
Transform
map
![](https://i-blog.csdnimg.cn/blog_migrate/7590318ef4554fe80d48c7b79d1f1f96.webp?x-image-process=image/format,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
![](https://i-blog.csdnimg.cn/blog_migrate/9ab9239ac5dbb94770e257afea77a4ba.webp?x-image-process=image/format,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
![](https://i-blog.csdnimg.cn/blog_migrate/0331dd2ac89e349857ccf455dcc85c08.webp?x-image-process=image/format,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
![](https://i-blog.csdnimg.cn/blog_migrate/e78720103a0720c13bd6bf7fc3bdf544.webp?x-image-process=image/format,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
![](https://i-blog.csdnimg.cn/blog_migrate/23a612bd024a671b418c6a0721ceef7b.webp?x-image-process=image/format,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
![](https://i-blog.csdnimg.cn/blog_migrate/6cb95dac679dcb9629a7c7effa6bd53e.webp?x-image-process=image/format,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) }