[6a3a178] | 1 | import { Operator } from '../Operator';
|
---|
| 2 | import { Subscriber } from '../Subscriber';
|
---|
| 3 | import { Observable } from '../Observable';
|
---|
| 4 | import { OperatorFunction, MonoTypeOperatorFunction, TeardownLogic } from '../types';
|
---|
| 5 |
|
---|
| 6 | /* tslint:disable:max-line-length */
|
---|
| 7 | export function filter<T, S extends T>(predicate: (value: T, index: number) => value is S,
|
---|
| 8 | thisArg?: any): OperatorFunction<T, S>;
|
---|
| 9 | export function filter<T>(predicate: (value: T, index: number) => boolean,
|
---|
| 10 | thisArg?: any): MonoTypeOperatorFunction<T>;
|
---|
| 11 | /* tslint:enable:max-line-length */
|
---|
| 12 |
|
---|
| 13 | /**
|
---|
| 14 | * Filter items emitted by the source Observable by only emitting those that
|
---|
| 15 | * satisfy a specified predicate.
|
---|
| 16 | *
|
---|
| 17 | * <span class="informal">Like
|
---|
| 18 | * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),
|
---|
| 19 | * it only emits a value from the source if it passes a criterion function.</span>
|
---|
| 20 | *
|
---|
| 21 | * ![](filter.png)
|
---|
| 22 | *
|
---|
| 23 | * Similar to the well-known `Array.prototype.filter` method, this operator
|
---|
| 24 | * takes values from the source Observable, passes them through a `predicate`
|
---|
| 25 | * function and only emits those values that yielded `true`.
|
---|
| 26 | *
|
---|
| 27 | * ## Example
|
---|
| 28 | * Emit only click events whose target was a DIV element
|
---|
| 29 | * ```ts
|
---|
| 30 | * import { fromEvent } from 'rxjs';
|
---|
| 31 | * import { filter } from 'rxjs/operators';
|
---|
| 32 | *
|
---|
| 33 | * const clicks = fromEvent(document, 'click');
|
---|
| 34 | * const clicksOnDivs = clicks.pipe(filter(ev => ev.target.tagName === 'DIV'));
|
---|
| 35 | * clicksOnDivs.subscribe(x => console.log(x));
|
---|
| 36 | * ```
|
---|
| 37 | *
|
---|
| 38 | * @see {@link distinct}
|
---|
| 39 | * @see {@link distinctUntilChanged}
|
---|
| 40 | * @see {@link distinctUntilKeyChanged}
|
---|
| 41 | * @see {@link ignoreElements}
|
---|
| 42 | * @see {@link partition}
|
---|
| 43 | * @see {@link skip}
|
---|
| 44 | *
|
---|
| 45 | * @param {function(value: T, index: number): boolean} predicate A function that
|
---|
| 46 | * evaluates each value emitted by the source Observable. If it returns `true`,
|
---|
| 47 | * the value is emitted, if `false` the value is not passed to the output
|
---|
| 48 | * Observable. The `index` parameter is the number `i` for the i-th source
|
---|
| 49 | * emission that has happened since the subscription, starting from the number
|
---|
| 50 | * `0`.
|
---|
| 51 | * @param {any} [thisArg] An optional argument to determine the value of `this`
|
---|
| 52 | * in the `predicate` function.
|
---|
| 53 | * @return {Observable} An Observable of values from the source that were
|
---|
| 54 | * allowed by the `predicate` function.
|
---|
| 55 | * @method filter
|
---|
| 56 | * @owner Observable
|
---|
| 57 | */
|
---|
| 58 | export function filter<T>(predicate: (value: T, index: number) => boolean,
|
---|
| 59 | thisArg?: any): MonoTypeOperatorFunction<T> {
|
---|
| 60 | return function filterOperatorFunction(source: Observable<T>): Observable<T> {
|
---|
| 61 | return source.lift(new FilterOperator(predicate, thisArg));
|
---|
| 62 | };
|
---|
| 63 | }
|
---|
| 64 |
|
---|
| 65 | class FilterOperator<T> implements Operator<T, T> {
|
---|
| 66 | constructor(private predicate: (value: T, index: number) => boolean,
|
---|
| 67 | private thisArg?: any) {
|
---|
| 68 | }
|
---|
| 69 |
|
---|
| 70 | call(subscriber: Subscriber<T>, source: any): TeardownLogic {
|
---|
| 71 | return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));
|
---|
| 72 | }
|
---|
| 73 | }
|
---|
| 74 |
|
---|
| 75 | /**
|
---|
| 76 | * We need this JSDoc comment for affecting ESDoc.
|
---|
| 77 | * @ignore
|
---|
| 78 | * @extends {Ignored}
|
---|
| 79 | */
|
---|
| 80 | class FilterSubscriber<T> extends Subscriber<T> {
|
---|
| 81 |
|
---|
| 82 | count: number = 0;
|
---|
| 83 |
|
---|
| 84 | constructor(destination: Subscriber<T>,
|
---|
| 85 | private predicate: (value: T, index: number) => boolean,
|
---|
| 86 | private thisArg: any) {
|
---|
| 87 | super(destination);
|
---|
| 88 | }
|
---|
| 89 |
|
---|
| 90 | // the try catch block below is left specifically for
|
---|
| 91 | // optimization and perf reasons. a tryCatcher is not necessary here.
|
---|
| 92 | protected _next(value: T) {
|
---|
| 93 | let result: any;
|
---|
| 94 | try {
|
---|
| 95 | result = this.predicate.call(this.thisArg, value, this.count++);
|
---|
| 96 | } catch (err) {
|
---|
| 97 | this.destination.error(err);
|
---|
| 98 | return;
|
---|
| 99 | }
|
---|
| 100 | if (result) {
|
---|
| 101 | this.destination.next(value);
|
---|
| 102 | }
|
---|
| 103 | }
|
---|
| 104 | }
|
---|