RxJS

操作符 Operators

public buffer(closingNotifier: Observable<any>): Observable<T[]>
public bufferCount(bufferSize: number, startBufferEvery: number): Observable<T[]>
public bufferTime(bufferTimeSpan: number, bufferCreationInterval: number, maxBufferSize: number, scheduler: Scheduler): Observable<T[]>
public bufferToggle(openings: SubscribableOrPromise<O>, closingSelector: function(value: O): SubscribableOrPromise): Observable<T[]>
public bufferWhen(closingSelector: function(): Observable): Observable<T[]>
public combineAll(project: function): Observable
public static combineLatest(observable1: Observable, observable2: Observable, project: function, scheduler: Scheduler): Observable
public concat(other: Observable, scheduler: Scheduler): Observable
public concatAll(): Observable
public concatMap(project: function(value: T, ?index: number): Observable, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable
public concatMapTo(innerObservable: Observable, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable
public count(predicate: function(value: T, i: number, source: Observable<T>): boolean): Observable
public debounce(durationSelector: function(value: T): Observable | Promise): Observable
public debounceTime(dueTime: number, scheduler: Scheduler): Observable
public defaultIfEmpty(defaultValue: any): Observable
public delay(delay: number | Date, scheduler: Scheduler): Observable
public delayWhen(delayDurationSelector: function(value: T): Observable, subscriptionDelay: Observable): Observable
public dematerialize(): Observable

distinctUntilChanged、do(logging)、every

public expand(project: function(value: T, index: number), concurrent: number, scheduler: Scheduler): Observable
public filter(predicate: function(value: T, index: number): boolean, thisArg: any): Observable
public first(predicate: function(value: T, index: number, source: Observable<T>): boolean, resultSelector: function(value: T, index: number): R, defaultValue: R): Observable<T | R>
public groupBy(keySelector: function(value: T): K, elementSelector: function(value: T): R, durationSelector: function(grouped: GroupedObservable<K, R>): Observable<any>): Observable<GroupedObservable<K, R>>
public ignoreElements(): Observable
public last(predicate: function): Observable

let: the whole observable

public map(project: Function, thisArg: any): Observable
public mapTo(value: any): Observable
public merge(other: Observable, concurrent: number, scheduler: Scheduler): Observable
public mergeMap(project: function(value: T, ?index: number): Observable, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any, concurrent: number): Observable
public partition(predicate: function(value: T, index: number): boolean, thisArg: any): [Observable<T>, Observable<T>]
public pluck(properties: …string): Observable
public publish(): *

public race(): Observable

public repeat(scheduler: Scheduler, count: number): Observable
public retry(number: number): Observable
public retryWhen(receives: notificationHandler, the: scheduler): Observable
public sample(notifier: Observable<any>): Observable<T>
public scan(accumulator: function(acc: R, value: T, index: number): R, seed: T | R): Observable<R>
public share(): Observable<T>
public single(a: Function): Observable<T>
public skip(the: Number): Observable
public skipUntil(the: Observable): Observable<T>
public skipWhile(predicate: Function): Observable<T>
public startWith(an: Values): Observable
public switchMap(project: function(value: T, ?index: number): Observable, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable
public window(windowBoundaries: Observable<any>): Observable<Observable<T>>
public windowCount(windowSize: number, startWindowEvery: number): Observable<Observable<T>>
public windowTime(windowTimeSpan: number, windowCreationInterval: number, scheduler: Scheduler): Observable<Observable<T>>
public windowToggle(openings: Observable<O>, closingSelector: function(value: O): Observable): Observable<Observable<T>>
public windowWhen(closingSelector: function(): Observable): Observable<Observable<T>>
public withLatestFrom(other: Observable, project: Function): Observable

public static zip(observables: *): Observable<R>

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