operator 也是 Rx 的基本元素, 通过它, 可以对 observable 中的事件序列进行操作.� 比如�可以去简单地进行加减. 通过 �operator 的链式表达, 可以实现许多复杂的�逻辑.
本部分首先学习 filter 类型的操作符, 然后是 transform 类型的操作符, 然后再看 combining 类型的操作符. 最后是一些基于时间的操作符, 比如延迟事件, 组合一段时间内的事件等等.
学习完本部分, 就具备了编写一些简单的 RxSwift app 的能力.
学习一个新的技术栈和�建造一栋摩天大楼是一个道理, 首先要打好打牢基础. 在之前的学习中已经学会了Observable, subject, RxSwift 中的内存管理等基础性内容. 下面就在这些的基础上, 再向上学习.
本章中会讲如何通过 RxSwift 的 过滤操作符来操作 next 事件, 这样最终观察者接收到的就是它自己想要接收的数据.
�概述
这里直入主题, 我们先来看再 RxSwift 中如何使用过滤操作符.
过滤型操作符
主要有如下三种:
- ignoreElements
- elementAt
- filter
ignoreElements 操作符
这个操作符的作用是过滤掉所有的 next 事件:
let disbag = DisposeBag()
let sbj = PublishSubject<Int>()
sbj
// .ignoreElements()
.subscribe(onNext: {
print($0)
}, onError: {
print($0)
}, onCompleted: {
print("complete")
}, onDisposed: {
print("dispose")
})
.addDisposableTo(disbag)
sbj.onNext(1)
sbj.onNext(2)
sbj.onCompleted()
若不加 ignoreElements, 则输出为:
1
2
complete
dispose
而加了的话:
complete
dispose
可以看到, ignoreElement 操作符的作用的确是将所有的 next 事件过滤掉.
elementAt 操作符
比如只想接收序列中的某个下标位置的元素(从0开始计数), 可以使用 elementAt 操作符.
elementAt 操作符的参数越界的话并不会崩溃, 只会打印错误信息.
上面这两个操作符都是属于过滤操作符中的"忽略"子类中的操作符.
若需要特殊的过滤条件, 则可以使用 filter 操作符.
filter 的原理是利用一个过滤条件块来, 在里面将过滤条件应用到所有的元素上, 这样即可对元素进行过滤. 只有当条件为真的元素才不会被过滤. 即需要保留的元素在应用条件时候的判断结果为真.
exampleOf("过滤", operation: {
let disposebag = DisposeBag()
let obsv = Observable.of(1, 2, 3, 4, 56)
obsv
.filter({ elem in
elem > 3
})
.subscribe(onNext: {
print($0)
}).addDisposableTo(disposebag)
})
上述首先对 observable 的事件序列应用了过滤操作符, 过滤掉所有小于 3 的元素. 输出为:
过滤
4
5
6
跳读操作符(skip)
如果想要自动跳过若干个元素时, 就可以使用 skip 操作符.
比如有三天的天气预报可以被观察, 但只想要今天的, 就可以跳过前两天的预报:
exampleOf("skip", operation: {
let obsv = Observable.from([1, 2, 3, 48])
obsv.skip(3).subscribe(onNext: {
print($0)
}).addDisposableTo(disBag)
})
输出为:
skip
4
8
实际上 skip 是一个操作符家族, 里面有诸如 skipWhile, 它允许在 skip 的时候同时指定条件. 和 filter 不同的是, skipWhile 是遇到第一个不能 skip 的元素之后, 就不再进行判断了, 后面所有的元素都放行.
并且, skipWhile 的判断条件中, 如果满足条件的会被跳过. 结合起来即: 遇到第一个不满足判断条件的(返回值为 false 的)�元素及其后面的所有元素都会被观察者接收到.
比如下面的代码:
exampleOf("skipWhile", operation: {
let obsv = Observable.from([1, 2, 3, 48, 1, 2, 3])
obsv.skipWhile({ elem in
elem * 2 < 8
}).subscribe(onNext: {
print($0)
}).addDisposableTo(disBag)
})
则其输出为:
skipWhile
4
8
1
2
3
到目前为止, 所有的过滤都是使用一些静态条件. 但如果需要基于其他的 observable 来动态过滤元素呢?
下面就来介绍一些这样的 operator. 首先来看的是 skipUntil, 它会持续在� "源 observable" (就是观察者观察的那个 observable) 中跳过元素, 直到� "触发器 observable"(即另外一个 observable) 发送了 next 事件(而 complete 和 error 均无作用), 此时源 observable 中的后续的所有事件就不会再被跳过了.
比如如下代码:
exampleOf("skipUntil", operation: {
let sourceObsv = PublishSubject<Strin()
let triggerObsv = PublishSubject<Strin()
sourceObsv
.skipUntil(trigger)
.subscribe(onNext: {
print($0)
}).addDisposableTo(disBag)
sourceObsv.onNext("A")
sourceObsv.onNext("B")
triggerObsv.onNext("something")
sourceObsv.onNext("C")
})
skipUntil
C
Taking 操作符
Taking 的效果正好和 skip 相反.
比如如下代码:
exampleOf("taking", operation: {
let obsv = Observable.from([1, 2, 3, 48, 1, 2, 3])
obsv
.take(3)
.subscribe(onNext: {
print($0)
}).addDisposableTo(disBag)
})
则输出结果是:
taking
1
2
3
即 take(_ count:) 操作符的作用是只获取事件序列中的 count 个元素.
相应的, 也有 takeWhile 操作符, 它和 skipWhile 的区别是它一直去取满足条件的, 直到遇到第一个不满足条件的, 而 skipWhile 是满足条件的都被跳过, 直到遇到第一个不满足条件的.
另外还有些情况下需要� takeWhile 满足条件的同时满足�指定的元素下标要求, 此时就可以使用 takeWhileWithIndex:
exampleOf("takeWhileWithIndex", operation: {
let obsv = Observable.from([5, 4, 8, 12, 3])
obsv
.takeWhileWithIndex({ value, idx in
return value > 3 && idx < 5
})
.subscribe(onNext: {
print($0)
})
.addDisposableTo(disBag)
})
输出为:
takeWhileWithIndex
5
4
8
即它去取满足条件的元素, 直到遇到第一个不满足条件的, 而后面的�都不通过.
另外还有 �skipWhileWithIndex, 不同点是它是去跳过. 而和 skipUntil 类似, 有 takeUntil 操作符, 它的作用是一直�允许取 "源 observable" 中的元素, 直到 "触发器 observable" 发送 next 事件.
而它可以用在如下情况:
-
比如在 RxCocoa 中, 用于将观察者释放. 而无需装入 disposeBag. 但对于大多数情况而言, 放入 disposeBag 都是最佳的选择.
比如下面的代码:
someObservable .takeUntil(self.rx.deallocated) .subscribe(onNext: { print($0) })即当自己被释放之前, 都可以获取到源 observable 的事件, 而当 触发器 �observable(这里是 RxCocoa 中的自己) 发送自己被释放的事件时, 就不能再获取源 observable 中的任何 next 事件了.
Distinct 操作符
下面来看一些可以防止多次重复元素通过的操作符.
先来看 distinctUntilChanged 操作符:
1---2---2---1
distinctUntilChanged
1---2------1
它的作用就是过滤掉序列中一次或多次相邻元素是相同的情况.
比如如下代码:
example(of: "Distinct Operator") {
Observable.of("A", "B", "A", "A", "B", "B")
.distinctUntilChanged()
.subscribe(onNext: {
print($0)
})
.addDisposableTo(disposeBag)
}
输出为:
--- Example of: Distinct Operator ---
A
B
A
B
而操作符的判断依据是根据 Equatable 协议, 由于 String 是实现了该协议的, 故可以对 String 类型的序列使用.
但如果是没有实现该协议的元素类型, 要想判断的话, 可以先去实现该协议. 或者是可以使用 distinctUntilChanged(_:) 提供判断条件即可.
example(of: "Distinct with condition") {
let elem0 = MyElemType(value: 1, name: "elem0")
let elem1 = MyElemType(value: 2, name: "elem1")
let elem2 = MyElemType(value: 2, name: "elem2")
let elem3 = MyElemType(value: 1, name: "elem3")
Observable.of(elem0, elem1, elem2, elem3)
.distinctUntilChanged({ (elemA, elemB) -Bool in
elemA.value == elemB.value
})
.subscribe(onNext: {
print($0)
})
.addDisposableTo(disposeBag)
}
输出为:
--- Example of: Distinct with condition ---
MyElemType(value: 1, name: "elem0")
MyElemType(value: 2, name: "elem1")
MyElemType(value: 1, name: "elem3")
可以看到, 通过条件来判断两个元素是否相等操作起来十分方便.
