Question

我将观察者推入像这样的阵列......

var tasks$ = [];
tasks$.push(Observable.timer(1000));
tasks$.push(Observable.timer(3000));
tasks$.push(Observable.timer(10000));

我希望Observable在所有任务$完成后发出。请记住，在实践中，任务$没有已知数量的Observable。

我已经尝试了Observable.zip(tasks$).subscribe()但是，如果只有一项任务，这似乎失败了，并且让我相信ZIP需要偶数个元素才能按照我的方式工作期待。

我试过Observable.concat(tasks$).subscribe()但是concat运算符的结果似乎是一个可观察数组...例如与输入基本相同。你甚至无法打电话订阅。

在C＃中，这类似于Task.WhenAll()。在ES6中承诺它类似于Promise.all()。

我遇到了许多SO问题，但他们似乎都在等待已知数量的流（例如将它们映射到一起）。

Answer 1

如果要编写在所有源可观察对象完成时发出的可观察对象，可以使用forkJoin：

import { Observable } from 'rxjs/Observable';
import 'rxjs/add/observable/forkJoin';
import 'rxjs/add/operator/first';

var tasks$ = [];
tasks$.push(Observable.timer(1000).first());
tasks$.push(Observable.timer(3000).first());
tasks$.push(Observable.timer(10000).first());
Observable.forkJoin(...tasks$).subscribe(results => { console.log(results); });

Answer 2

您可以使用zip。

组合多个Observable来创建一个Observable，其值是根据其每个输入Observable的值按顺序计算的。

const obsvA = this._service.getObjA();
const obsvB = this._service.getObjB();
// or with array
// const obsvArray = [obsvA, obsvB];

const zip = Observable.zip(obsvA, obsvB);
// or with array
// const zip = Observable.zip(...obsvArray);
zip.subscribe(
  result => console.log(result), // result is an array with the responses [respA, respB]
);

要考虑的事项：

不需要是偶数个可观察对象。

zip视觉上

如here所述，

zip运算符将订阅所有内部可观察对象，等待每个内部观察对象发出值。一旦发生这种情况，将发出具有相应索引的所有值。这将一直持续到至少一个内部可观察的对象完成。

当一个可观察对象抛出一个错误（或什至两个都抛出错误）时，订阅都被关闭（onComplete完成时被调用），并带有一个onError方法，您只会得到第一个错误。

zip.subscribe(
  result => console.log(result), // result is an array with the responses [respA, respB]
  error => console.log(error), // will return the error message of the first observable that throws error and then finish it
  () => console.log ('completed after first error or if first observable finishes)
);

Answer 3

对我来说，sample是最佳解决方案。

const source = Observable.interval(500);
const example = source.sample(Observable.interval(2000));
const subscribe = example.subscribe(val => console.log('sample', val));

所以..只有当第二个（例子）发出时 - 你会看到第一个（源）的最后一个值。

在我的任务中，我等待表单验证和其他DOM事件。

Answer 4

// waits for all Observables no matter of success/fails each of them
// returns array of items
// each item represent even first value of Observable or it's error
export function waitAll(args: Observable<any>[]): Observable<any[]> {
  const final = new Subject<any[]>();
  const flags = new Array(args.length);
  const result = new Array(args.length);
  let total = args.length;
  for (let i = 0; i < args.length; i++) {
    flags[i] = false;
    args[i].subscribe(
      res => {
        console.info('waitAll ' + i + ' ok ', res);
        if (flags[i] === false) {
          flags[i] = true;
          result[i] = res;
          total--;
          if (total < 1) {
            final.next(result);
          }
        }
      },
      error => {
        console.error('waitAll ' + i + ' failed ', error);
        if (flags[i] === false) {
          flags[i] = true;
          result[i] = error;
          total--;
          if (total < 1) {
            final.next(result);
          }
        }
      }
    );
  }
  return final.asObservable();
}

单元测试：

describe('waitAll', () => {
  it('should wait for all observables', async () => {
    const o1 = new Subject();
    const o2 = new Subject();
    const o3 = new Subject();

    const o = waitAll([o1, o2, o3]);
    const res = {arr: []};
    o.subscribe(result => res.arr = result, err => res.arr = []);

    expect(res.arr).toEqual([]);
    o1.next('success1');
    expect(res.arr).toEqual([]);
    o2.error('failed2')
    expect(res.arr).toEqual([]);
    o3.next('success3')
    expect(res.arr).toEqual(['success1', 'failed2', 'success3']);

    o1.next('success1*');
    expect(res.arr).toEqual(['success1', 'failed2', 'success3']);
    o2.error('failed2*')
    expect(res.arr).toEqual(['success1', 'failed2', 'success3']);
    o3.next('success3*')
    expect(res.arr).toEqual(['success1', 'failed2', 'success3']);
  });
});

RXJS等待数组中的所有可观察对象完成（或错误）

4 个答案: