RxJS forkJoin

接受 Array of ObservableInput 或 of 的字典 Object，ObservableInput 并返回，Observable 其發(fā)出與傳遞的數(shù)組完全相同的順序的值數(shù)組或與傳遞的字典具有相同形狀的值的字典。

forkJoin(...sources: any[]): Observable<any>

參量

returns

Observable<any>：可觀察對象發(fā)出由傳遞的可觀察對象發(fā)出的最后一個值的數(shù)組或項目函數(shù)中的值。

描述

等待 Observable 完成，然后合并它們發(fā)出的最后一個值。

forkJoin 是一個運算符，它接受任意數(shù)量的輸入可觀察值，這些輸入可觀察值可以作為輸入可觀察值的數(shù)組或字典傳遞。如果沒有提供可觀察的輸入，則結果流將立即完成。

forkJoin 將等待所有傳遞的可觀察變量完成，然后它將發(fā)出一個數(shù)組或一個對象，該數(shù)組或對象具有來自相應可觀察變量的最后一個值。

如果將 n 可觀察 n 變量數(shù)組傳遞給運算符，則結果數(shù)組將具有值，其中第一個值是第一個可觀察變量發(fā)出的最后一個值，第二個值是第二個可觀察變量發(fā)出的最后一個值，依此類推。

如果將可觀察性字典傳遞給操作員，則生成的對象將具有與傳遞的字典相同的鍵，并且它們發(fā)出的最后值位于相應的鍵處。

這意味著 forkJoin 發(fā)射不會超過一次，并且將在此之后完成。如果您不僅需要在傳遞的可觀察變量的生命周期結束時發(fā)出組合值，還需要在整個過程中發(fā)出組合值，請嘗試一下 combineLatest 或 zip 改為嘗試。

為了使所得數(shù)組的長度與輸入可觀察數(shù)的長度相同，每當任何一個可觀察項完成而沒有發(fā)出任何值時，forkJoin該時刻也將完成，并且即使已經有一些最后一個也不會發(fā)出任何東西其他觀測值的值。相反，如果存在一個永不完備的可觀察物，那么也 forkJoin 將永遠也不會完成，除非在任何時候任何其他可觀察的完備物都沒有產生價值，這使我們回到了前面的情況?？偟膩碚f，為了 forkJoin 發(fā)出一個值，作為參數(shù)傳遞的所有可觀察對象必須發(fā)出至少一次且完整的東西。

如果在某個點有任何輸入的可觀察錯誤，那么 forkJoin 也會發(fā)生錯誤，所有其他可觀察變量將立即取消訂閱。

（可選）forkJoin 接受項目函數(shù)，該函數(shù)將使用通常會位于發(fā)射數(shù)組中的值來調用。無論項目功能返回什么，它將顯示在可觀察的輸出中。這意味著可以將默認項目視為具有所有自變量并將其放入數(shù)組的函數(shù)。請注意，僅當假定可觀察的輸出會發(fā)出結果時，才調用項目函數(shù)。

例子

將 forkJoin 與可觀察輸入的字典一起使用

import { forkJoin, of, timer } from 'rxjs';


const observable = forkJoin({
  foo: of(1, 2, 3, 4),
  bar: Promise.resolve(8),
  baz: timer(4000),
});
observable.subscribe({
 next: value => console.log(value),
 complete: () => console.log('This is how it ends!'),
});


// Logs:
// { foo: 4, bar: 8, baz: 0 } after 4 seconds
// "This is how it ends!" immediately after

將 forkJoin 與可觀察輸入數(shù)組結合使用

import { forkJoin, of } from 'rxjs';


const observable = forkJoin([
  of(1, 2, 3, 4),
  Promise.resolve(8),
  timer(4000),
]);
observable.subscribe({
 next: value => console.log(value),
 complete: () => console.log('This is how it ends!'),
});


// Logs:
// [4, 8, 0] after 4 seconds
// "This is how it ends!" immediately after

超載

forkJoin(v1: SubscribableOrPromise<T>): Observable<[T]>

returnsObservable<[T]>

forkJoin(v1: any, v2: any): Observable<[T, T2]>

returnsObservable<[T, T2]>

forkJoin(v1: any, v2: any, v3: any): Observable<[T, T2, T3]>

returnsObservable<[T, T2, T3]>

forkJoin(v1: any, v2: any, v3: any, v4: any): Observable<[T, T2, T3, T4]>

returnsObservable<[T, T2, T3, T4]>

forkJoin(v1: any, v2: any, v3: any, v4: any, v5: any): Observable<[T, T2, T3, T4, T5]>

returnsObservable<[T, T2, T3, T4, T5]>

forkJoin(v1: any, v2: any, v3: any, v4: any, v5: any, v6: any): Observable<[T, T2, T3, T4, T5, T6]>

returnsObservable<[T, T2, T3, T4, T5, T6]>

forkJoin(sources: [any]): Observable<[A]>

returnsObservable<[A]>

forkJoin(sources: [any, any]): Observable<[A, B]>

returnsObservable<[A, B]>

forkJoin(sources: [any, any, any]): Observable<[A, B, C]>

returnsObservable<[A, B, C]>

forkJoin(sources: [any, any, any, any]): Observable<[A, B, C, D]>

returnsObservable<[A, B, C, D]>

forkJoin(sources: [any, any, any, any, any]): Observable<[A, B, C, D, E]>

returnsObservable<[A, B, C, D, E]>

forkJoin(sources: [any, any, any, any, any, any]): Observable<[A, B, C, D, E, F]>

returnsObservable<[A, B, C, D, E, F]>

forkJoin(sources: A): Observable<ObservedValuesFromArray<A>[]>

forkJoin(sourcesObject: {}): Observable<never>

returnsObservable<never>

forkJoin(sourcesObject: T): Observable<{ [K in keyof T]: ObservedValueOf<T[K]>; }>

returnsObservable<{ [K in keyof T]: ObservedValueOf<T[K]>; }>

forkJoin(...args: any[]): Observable<any>

returnsObservable<any>

forkJoin(...sources: any[]): Observable<T[]>

也可以看看

• combineLatest
• zip