Question

我有一个类似于数组的数组，它公开了异步方法。 async方法调用返回数组结构，进而显示更多异步方法。我正在创建另一个JSON对象来存储从这个结构中获取的值，因此我需要注意跟踪回调中的引用。

我编写了一个强力解决方案，但我想学习一个更惯用或更干净的解决方案。

对于n级嵌套，模式应该是可重复的。
我需要使用promise.all或类似技术来确定何时解决封闭例程。
并非每个元素都必然涉及进行异步调用。所以在嵌套的promise.all中我不能简单地根据索引对我的JSON数组元素进行赋值。不过，我确实需要在嵌套的forEach中使用promise.all之类的东西，以确保在解析封闭例程之前已经完成了所有的属性赋值。
我正在使用bluebird promise lib，但这不是必需的

这是一些部分代码 -

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();

Answer 1

使用一些简单的规则非常简单：

每当您在then中创建承诺时，请将其退回 - 任何您不会返回的承诺都不会在外面等待。
每当您创建多个承诺时，.all他们 - 这样就会等待所有承诺，并且任何承诺都不会出现任何错误。
每当您嵌套then时，您通常可以在中间返回 - then链通常最多只有1级。
每当你执行IO时，它应该是一个承诺 - 它应该在一个承诺中，或者它应该使用一个承诺来表示它的完成。

还有一些提示：

使用.map比使用for/push 更好地进行映射 - 如果您使用函数映射值，map可让您简明扼要地表达逐一实施行动并汇总结果的概念。
并发性优于顺序执行，如果它是免费的 - 同时执行并等待它们Promise.all比在{1}之后执行事情更好其他 - 每个人在下一个之前等待。

好的，让我们开始吧：

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]
});

Answer 2

这是一个使用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();
        })
    });
}

Answer 3

我遇到了同样的情况。我解决了使用两个Promise.All（）。

我认为这是非常好的解决方案，所以我在npm发布了它：https://www.npmjs.com/package/promise-foreach

我认为您的代码将是这样的

var promiseForeach = require('promise-foreach')
var jsonItems = [];
promiseForeach.each(jsonItems,
    [function (jsonItems){
        return new Promise(function(resolve, reject){
            if(jsonItems.type === 'file'){
                jsonItems.getFile().then(function(file){ //or promise.all?
                    resolve(file.getSize())
                })
            }
        })
    }],
    function (result, current) {
        return {
            type: current.type,
            size: jsonItems.result[0]
        }
    },
    function (err, newList) {
        if (err) {
            console.error(err)
            return;
        }
        console.log('new jsonItems : ', newList)
    })

Answer 4

仅需添加到提供的解决方案中，就我而言，我想从Firebase获取多个数据以获取产品列表。这是我的操作方式：

useEffect(() => {
  const fn = p => firebase.firestore().doc(`products/${p.id}`).get();
  const actions = data.occasion.products.map(fn);
  const results = Promise.all(actions);
  results.then(data => {
    const newProducts = [];
    data.forEach(p => {
      newProducts.push({ id: p.id, ...p.data() });
    });
    setProducts(newProducts);
  });
}, [data]);

节点JS Promise.all和forEach

4 个答案: