Question

我希望通过一系列异步/网络操作（远程HTTP请求）来处理对象数组。

在某些操作中，我想确保不会同时处理超过X个项目。

我怎样才能做到这一点？

示例代码：

function someAsyncOp(item) {...} // returns a promise

var source = Rx.Observable.from([{item1},{item2},...])
source
  .flatMap((item) => {

    // I WANT THE FOLLOWING OPERATION TO BE EXECUTING  
    // ON AT MAX 10 ITEMS AT A TIME, NEXT ITEM SHOULD
    // BE SUBMITTED ONLY WHEN A SLOT GETS FREED AS A 
    // RESULT OF THE PROMISE SUCCEEDING OR FAILING

    return Rx.Observable.fromPromise(someAsyncOp(item))

  })
  .subscribe(
    console.log, 
    console.error, 
    () => console.log('completed')
  )

Answer 1

有一个名为flatMap的{{1}}兄弟带有一个并发参数。它的功能类似于本杰明的回答所提出的flatMapWithMaxConcurrent。

map(fn).merge(n)

Answer 2

您可以merge使用map代替flatMap：

var concurrency = 10;
source.map(someAsyncOp).merge(concurrency).subscribe(x => console.log(x));

请注意，由于承诺是渴望的，而且可观察性是懒惰的，因此不会削减它（并且Rx可以在没有它的情况下同化承诺）。我建议将其包装在create。

中

＆＃13;

var delay = function(ms){ return new Promise(function(r){ setTimeout(r, 2000, ms) }); }

var log = function(msg){ document.body.innerHTML += msg + "<br />"; }

Rx.Observable.range(1000, 10).map(delay).merge(2).subscribe(log)

＆＃13;

<script src="https://cdnjs.cloudflare.com/ajax/libs/rxjs/4.0.7/rx.all.js"></script>

＆＃13;

Rx.js与promises的并发性

2 个答案: