接受 Array of ObservableInput 或 of 的字典 Object，ObservableInput 并返回，Observable 其发出与传递的数组完全相同的顺序的值数组或与传递的字典具有相同形状的值的字典。

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

参量

returns

Observable<any>：可观察对象发出由传递的可观察对象发出的最后一个值的数组或项目函数中的值。

描述

等待 Observable 完成，然后合并它们发出的最后一个值。

forkJoin 是一个运算符，它接受任意数量的输入可观察值，这些输入可观察值可以作为输入可观察值的数组或字典传递。如果没有提供可观察的输入，则结果流将立即完成。

forkJoin 将等待所有传递的可观察变量完成，然后它将发出一个数组或一个对象，该数组或对象具有来自相应可观察变量的最后一个值。

如果将 n 可观察 n 变量数组传递给运算符，则结果数组将具有值，其中第一个值是第一个可观察变量发出的最后一个值，第二个值是第二个可观察变量发出的最后一个值，依此类推。

如果将可观察性字典传递给操作员，则生成的对象将具有与传递的字典相同的键，并且它们发出的最后值位于相应的键处。

这意味着 forkJoin 发射不会超过一次，并且将在此之后完成。如果您不仅需要在传递的可观察变量的生命周期结束时发出组合值，还需要在整个过程中发出组合值，请尝试一下 combineLatest 或 zip 改为尝试。

为了使所得数组的长度与输入可观察数的长度相同，每当任何一个可观察项完成而没有发出任何值时，forkJoin该时刻也将完成，并且即使已经有一些最后一个也不会发出任何东西其他观测值的值。相反，如果存在一个永不完备的可观察物，那么也 forkJoin 将永远也不会完成，除非在任何时候任何其他可观察的完备物都没有产生价值，这使我们回到了前面的情况。总的来说，为了 forkJoin 发出一个值，作为参数传递的所有可观察对象必须发出至少一次且完整的东西。

如果在某个点有任何输入的可观察错误，那么 forkJoin 也会发生错误，所有其他可观察变量将立即取消订阅。

（可选）forkJoin 接受项目函数，该函数将使用通常会位于发射数组中的值来调用。无论项目功能返回什么，它将显示在可观察的输出中。这意味着可以将默认项目视为具有所有自变量并将其放入数组的函数。请注意，仅当假定可观察的输出会发出结果时，才调用项目函数。

例子

将 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 与可观察输入数组结合使用

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