將回調(diào) API 轉換為返回 Observable 的函數(shù)。

bindCallback<T>(callbackFunc: Function, resultSelector?:Function | SchedulerLike, scheduler?: SchedulerLike): (...args: any[]) =>Observable<T>

參量

returns

(...args: any[]) => Observable<T>：返回 Observable 的函數(shù)，該函數(shù)提供與回調(diào)傳遞的值相同的值。

描述

給它一個 f類型 f(x, callback)的函數(shù) g，它將返回一個函數(shù)，當調(diào)用 as 時 g(x)將輸出一個 Observable。

bindCallback 不是運算符，因為其輸入和輸出都不是可觀察的。輸入是 func 帶有某些參數(shù)的函數(shù)。最后一個參數(shù)必須 func 是完成后調(diào)用的回調(diào)函數(shù)。

輸出的 bindCallback 是 func 與最后一個參數(shù)（回調(diào)）相同的，與相同的參數(shù)的函數(shù)。使用參數(shù)調(diào)用輸出函數(shù)時，它將返回一個 Observable。如果函數(shù) func 使用一個參數(shù)調(diào)用其回調(diào)，則 Observable 將發(fā)出該值。另一方面，如果使用多個值調(diào)用回調(diào)，則產(chǎn)生的 Observable 將發(fā)出一個以所述值作為參數(shù)的數(shù)組。

這是非常重要的是要記住，輸入功能 func，當輸出功能是不叫，而是當由輸出函數(shù)返回的可觀測訂閱。這意味著，如果 func 發(fā)出 AJAX 請求，則每次有人訂閱生成的 Observable 時都會發(fā)出該請求，但不是之前。

最后一個可選參數(shù)-- scheduler可用于控制 func在有人訂閱 Observable 之后何時進行調(diào)用，以及何時傳遞傳遞給回調(diào)的結果。默認情況下，對 Observable 的預訂是 func 同步進行的，但是將其 async用作最后一個參數(shù)會將調(diào)用推遲到 func，就像將調(diào)用包裝成 will setTimeout超時0一樣。如果要使用異步調(diào)度程序并 subscribe在輸出 Observable 上調(diào)用，則當前正在執(zhí)行的所有函數(shù)調(diào)用將在 func調(diào)用之前結束。

默認情況下，傳遞給回調(diào)的結果在 func調(diào)用回調(diào)后立即發(fā)出。特別是，如果回調(diào)是同步調(diào)用的，則結果Observable 的訂閱也將 next 同步調(diào)用該函數(shù)。如果您想推遲該呼叫，則可以 async像以前一樣使用。這意味著通過使用 Scheduler.async 您可以確保 func 始終異步調(diào)用其回調(diào)，從而避免使 Zalgo 感到恐懼。

請注意，由輸出函數(shù)創(chuàng)建的 Observable 將始終發(fā)出單個值，然后立即完成。如果 func 多次調(diào)用回調(diào)，則后續(xù)調(diào)用中的值將不會出現(xiàn)在流中。如果您需要收聽多個呼叫，則可能要使用 fromEvent 或 fromEventPattern 代替。

如果 func 依賴于某些上下文（this屬性）并且尚未綁定，則的上下文 func 將是輸出函數(shù)在調(diào)用時具有的上下文。特別是，如果 if func 作為某些 objec 的方法被調(diào)用，并且 if func 尚未綁定，則為了保留上下文，建議將輸出函數(shù)的上下文也設置為該對象。

如果輸入函數(shù)以“節(jié)點樣式”調(diào)用其回調(diào)（即，回調(diào)的第一個參數(shù)是表示調(diào)用是否失敗的可選錯誤參數(shù)），bindNodeCallback 則將提供方便的錯誤處理，并且可能是更好的選擇。 bindCallback 會將此類函數(shù)與其他任何函數(shù)一樣對待，并且錯誤參數(shù)（無論是否傳遞）將始終被解釋為常規(guī)回調(diào)參數(shù)。

例子

將 jQuery 的 getJSON 轉換為可觀察的 API

import { bindCallback } from 'rxjs';
import * as jQuery from 'jquery';


// Suppose we have jQuery.getJSON('/my/url', callback)
const getJSONAsObservable = bindCallback(jQuery.getJSON);
const result = getJSONAsObservable('/my/url');
result.subscribe(x => console.log(x), e => console.error(e));

接收傳遞給回調(diào)的參數(shù)數(shù)組

import { bindCallback } from 'rxjs';


const someFunction = (a, b, c) => {
  console.log(a); // 5
  console.log(b); // 'some string'
  console.log(c); // {someProperty: 'someValue'}
};


const boundSomeFunction = bindCallback(someFunction);
boundSomeFunction().subscribe(values => {
  console.log(values) // [5, 'some string', {someProperty: 'someValue'}]
});

比較有無異步 Scheduler 的行為

import { bindCallback } from 'rxjs';


function iCallMyCallbackSynchronously(cb) {
  cb();
}


const boundSyncFn = bindCallback(iCallMyCallbackSynchronously);
const boundAsyncFn = bindCallback(iCallMyCallbackSynchronously, null, Rx.Scheduler.async);


boundSyncFn().subscribe(() => console.log('I was sync!'));
boundAsyncFn().subscribe(() => console.log('I was async!'));
console.log('This happened...');


// Logs:
// I was sync!
// This happened...
// I was async!

在對象方法上使用 bindCallback

content_copyopen_in_newimport { bindCallback } from 'rxjs'; const boundMethod = bindCallback(someObject.methodWithCallback); boundMethod.call(someObject) // make sure methodWithCallback has access to someObject .subscribe(subscriber);

超載

| bindCallback(callbackFunc: Function, resultSelector: Function, scheduler?: SchedulerLike): (...args: any[]) => Observable<any>

returns (...args: any[]) => Observable<any>

| bindCallback(callbackFunc: (callback: (res1: R1, res2: R2, res3: R3, res4: R4, ...args: any[]) => any) => any, scheduler?: SchedulerLike): () => Observable<any[]>

returns() => Observable<any[]>

bindCallback(callbackFunc: (callback: (res1: R1, res2: R2, res3: R3) => any) => any, scheduler?: SchedulerLike): () => Observable<[R1, R2, R3]>

returns() => Observable<[R1, R2, R3]> |

bindCallback(callbackFunc: (callback: (res1: R1, res2: R2) => any) => any, scheduler?: SchedulerLike): () => Observable<[R1, R2]>

returns() => Observable<[R1, R2]>

bindCallback(callbackFunc: (callback: (res1: R1) => any) => any, scheduler?: SchedulerLike): () => Observable<R1>

returns() => Observable<R1>

bindCallback(callbackFunc: (callback: () => any) => any, scheduler?: SchedulerLike): () => Observable<void>

returns() => Observable<void>

bindCallback(callbackFunc: (arg1: A1, callback: (res1: R1, res2: R2, res3: R3, res4: R4, ...args: any[]) => any) => any, scheduler?: SchedulerLike): (arg1: A1) => Observable<any[]>

returns(arg1: A1) => Observable<any[]>

bindCallback(callbackFunc: (arg1: A1, callback: (res1: R1, res2: R2, res3: R3) => any) => any, scheduler?: SchedulerLike): (arg1: A1) => Observable<[R1, R2, R3]>

returns(arg1: A1) => Observable<[R1, R2, R3]>

bindCallback(callbackFunc: (arg1: A1, callback: (res1: R1, res2: R2) => any) => any, scheduler?: SchedulerLike): (arg1: A1) => Observable<[R1, R2]>

returns(arg1: A1) => Observable<[R1, R2]>

bindCallback(callbackFunc: (arg1: A1, callback: (res1: R1) => any) => any, scheduler?: SchedulerLike): (arg1: A1) => Observable<R1>

returns(arg1: A1) => Observable<R1>

bindCallback(callbackFunc: (arg1: A1, callback: () => any) => any, scheduler?: SchedulerLike): (arg1: A1) => Observable<void>

returns(arg1: A1) => Observable<void>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, callback: (res1: R1, res2: R2, res3: R3, res4: R4, ...args: any[]) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2) => Observable<any[]>

returns(arg1: A1, arg2: A2) => Observable<any[]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, callback: (res1: R1, res2: R2, res3: R3) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2) => Observable<[R1, R2, R3]>

returns(arg1: A1, arg2: A2) => Observable<[R1, R2, R3]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, callback: (res1: R1, res2: R2) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2) => Observable<[R1, R2]>

returns(arg1: A1, arg2: A2) => Observable<[R1, R2]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, callback: (res1: R1) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2) => Observable<R1>

returns(arg1: A1, arg2: A2) => Observable<R1>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, callback: () => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2) => Observable<void>

returns(arg1: A1, arg2: A2) => Observable<void>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, callback: (res1: R1, res2: R2, res3: R3, res4: R4, ...args: any[]) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3) => Observable<any[]>

returns(arg1: A1, arg2: A2, arg3: A3) => Observable<any[]> | bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, callback: (res1: R1, res2: R2, res3: R3) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3) => Observable<[R1, R2, R3]>

returns(arg1: A1, arg2: A2, arg3: A3) => Observable<[R1, R2, R3]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, callback: (res1: R1, res2: R2) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3) => Observable<[R1, R2]>

returns(arg1: A1, arg2: A2, arg3: A3) => Observable<[R1, R2]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, callback: (res1: R1) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3) => Observable<R1>

returns(arg1: A1, arg2: A2, arg3: A3) => Observable<R1>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, callback: () => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3) => Observable<void>

returns(arg1: A1, arg2: A2, arg3: A3) => Observable<void>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, callback: (res1: R1, res2: R2, res3: R3, res4: R4, ...args: any[]) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Observable<any[]>

returns(arg1:A1, arg2: A2, arg3: A3, arg4: A4) => Observable<any[]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, callback: (res1: R1, res2: R2, res3: R3) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Observable<[R1, R2, R3]>

returns(arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Observable<[R1, R2, R3]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, callback: (res1: R1, res2: R2) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Observable<[R1, R2]>

returns(arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Observable<[R1, R2]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, callback: (res1: R1) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Observable<R1>

returns(arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Observable<R1>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, callback: () => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Observable<void>

returns(arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Observable<void>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, callback: (res1: R1, res2: R2, res3: R3, res4: R4, ...args: any[]) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<any[]>

returns(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<any[]> |

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, callback: (res1: R1, res2: R2, res3: R3) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<[R1, R2, R3]>

returns(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<[R1, R2, R3]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, callback: (res1: R1, res2: R2) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<[R1, R2]>

returns(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<[R1, R2]>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, callback: (res1: R1) => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<R1>

returns(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<R1>

bindCallback(callbackFunc: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, callback: () => any) => any, scheduler?: SchedulerLike): (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<void>

returns(arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Observable<void> |

bindCallback(callbackFunc: (...args: (A | ((result: R) => any))[]) => any, scheduler?: SchedulerLike): (...args: A[]) => Observable<R>

returns(...args: A[]) => Observable<R>

bindCallback(callbackFunc: (...args: (A | ((...results: R[]) => any))[]) => any, scheduler?: SchedulerLike): (...args: A[]) => Observable<R[]>

returns(...args: A[]) => Observable<R[]>

bindCallback(callbackFunc: Function, scheduler?: SchedulerLike): (...args: any[]) => Observable<any>

returns(...args: any[]) => Observable<any>

也可以看看

• bindNodeCallback
• from