Javascript 节点js：等待100个请求完成

我有以下代码。它迭代一组id并对每个id发出请求。我想在所有请求完成后执行一些代码，比如100。如何做到这一点

function initRequest(url){
  request.get(topPostsUrl, function(err,response,body){
    if(err) throw err;
    handlePosts(body);
  })
}

function handlePosts(posts){
  var postsArray = JSON.parse(posts);
  for(var i=0; i < postsCount; i++){
      var targetUrl = itemUrl.replace("**id**", postsArray[i]);
      request.get(targetUrl, function(err,response,body){
        if(err) throw err;
        processOutput(body,i+1);
      })
    }
}

function calthisFunctionAfterAllRequests () {

}

函数初始化请求（url）{
get（topPostsUrl，函数（err，response，body）{
如果（错误）抛出错误；
手柄（本体）；
})
}
功能手柄（立柱）{
var postsArray=JSON.parse（posts）；
对于（变量i=0；i

这是抽象代码表示

function RequestAll() {

  for (var i = 1; i <= 100; i++) {
    initRequest();
  }
  // return a promise 
}


RequestAll.then(function() {
  //whatever you need to do
});

函数RequestAll（）{
对于（var i=1；i这是抽象代码表示

function RequestAll() {

  for (var i = 1; i <= 100; i++) {
    initRequest();
  }
  // return a promise 
}


RequestAll.then(function() {
  //whatever you need to do
});

函数RequestAll（）{
对于（var i=1；i一个简单的解决方案，它使用Promises（）和
Promise.all
（）函数等待所有请求

function initRequest(url){
  request.get(topPostsUrl, function(err,response,body){
    if(err) throw err;
    handlePosts(body).then(calthisFunctionAfterAllRequests);
  })
}
function doRequest(url) {
  return new Promise(function(resolve, reject) {
    request.get(url, function(err,response,body){
      if(err) return reject(err);
      return resolve(body);
    })
  })
}
function handlePosts(posts){
  var postsArray = JSON.parse(posts);
  var requests = [];
  for(var i=0; i < postsCount; i++) {
      var targetUrl = itemUrl.replace("**id**", postsArray[i]);
      requests.push(doRequest(targetUrl));
  }
  // here is magic
  return Promise.all(requests)
}

function calthisFunctionAfterAllRequests (requestsResult) {
    // results store in requestsResult array in same order they added
}

函数初始化请求（url）{
get（topPostsUrl，函数（err，response，body）{
如果（错误）抛出错误；
handlePosts（body）。然后（在所有请求之后计算此函数）；
})
}
函数doRequest（url）{
返回新承诺（功能（解决、拒绝）{
获取（url、函数（错误、响应、正文）{
如果（错误）返回拒绝（错误）；
返回解析（body）；
})
})
}
功能手柄（立柱）{
var postsArray=JSON.parse（posts）；
var请求=[]；
对于（变量i=0；i
一个简单的解决方案是使用Promises（）和
Promise.all
（）函数等待所有请求

function initRequest(url){
  request.get(topPostsUrl, function(err,response,body){
    if(err) throw err;
    handlePosts(body).then(calthisFunctionAfterAllRequests);
  })
}
function doRequest(url) {
  return new Promise(function(resolve, reject) {
    request.get(url, function(err,response,body){
      if(err) return reject(err);
      return resolve(body);
    })
  })
}
function handlePosts(posts){
  var postsArray = JSON.parse(posts);
  var requests = [];
  for(var i=0; i < postsCount; i++) {
      var targetUrl = itemUrl.replace("**id**", postsArray[i]);
      requests.push(doRequest(targetUrl));
  }
  // here is magic
  return Promise.all(requests)
}

function calthisFunctionAfterAllRequests (requestsResult) {
    // results store in requestsResult array in same order they added
}

函数初始化请求（url）{
get（topPostsUrl，函数（err，response，body）{
如果（错误）抛出错误；
handlePosts（body）。然后（在所有请求之后计算此函数）；
})
}
函数doRequest（url）{
返回新承诺（功能（解决、拒绝）{
获取（url、函数（错误、响应、正文）{
如果（错误）返回拒绝（错误）；
返回解析（body）；
})
})
}
功能手柄（立柱）{
var postsArray=JSON.parse（posts）；
var请求=[]；
对于（变量i=0；i

然后

var rp=require（'request-promise'）；
函数初始化请求（url）{
rp.get（topPostsUrl）
。然后（body=>{
扶手柱（主体）
})
.catch（错误=>{
失误
})
}
功能手柄（立柱）{
var postsArray=JSON.parse（posts）
var arrayRequests=[]
对于（变量i=0；i{
返回真值
})
.catch（错误=>{
失误
})
}
)
新承诺
.所有（阵列请求）
.然后（（）=>{
calthisFunctionAfterAllRequests（）
})
.catch（错误=>{
失误
})
}
}
函数calthisFunctionAfterAllRequests（）{
}

然后

var rp=require（'request-promise'）；
函数初始化请求（url）{
rp.get（topPostsUrl）
。然后（body=>{
扶手柱（主体）
})
.catch（错误=>{
失误
})
}
功能手柄（立柱）{
var postsArray=JSON.parse（posts）
var arrayRequests=[]
对于（变量i=0；i{
返回真值
})
.catch（错误=>{
失误
})
}
)
新承诺
.所有（阵列请求）
.然后（（）=>{
calthisFunctionAfterAllRequests（）
})
.catch（错误=>{
失误
})
}
}
函数calthisFunctionAfterAllRequests（）{
}
Promise有两个缺点：

如果任何承诺失败，它们都将失败（不调用处理成功请求的函数）

您的所有请求都会立即启动。如果您有一个包含100个URL的数组，那么您将发出100个请求，并可能使请求的目标不满意，或者锁定正在运行的计算机的网络流量

要解决第1点，您可以创建一个承诺数组，该数组将处理拒绝（失败）并返回
fail
对象。在处理结果时，您可以过滤掉失败的请求：

const doRequest = url => 
  new Promise(
    (resolve, reject) =>
      request.get(
        url, 
        (err,response,body) =>
          (err)
            ? reject(err)
            : resolve(body)
      )
  );
const Fail = function(reason){ this.reason = reason; }
const handlePosts = posts =>
  Promise.all(
    (JSON.parse(posts))
    .map(
      post => post.replace("**id**", post)
    )
    .map(
      url => doRequest(url)
      .then(
        resolve=>resolve
        ,reject => new Fail(reject) //do not fail all requests just because one failed
      )
    )
  )

doRequest(topPostsUrl)
.then(
  handlePosts
)
.then(
  // you can filter out failed request by: results.filter(r=>(r && r.constructor)!==Fail)
  // you can filter out succeeded request by: results.filter(r=>(r && r.constructor)===Fail)
  calthisFunctionAfterAllRequests
)

第2点可以通过活动请求的数量来处理：上面的代码如下所示：

const max5 = throttle(5)
const handlePosts = posts =>
  Promise.all(
    (JSON.parse(posts))
    .map(
      post => post.replace("**id**", post)
    )
    .map(
      url => max5(doRequest)(url)
      .then(
        resolve=>resolve
        ,reject => new Fail(reject) //do not fail all requests just because one failed
      )
    )
  )

Promise有两个缺点。全部：

如果任何承诺失败，它们都将失败（不调用处理成功请求的函数）

您的所有请求都会立即启动。如果您有一个包含100个URL的数组，那么您将发出100个请求，并可能使请求的目标不满意，或者锁定正在运行的计算机的网络流量

要解决第1点，您可以创建一个承诺数组，该数组将处理拒绝（失败）并返回
fail
对象。在处理结果时，您可以过滤掉失败的请求：

const doRequest = url => 
  new Promise(
    (resolve, reject) =>
      request.get(
        url, 
        (err,response,body) =>
          (err)
            ? reject(err)
            : resolve(body)
      )
  );
const Fail = function(reason){ this.reason = reason; }
const handlePosts = posts =>
  Promise.all(
    (JSON.parse(posts))
    .map(
      post => post.replace("**id**", post)
    )
    .map(
      url => doRequest(url)
      .then(
        resolve=>resolve
        ,reject => new Fail(reject) //do not fail all requests just because one failed
      )
    )
  )

doRequest(topPostsUrl)
.then(
  handlePosts
)
.then(
  // you can filter out failed request by: results.filter(r=>(r && r.constructor)!==Fail)
  // you can filter out succeeded request by: results.filter(r=>(r && r.constructor)===Fail)
  calthisFunctionAfterAllRequests
)

第2点可以通过活动请求的数量来处理：