Rxjs--转换操做符

对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	number		填满每一个缓冲数组的时间。
bufferCreationInterval	number	可选的	开启新缓冲区的时间间隔。
maxBufferSize	number	可选的	缓冲区的最大容量。
scheduler	Scheduler	可选的 默认值: async	调度器，调度缓冲区。

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	function(acc: R, value: T, index: number): R		对每一个源数据调用的累加器函数。
seed	T | R	可选的	初始值。

map

public map(project: function(value: T, index: number): R, thisArg: any): Observable<R>

操做符将 投射函数 应用于每一个值而且在输出 Observable 中发出投射后的结果

thisArg

any

可选的

可选参数，定义在 project 函数中的 this 是什么。

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 发送的索引。 传递给这个函数参数有： outerValue: 来自源的值 innerValue: 来自投射的 Observable 的值 outerIndex: 来自源的值的 "index" innerIndex: 来自投射的 Observable 的值的 "index"

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	number	可选的 默认值: Number.POSITIVE_INFINITY	能够同时订阅的输入 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 而不是数组