Rxjs--过滤操做符

防抖动(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相反