Node.js Angular2 RxJS分叉连接替代方案

使用forkJoin时，所有项目（在本例中为HTTP请求）都会立即发送到服务器，然后作为数组发出：

let observable_array = [observable1, observable2, ...];

Observable.forkJoin(observable_array).subscribe(res => {
  console.log('Res: ', res);
}, err => {
  console.log('Err: ', err);
});

这对我来说是个问题，因为我使用的是单线程服务器（NodeJS）。如果

observable_array

包含10个HTTP请求，并且每个请求需要3秒钟才能完成，则在30秒钟内不能发出其他请求

我正在寻找一种方法来执行请求1，等待服务器的响应完成，然后执行请求2，然后等待响应，等等。使用这种方法意味着新请求不必等待30秒，服务器就可以执行

observable\u array

。。。他们最多只能等3秒钟

我提出了以下解决方案，但我相信知识更渊博的人有一个更优雅的解决方案

let observable_array = [observable1, observable2, ...];

var queue = function(t, ob) { // Needed to use var instead of let because of scoping...

  if (ob) {

    ob.subscribe(res => {
      console.log('Res: ', res);
      queue(t, observables.shift());
    }, err => {
      console.log('Err: ', err);
    });

  }

}

queue(this, observables.shift());

---

您可以使用您最喜欢的flatMap/mergeMap并添加一个并发参数。这将限制您正在服务的并发观察/请求的数量

//emit value every 1s
const source = Rx.Observable.interval(1000);

const example = source.mergeMap(
    //project
    val => Rx.Observable.interval(5000).take(2),
  //resultSelector
  (oVal, iVal, oIndex, iIndex) => [oIndex, oVal, iIndex, iVal],
  //concurrent
  2 
);
/*
        Output:
        [0, 0, 0, 0] <--1st inner observable
        [1, 1, 0, 0] <--2nd inner observable
        [0, 0, 1, 1] <--1st inner observable
        [1, 1, 1, 1] <--2nd inner observable
        [2, 2, 0, 0] <--3rd inner observable
        [3, 3, 0, 0] <--4th inner observable
*/
const subscribe = example.subscribe(val => console.log(val));

//每1s发出一次值
常数源=可观测的接收间隔（1000）；
const example=source.mergeMap(
//计划
val=>Rx.可观测间隔（5000）.取（2），
//结果选择器
（椭圆形，iVal，oIndex，iIndex）=>[oIndex，椭圆形，iIndex，iVal]，
//同时发生
2.
);
/*
输出：
[0,0,0,0]您可以使用您最喜欢的flatMap/mergeMap风格并添加一个并发参数。这将限制您正在服务的并发观察/请求的数量

//emit value every 1s
const source = Rx.Observable.interval(1000);

const example = source.mergeMap(
    //project
    val => Rx.Observable.interval(5000).take(2),
  //resultSelector
  (oVal, iVal, oIndex, iIndex) => [oIndex, oVal, iIndex, iVal],
  //concurrent
  2 
);
/*
        Output:
        [0, 0, 0, 0] <--1st inner observable
        [1, 1, 0, 0] <--2nd inner observable
        [0, 0, 1, 1] <--1st inner observable
        [1, 1, 1, 1] <--2nd inner observable
        [2, 2, 0, 0] <--3rd inner observable
        [3, 3, 0, 0] <--4th inner observable
*/
const subscribe = example.subscribe(val => console.log(val));

//每1s发出一次值
常数源=可观测的接收间隔（1000）；
const example=source.mergeMap(
//计划
val=>Rx.可观测间隔（5000）.取（2），
//结果选择器
（椭圆形，iVal，oIndex，iIndex）=>[oIndex，椭圆形，iIndex，iVal]，
//同时发生
2.
);
/*
输出：
[0,0,0,0]的可能重复我不确定他的问题是否相同-链接的“重复”不关心并发执行，OP关心的是并发执行-他只关心按顺序订阅结果。不同之处在于关注太多并发http请求…您应该在后端寻找解决方案，因为如果有人想溢出你的调用堆栈，这很容易…只需使用
concat
而不是
forkJoin
可能的重复，我不确定他的问题是否相同-链接的“重复”不关心并发执行，哪一位OP关心——他只关心按顺序订阅结果。不同之处在于关注太多的并发http请求…您应该在后端寻找解决方案，因为如果有人想溢出您的调用堆栈，这将很容易…只需使用
concat
而不是
forkJoin