对Observable 发出的值进行: 缓存(buffer)、映射(map)、扫描累计(scan)、抽取对象属性(pluck)、分离(partition、groupBy)、组合操作(map&concat、merge、switch和scan&merge)、递归扩展(expand)、窗口限制(window)
buffer
public buffer(closingNotifier: Observable<any>): Observable<T[]>
将 Observable 发出的值缓冲起来直到 closingNotifier 发出数据, 在这个时候在输出 Observable 上发出该缓冲区的值并且内部开启一个新的缓冲区, 等待下一个closingNotifier的发送
bufferCount
public bufferCount(bufferSize: number, startBufferEvery: number): Observable<T[]>
将过往的值收集到一个数组中,当数组数量到达设定的 bufferSize 时发出该数组
bufferTime
public bufferTime(bufferTimeSpan: number, bufferCreationInterval: number, maxBufferSize: number, scheduler: Scheduler): Observable<T[]>
将过往的值收集到数组中,并周期性地发出这些数组
名称 | 类型 | 属性 | 描述 |
bufferTimeSpan | | 填满每个缓冲数组的时间。 | |
bufferCreationInterval |
| 开启新缓冲区的时间间隔。 | |
maxBufferSize |
| 缓冲区的最大容量。 | |
scheduler |
| 调度器,调度缓冲区。 |
bufferToggle
public bufferToggle(openings: SubscribableOrPromise<O>, closingSelector: function(value: O): SubscribableOrPromise): Observable<T[]>
将过往数据收集到数组中. 当opening发送的时候开始收集, 然后调用closingSelector 函数获取 Observable ,该Observable 告知什么时候关闭缓冲。即源 Observable 发送的值输出有其他 Observable 控制。
bufferWhen
public bufferWhen(closingSelector: function(): Observable): Observable<T[]>
立马开启缓冲区, 然后当closingSelector函数返回的observable发出数据的时候关闭缓冲区. 当关闭缓冲区的时候, 会立马开启新的缓冲区,并不断重复此过程
scan
public scan(accumulator: function(acc: R, value: T, index: number): R, seed: T | R): Observable<R>
对源 Observable 使用累加器函数, 返回生成的中间值(返回的可以不是累加值), 累计值可初始化(seed)
accumulator | | 对每个源数据调用的累加器函数。 | |
seed | T | R | 可选的 | 初始值。 |
map
public map(project: function(value: T, index: number): R, thisArg: any): Observable<R>
操作符将 投射函数 应用于每个值并且在输出 Observable 中发出投射后的结果
thisArg | any | 可选的 | 可选参数,定义在 |
mapTo
public mapTo(value: any): Observable
将源 Observable 发出的所有值都映射为 同一值
pluck
public pluck(properties: ...string): Observable
将每个源值(对象)映射成它指定的嵌套属性
pairwise
public pairwise(): Observable<Array<T>>
将一系列连续的发送成对的组合在一起,并将这些分组作为两个值的数组发出
partition
public partition(predicate: function(value: T, index: number): boolean, thisArg: any): [Observable<T>, Observable<T>]
将源 Observable 根据条件函数返回数组Observable,[0]是所有满足 predicate 函数的值,[1]是所有 不满足 predicate 的值
groupBy
public groupBy(keySelector: function(value: T): K, elementSelector: function(value: T): R, durationSelector: function(grouped: GroupedObservable<K, R>): Observable<any>): Observable<GroupedObservable<K, R>>
根据指定条件将源 Observable 发出的值进行分组,并将这些分组作为 GroupedObservables 发出,每一个分组都是一个 GroupedObservable
concatMap
public concatMap(project: function(value: T, ?index: number): ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable
将每个值映射为 Observable, 然后使用 concatAll 将所有的内部 Observables 打平串行订阅
相当于 map 操作后进行 concatAll 操作
resultSelector | function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any |
| 函数,它用于产生基于值的输出 Observable 和源(外部)发送和内部 Observable 发送的索引。 传递给这个函数参数有:
|
concatMapTo
public concatMapTo(innerObservable: ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable
就像是concatMap, 但是将每个值总是映射为同一个内部 Observable
mapTo 操作符和 concatAll 合并后的效果, resultSelector 函数和 concatMap 中一样
exhaustMap
public exhaustMap(project: function(value: T, ?index: number): ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable
把每个值通过 map 映射成 Observable,然后使用 exhaust 操作符打平所有的内部 Observables
mergeMap
将每个值通过 map 映射成 Observable,然后使用 mergeAll(并行订阅) 打平所有的内部 Observables
mergeMapTo
public mergeMapTo(innerObservable: ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any, concurrent: number): Observable
将每个源值通过 mapTo 投射成同一个 Observable ,然后使用 mergeAll(并行订阅) 打平所有的内部 Observables
mergeScan
public mergeScan(accumulator: function(acc: R, value: T): Observable<R>, seed: *, concurrent: number): Observable<R>
在源 Observable 上应用 accumulator 函数,其中 accumulator 函数本身返回 Observable ,然后每个返回的中间 Observable 会被合并到输出 Observable 中
名称 | 类型 | 属性 | 描述 |
accumulator | function(acc: R, value: T): Observable<R> | | 在每个源值上调用的累加器函数。 |
seed | * | | 初始的累加值。 |
concurrent |
| 可以同时订阅的输入 Observables 的最大数量。 |
switchMap
public switchMap(project: function(value: T, ?index: number): ObservableInput, resultSelector: function(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): any): Observable
将每个值通过 map 映射成 Observable ,然后使用 switch 打平所有的内部 Observables
switchMapTo
将每个源值通过 mapTo 映射成同一个 Observable ,该 Observable 会使用 switch 多次被打平 到输出 Observable 中
window
public window(windowBoundaries: Observable<any>): Observable<Observable<T>>
返回的 Observable 发出从源 Observable 收集到的项的窗口。 输出 Observable 发出连接的,不重叠的 窗口. 当windowBoundaries
Observable 开始发出数据,它会发出目前的窗口并且会打开一个新的。 因为每个窗口都是 Observable, 所以输出 Observable 是高阶 Observable。
在每个窗口(窗口间的时间间隔为1秒)中,最多发出两次点击事件
var clicks = Rx.Observable.fromEvent(document, 'click');
var interval = Rx.Observable.interval(1000);
var result = clicks.window(interval)
.map(win => win.take(2)) // 每个窗口最多两个发送
.mergeAll(); // 打平高阶 Observable
result.subscribe(x => console.log(x));
windowCount
public windowCount(windowSize: number, startWindowEvery: number): Observable<Observable<T>>
将源 Observable 的值分支成多个嵌套的 Observable ,每个嵌套的 Observable 最多发出 windowSize 个值
windowToggle
public windowToggle(openings: Observable<O>, closingSelector: function(value: O): Observable): Observable<Observable<T>>
将源 Observable 的值分支成嵌套的 Observable,分支策略是以 openings 发出项为起始,以 closingSelector 发出为结束
windowWhen
public windowWhen(closingSelector: function(): Observable): Observable<Observable<T>>
将源 Observable 的值分支成嵌套的 Observable ,通过使用关闭 Observable 的工厂函数来决定何时开启新的窗口, 就像是 bufferWhen, 但是发出的是嵌套的 Observable 而不是数组