Javascript 在具有节点请求的循环中等待所有已完成的请求

我使用node请求ajax包。所以，我有一个循环，在每次迭代中它都向我的服务器发出请求

// realItems needs the complete value of items assigned
var realItems;

var items = [];
_.forEach(JSON.parse(body), (value, key) => {
  request('myurl/' + id, (error, response, body) => {
    items = JSON.parse(body)
  });
});

如何绑定来自

request

包的所有请求，以便在末尾将

items

变量的值分配给

realtimes

//编辑：

---

我使用react js，因此在本例中，

realtimes

是一种状态，我不能在每次循环迭代中触发它，因为在每个

setState

上都会触发render，有很多方法可以实现这一点。以下是一种不保留结果顺序的暴力方法：

var items = [];
var cnt = 0;
_.forEach(JSON.parse(body), (value, key) => {
  ++cnt;
  request('myurl/' + value.id, (error, response, body) => {
    items.push(JSON.parse(body));
    // if all requesets are done
    if (--cnt === 0) {
        // process items here as all results are done now
    }
  });
});

---

以下是一个使用蓝鸟承诺的版本：

var Promise = require('bluebird');
var request = Promise.promisify(require("request"));
Promise.promisifyAll(request);

var promises = [];
_.forEach(JSON.parse(body), (value, key) => {
    promises.push(request('myurl/' + value.id));
});
Promise.all(promises).then(function(results) {
    // all requests are done, data from all requests is in the results array
    // and are in the order that the requests were originally made
});

还有一个更简单的Bluebird promises方法，它使用Bluebird迭代器：

var Promise = require('bluebird');
var request = Promise.promisify(require("request"));
Promise.promisifyAll(request);

Promise.map(JSON.parse(body), function(value) {
    return request('myurl/' + value.id);
}).then(function(results) {
    // all requests are done, data is in the results array
});

---

有很多方法可以做到这一点。以下是一种不保留结果顺序的暴力方法：

var items = [];
var cnt = 0;
_.forEach(JSON.parse(body), (value, key) => {
  ++cnt;
  request('myurl/' + value.id, (error, response, body) => {
    items.push(JSON.parse(body));
    // if all requesets are done
    if (--cnt === 0) {
        // process items here as all results are done now
    }
  });
});

---

以下是一个使用蓝鸟承诺的版本：

var Promise = require('bluebird');
var request = Promise.promisify(require("request"));
Promise.promisifyAll(request);

var promises = [];
_.forEach(JSON.parse(body), (value, key) => {
    promises.push(request('myurl/' + value.id));
});
Promise.all(promises).then(function(results) {
    // all requests are done, data from all requests is in the results array
    // and are in the order that the requests were originally made
});

还有一个更简单的Bluebird promises方法，它使用Bluebird迭代器：

var Promise = require('bluebird');
var request = Promise.promisify(require("request"));
Promise.promisifyAll(request);

Promise.map(JSON.parse(body), function(value) {
    return request('myurl/' + value.id);
}).then(function(results) {
    // all requests are done, data is in the results array
});

---

有很多方法可以做到这一点。以下是一种不保留结果顺序的暴力方法：

var items = [];
var cnt = 0;
_.forEach(JSON.parse(body), (value, key) => {
  ++cnt;
  request('myurl/' + value.id, (error, response, body) => {
    items.push(JSON.parse(body));
    // if all requesets are done
    if (--cnt === 0) {
        // process items here as all results are done now
    }
  });
});

---

以下是一个使用蓝鸟承诺的版本：

var Promise = require('bluebird');
var request = Promise.promisify(require("request"));
Promise.promisifyAll(request);

var promises = [];
_.forEach(JSON.parse(body), (value, key) => {
    promises.push(request('myurl/' + value.id));
});
Promise.all(promises).then(function(results) {
    // all requests are done, data from all requests is in the results array
    // and are in the order that the requests were originally made
});

还有一个更简单的Bluebird promises方法，它使用Bluebird迭代器：

var Promise = require('bluebird');
var request = Promise.promisify(require("request"));
Promise.promisifyAll(request);

Promise.map(JSON.parse(body), function(value) {
    return request('myurl/' + value.id);
}).then(function(results) {
    // all requests are done, data is in the results array
});

---

有很多方法可以做到这一点。以下是一种不保留结果顺序的暴力方法：

var items = [];
var cnt = 0;
_.forEach(JSON.parse(body), (value, key) => {
  ++cnt;
  request('myurl/' + value.id, (error, response, body) => {
    items.push(JSON.parse(body));
    // if all requesets are done
    if (--cnt === 0) {
        // process items here as all results are done now
    }
  });
});

---

以下是一个使用蓝鸟承诺的版本：

var Promise = require('bluebird');
var request = Promise.promisify(require("request"));
Promise.promisifyAll(request);

var promises = [];
_.forEach(JSON.parse(body), (value, key) => {
    promises.push(request('myurl/' + value.id));
});
Promise.all(promises).then(function(results) {
    // all requests are done, data from all requests is in the results array
    // and are in the order that the requests were originally made
});

还有一个更简单的Bluebird promises方法，它使用Bluebird迭代器：

var Promise = require('bluebird');
var request = Promise.promisify(require("request"));
Promise.promisifyAll(request);

Promise.map(JSON.parse(body), function(value) {
    return request('myurl/' + value.id);
}).then(function(results) {
    // all requests are done, data is in the results array
});

---

是否要求您使用

请求

包？我使用了类似的

async

，并附带了一个

parallel

方法，它可以完全满足您的要求-

例如：

async.parallel([
  function(callback){
    setTimeout(function(){
        callback(null, 'one');
    }, 200);
  },
  function(callback){
    setTimeout(function(){
        callback(null, 'two');
    }, 100);
  }
],
// optional callback
function(err, results){
    // the results array will equal ['one','two'] even though
    // the second function had a shorter timeout.
});

---

是否要求您使用

请求

包？我使用了类似的

async

，并附带了一个

parallel

方法，它可以完全满足您的要求-

例如：

async.parallel([
  function(callback){
    setTimeout(function(){
        callback(null, 'one');
    }, 200);
  },
  function(callback){
    setTimeout(function(){
        callback(null, 'two');
    }, 100);
  }
],
// optional callback
function(err, results){
    // the results array will equal ['one','two'] even though
    // the second function had a shorter timeout.
});

---

是否要求您使用

请求

包？我使用了类似的

async

，并附带了一个

parallel

方法，它可以完全满足您的要求-

例如：

async.parallel([
  function(callback){
    setTimeout(function(){
        callback(null, 'one');
    }, 200);
  },
  function(callback){
    setTimeout(function(){
        callback(null, 'two');
    }, 100);
  }
],
// optional callback
function(err, results){
    // the results array will equal ['one','two'] even though
    // the second function had a shorter timeout.
});

---

是否要求您使用

请求

包？我使用了类似的

async

，并附带了一个

parallel

方法，它可以完全满足您的要求-

例如：

async.parallel([
  function(callback){
    setTimeout(function(){
        callback(null, 'one');
    }, 200);
  },
  function(callback){
    setTimeout(function(){
        callback(null, 'two');
    }, 100);
  }
],
// optional callback
function(err, results){
    // the results array will equal ['one','two'] even though
    // the second function had a shorter timeout.
});

---

---

JSON.parse（body）

的结果是什么？为什么在

request（）

调用中不使用它的任何内容？JSON.parse（body）的结果是什么？为什么在

request（）

调用中不使用它的任何内容？JSON.parse（body）的结果是什么为什么在

请求（）调用中不使用它的任何内容呢？

JSON.parse（body）的结果是什么？为什么在

请求（）调用中不使用它的任何内容呢？

谢谢！有了柜台也许行得通，但我更喜欢更优雅的方式，比如承诺。很抱歉我的代码，它真的很简单。所以，JSON.parse（body）来自外部请求（它实际上只是一个包含3项的数组，所以我知道需要进行多少个循环）。

id

也来自

value

并且在我的code

value中。id

@nutzt-我添加了一个使用promises.mh的版本。我变成了

参考错误：未定义requestAsync

@nutzt-我更正了它

request（）

是一个有点奇怪的模块，因此您必须以不同的方式来说明它-我的错误。关于承诺问题的详细信息。谢谢！有了柜台也许行得通，但我更喜欢更优雅的方式，比如承诺。很抱歉我的代码，它真的很简单。所以，JSON.parse（body）来自外部请求（它实际上只是一个包含3项的数组，所以我知道需要进行多少个循环）。

id

也来自

value

并且在我的code

value中。id

@nutzt-我添加了一个使用promises.mh的版本。我变成了

参考错误：未定义requestAsync

@nutzt-我更正了它

request（）

是一个有点奇怪的模块，因此您必须以不同的方式来说明它-我的错误。关于承诺问题的详细信息。谢谢！有了柜台也许行得通，但我更喜欢更优雅的方式，比如承诺。很抱歉我的代码，它真的很简单。所以，JSON.parse（body）来自外部请求（它实际上只是一个包含3项的数组，所以我知道需要进行多少个循环）。

id

也来自

value

并且在我的code

value中。id

@nutzt-我添加了一个使用promises.mh的版本。我变成了

参考错误：未定义requestAsync

@nutzt-我更正了它

request（）

是一个有点奇怪的模块，因此您必须以不同的方式来说明它-我的错误。关于承诺问题的详细信息。谢谢！有了柜台也许行得通，但我更喜欢更优雅的方式，比如承诺。很抱歉我的代码，它真的很简单。所以，JSON.parse（body）来自外部请求（它实际上只是一个包含3项的数组，所以我知道需要进行多少个循环）。

id

也来自

value

并且在我的code

value中。id

@nutzt-我添加了一个使用promises.mh的版本。我变成了

参考错误：未定义requestAsync

@nutzt-我更正了它

request（）

是一个有点奇怪的模块，因此您必须以不同的方式来说明它-我的错误。关于承诺问题的细节。