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

Question

我把可观测的物体放入这样的阵列中。。。

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

我想要一个可观测的，当所有任务$完成时发出。请记住，在实践中，任务$没有已知数量的可观察对象。

我试过可观察。zip（任务$）。subscribe（），但如果只有一个任务，这似乎失败了，这让我相信ZIP需要偶数个元素才能按预期的方式工作。

我已经尝试了Observable.concat（任务$）。订阅（），但是Conconat运算符的结果似乎只是一个可观察的数组...例如，基本上与输入相同。你甚至不能订阅它。

在C语言中，这类似于任务。WhenAll（）。在ES6 promise中，它类似于promise。all（）。

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

Answer 1

// 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']);
  });
});

Answer 2

您可以使用zip。

组合多个观察值以创建一个观察值，其值按顺序根据每个输入观察值的值计算。

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操作符将订阅所有内部观察值，等待每个观察值发出一个值。一旦发生这种情况，将发出具有相应索引的所有值。这将一直持续到至少一个内部可观察对象完成为止。

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

如果您想组成一个在所有源观测值完成时发出的观测值，可以使用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); });