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 而不是數組