Node JS中Promise.all和forEach的关系是什么?

内容来源于 Stack Overflow,并遵循CC BY-SA 3.0许可协议进行翻译与使用

  • 回答 (2)
  • 关注 (0)
  • 查看 (321)

我有一个像结构一样暴露异步方法的数组。async方法调用返回的数组结构,依次公开更多的异步方法。我正在创建另一个JSON对象来存储从此结构获得的值,因此我需要注意跟踪回调中的引用。

  1. 该模式应该是可重复的n层嵌套。
  2. 我需要使用promise.all或一些类似的技巧来确定何时解决封装例程。
  3. 并非每个元素都必然涉及进行异步调用。所以在一个嵌套promise.all中,我不能简单地根据索引对我的JSON数组元素进行赋值。不过,我确实需要在嵌套的forEach中使用promise.all等内容,以确保在解析封闭例程之前完成所有属性分配。

这里是一些部分代码 -

var jsonItems = [];

items.forEach(function(item){

  var jsonItem = {};
  jsonItem.name = item.name;
  item.getThings().then(function(things){
  // or Promise.all(allItemGetThingCalls, function(things){

    things.forEach(function(thing, index){

      jsonItems[index].thingName = thing.name;
      if(thing.type === 'file'){

        thing.getFile().then(function(file){ //or promise.all?

          jsonItems[index].filesize = file.getSize();
提问于
用户回答回答于

它有一些简单的规则很简单:

  • 每当你在a中创建一个承诺时then都要返回它 - 任何你不会返回的承诺都不会在外面等待。
  • 无论何时你创造多重承诺,.all它们 - 这样它就会等待所有的承诺,并且任何一个承诺都不会失败。
  • 每当你嵌套thens,你通常可以在中间返回 - then链通常是最多1层深。
  • 无论你什么时候执行IO,都应该有一个承诺 - 要么是承诺,要么应该使用承诺来表示完成。

还有一些提示:

  • .mapfor/push使用映射相比,使用映射更好 - 如果使用函数映射值,map可以简洁地表达逐个应用操作并汇总结果的概念。
  • 如果它是免费的,并发比顺序执行更好 - 最好是并发执行并等待它们,而Promise.all不是一个接一个地执行 - 每个都在下一个之前等待。
var items = [1, 2, 3, 4, 5];
var fn = function asyncMultiplyBy2(v){ // sample async action
    return new Promise(resolve => setTimeout(() => resolve(v * 2), 100));
};
// map over forEach since it returns

var actions = items.map(fn); // run the function over all items

// we now have a promises array and we want to wait for it

var results = Promise.all(actions); // pass array of promises

results.then(data => // or just .then(console.log)
    console.log(data) // [2, 4, 6, 8, 10]
);

// we can nest this of course, as I said, `then` chains:

var res2 = Promise.all([1, 2, 3, 4, 5].map(fn)).then(
    data => Promise.all(data.map(fn))
).then(function(data){
    // the next `then` is executed after the promise has returned from the previous
    // `then` fulfilled, in this case it's an aggregate promise because of 
    // the `.all` 
    return Promise.all(data.map(fn));
}).then(function(data){
    // just for good measure
    return Promise.all(data.map(fn));
});

// now to get the results:

res2.then(function(data){
    console.log(data); // [16, 32, 48, 64, 80]
});
用户回答回答于

这是一个使用reduce的简单示例。它连续运行,保持插入顺序,并且不需要bluebird。

/**
 * 
 * @param items An array of items.
 * @param fn A function that accepts an item from the array and returns a promise.
 * @returns {Promise}
 */
function forEachPromise(items, fn) {
    return items.reduce(function (promise, item) {
        return promise.then(function () {
            return fn(item);
        });
    }, Promise.resolve());
}

并像这样使用它:

var items = ['a', 'b', 'c'];

function logItem(item) {
    return new Promise((resolve, reject) => {
        process.nextTick(() => {
            console.log(item);
            resolve();
        })
    });
}

forEachPromise(items, logItem).then(() => {
    console.log('done');
});

我们发现将可选的上下文发送到循环是很有用的。上下文是可选的,并由所有迭代共享。

function forEachPromise(items, fn, context) {
    return items.reduce(function (promise, item) {
        return promise.then(function () {
            return fn(item, context);
        });
    }, Promise.resolve());
}

承诺功能如下所示:

function logItem(item, context) {
    return new Promise((resolve, reject) => {
        process.nextTick(() => {
            console.log(item);
            context.itemCount++;
            resolve();
        })
    });
}

扫码关注云+社区

领取腾讯云代金券