递归Promise.all？

Question

我正在等待一堆诺言完成。 我知道我可以使用Promise.all来做到这Promise.all ，但是当这些承诺之一将新的承诺推入承诺列表时，我不知道该怎么办。

例：

asyncFunction(...).then(result => {
    // do something
});


asyncFunction(...).then(result => {
    for(let row of result) {
        asyncFunction(row);
    }
});


console.log(promises.length); // 2
await Promise.all(promises);
console.log(promises.length); // 5

其中asyncFunction类似于：

const asyncFunction = (...args) => {
    let result = new Promise((resolve, reject) => {
        pool.query(...args, (err, rows, fields) => {
            if (err) {
                reject(err);
            } else {
                resolve(rows); 
            }
        });
    });
    promises.push(result);
    return result;
};

这里有什么情况是，前两个电话给asyncFunction推承诺变成我的promises数组，所以promises.length是2。然而，等待他们完成后，二日一推了一堆新的承诺转化为后面的阵列Promise.all已经评估了该数组，因此不等待它们。

那么，我怎样才能等待所有的承诺，再加上任何新的承诺？ 在此示例中，只需简单地两次调用await Promise.all(promises) ，但这可以无限进行。

Answer 1

您可以编写一个递归所有函数，在每次迭代后重新评估列表的状态：

function recursiveAll( array ) {
    // Wait for the promises to resolve
    return Promise.all( array ).then(function( result ) {
        // If no new promises were added, return the result
        if ( result.length == array.length )
            return result;
        // If new promises were added, re-evaluate the array.
        return recursiveAll( array );
    });
}

Answer 2

这就是具有副作用的函数的问题。

您的代码有点抽象，可以给您一个精确的答案，但是我建议您完全放弃promises -Array。

const asyncFunction = (...args) => {
    return new Promise((resolve, reject) => {
        pool.query(...args, (err, rows, fields) => {
            if (err) {
                reject(err);
            } else {
                resolve(rows); 
            }
        });
    });
}

和

asyncFunction(...).then(result => Promise.all(result.map(row => asyncFunction(row))) );

据我了解，您的意图是，这将导致Arrays中的Arrays嵌套结构，在最坏的情况下，现在只需要展平即可获得ALL值，而这些值是由先前的值触发的。

Answer 3

我认为，仅Promise.all替换Promise.all应该可以正常工作：

while(promises.length) {
    await promises.shift();
}