Rxjs--过滤操作符

2019独角兽企业重金招聘Python工程师标准>>>

防抖动(debounce)、去重(distinct)、指定索引值(elementAt)、条件过滤(filter)、

单个匹配值(first、last...)、审计(audit发出间隔内的最新值)、节流(throttle收到通知时发出最新值)、

采样(sample)、限定取值(take)、跳过值(skip)

debounce

public debounce(durationSelector: function(value: T): SubscribableOrPromise): Observable

debounce 延时发送源 Observable 发出的值, 但如果源 Observable 发出了新值 的话, 它会丢弃掉前一个等待中的延迟发送。这个操作符会追踪源 Observable 的最新值, 并通过调用 durationSelector 函数来生产 duration Observable。

只有当 duration Observable 发出值或完成时，才会发出值，如果源 Observable 上没有发出其他值，那么 duration Observable 就会产生。如果在 duration Observable 发出前出现了新值，那么前一个值会被丢弃并且不会在输出 Observable 上发出。

debounceTime

public debounceTime(dueTime: number, scheduler: Scheduler): Observable

只有在指定的时间周期内没有发出另一个源值, 才从源 Observable 中发出一个值

distinct

public distinct(keySelector: function, flushes: Observable): Observable

返回 Observable，它发出由源 Observable 所发出的所有与之前的项都不相同的项

即使是在新浏览器中，长时间运行的 distinct 操作也可能会导致内存泄露。为了在某种场景下来缓解这个问题，可以提供一个可选的 flushes 参数， 这样内部的 Set 可以被“清空”，基本上清除了它的所有值。

Observable.of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1)
  .distinct()
  .subscribe(x => console.log(x)); // 1, 2, 3, 4

keySelector	function	可选的	可选函数，用来选择某个键的值以检查是否是不同的。
flushes	Observable	可选的	可选 Observable，用来清空操作符内部的 HashSet 。

distinctUntilChanged

public distinctUntilChanged(compare: function): Observable

返回 Observable，它发出源 Observable 发出的所有与前一项不相同的项(与前一值比较)

名称	类型	属性	描述
compare	function	可选的	可选比较函数，用来检验当前项与源中的前一项是否相同。

distinctUntilKeyChanged

public distinctUntilKeyChanged(key: string, compare: function): Observable

返回 Observable，它发出源 Observable 发出的所有与前一项不相同的项，使用通过提供的 key 访问到的属性来检查两个项是否不同

如果没有提供 compare 函数，默认使用相等检查。

名称	类型	属性	描述
key	string		每项中用于查找对象属性的字符串键。
compare	function	可选的	可选比较函数，用来检验当前项与源中的前一项是否相同。

elementAt

public elementAt(index: number, defaultValue: T): Observable

elementAt 返回的 Observable 会发出源 Observable 指定 index 处的项，如果 index 超出范围并且提供了 default 参数的话，会发出一个默认值。如果没有提供 default 参数并且 index 超出范围，那么输出 Observable 会发出一个 ArgumentOutOfRangeError 错误。

filter

public filter(predicate: function(value: T, index: number): boolean, thisArg: any): Observable

类似于 Array.prototype.filter()， 它只会发出源 Observable 中符合标准函数的值

名称	类型	属性	描述
predicate	function(value: T, index: number): boolean		评估源 Observable 所发出的每个值的函数。如果它返回 true，就发出值，如果是 false 则不会传给输出 Observable 。index 参数是自订阅开始后发送序列的索引，是从 0 开始的。
thisArg	any	可选的	可选参数，用来决定 predicate 函数中的 this 的值。

first

public first(predicate: function(value: T, index: number, source: Observable<T>): boolean, resultSelector: function(value: T, index: number): R, defaultValue: R): Observable<T | R>

如果不使用参数调用，first 会发出源 Observable 中的第一个值，然后完成。如果使用 predicate 函数来调用，first 会发出源 Observable 第一个满足条件的值。它还可以 接收 resultSelector 函数根据输入值生成输出值，假如在源 Observable 完成前无法发 出一个有效值的话，那么会发出 defaultValue 。如果没有提供 defaultValue 并且也 找不到匹配的元素，则抛出错误。

single

public single(predicate: Function): Observable<T>

该 Observable 发出源 Observable 所发出的值中匹配指定 predicate 函数的单个项

如果源 Observable 发出多于1个数据匹配项或者没有发出数据项, 分别以 IllegalArgumentException 和 NoSuchElementException 进行通知。

last

public last(predicate: function): Observable

返回的 Observable 只发出由源 Observable 发出的最后一个值。它可以接收一个可选的 predicate 函数作为 参数，如果传入 predicate 的话则发送的不是源 Observable 的最后一项，而是发出源 Observable 中 满足 predicate 函数的最后一项。

ignoreElements

public ignoreElements(): Observable

忽略源 Observable 所发送的所有项，只传递 complete 或 error 的调用

audit

public audit(durationSelector: function(value: T): SubscribableOrPromise): Observable<T>

audit 和 throttle 很像, 但是发出沉默时间窗口的最后一个值, 而不是第一个。

只要 audit 的内部时间器被禁用， 它就会在输出 Observable 上发出源 Observable 的最新值，并且当时间器启用时忽略源值。初始时, 时间器是禁用的。只要第一个源值到达, 时间器是用源值调用 durationselector 方法启用, 返回 "duration" Observable。 当 duration Observable 发出数据或者完成时，时间器禁用，然后输出 Observable 发出最新的源值，并且不断的重复这个过程。

auditTime

public auditTime(duration: number, scheduler: Scheduler): Observable<T>

duration 毫秒内忽略源值，然后发出源 Observable 的最新值， 并且重复此过程

throttle

public throttle(durationSelector: function(value: T): SubscribableOrPromise, config: Object): Observable<T>

从源 Observable 中发出一个值，然后在由另一个 Observable 决定的期间内忽略 随后发出的源值，然后重复此过程

throttleTime

public throttleTime(duration: number, scheduler: Scheduler): Observable<T>

从源 Observable 中发出一个值，然后在 duration 毫秒内忽略随后发出的源值， 然后重复此过程

sample

public sample(notifier: Observable<any>): Observable<T>

另一个 notifier Observable发送时, 发出源 Observable 最新发出的值当

sampleTime

public sampleTime(period: number, scheduler: Scheduler): Observable<T>

在固定周期间隔内只发出源 Observable 发出的最新值

take

public take(count: number): Observable<T>

take 返回的 Observable 只发出源 Observable 最初发出的的N个值 (N = count)。 如果源发出值的数量小于 count 的话，那么它的所有值都将发出。然后它便完成，无论源 Observable 是否完成。

takeLast

public takeLast(count: number): Observable<T>

takeLast 返回的 Observable 只发出源 Observable 最后发出的的N个值 (N = count)。

如果源发出值的数量小于 count 的话，那么它的所有值都将发出。此操作符必须等待 源 Observable 的 complete 通知发送才能在输出 Observable 上发出 next 值， 因为不这样的话它无法知道源 Observable 上是否还有更多值要发出。

出于这个原因， 所有值都将同步发出，然后是 complete 通知。

takeUntil

public takeUntil(notifier: Observable): Observable<T>

发出源 Observable 发出的值，直到 notifier Observable 发出值

takeWhile

public takeWhile(predicate: function(value: T, index: number): boolean): Observable<T>

发出在源 Observable 中满足 predicate 函数的每个值，并且一旦出现不满足 predicate 的值就立即完成

skip

public skip(count: Number): Observable

和take相反

skipLast

public skipLast(count: number): Observable<T>

和takeLast相反

skipLast 返回一个 Observable，该 Observable 累积足够长的队列以存储最初的N个值 (N = count)。 当接收到更多值时，将从队列的前面取值并在结果序列上产生。 这种情况下值会被延时。

skipUntil

public skipUntil(notifier: Observable): Observable<T>

和takeUntil相反

skipWhile

public skipWhile(predicate: Function): Observable<T>

和takeWhile相反

 

转载于:https://my.oschina.net/u/3412211/blog/1606681