如何推送到Promise.all（Array）

Question

I don't think this is possible with the native promise implementation, but here's the basic idea of what I want:

const promises = [
    getSomething(),
    getSomethingElse(),
];

// combine promises
const alldone = Promise.all(promises);

// Add a promise after the previous ones have started
promises.push(getAThirdThing());

// everything, including `getAThirdThing` is done
await allDone;

In reality Promise.all() doesn't care that I pushed something onto the promises array.

Is there a similar pattern which accomplishes the same thing? Specifically, adding other promises to wait for, as they become known to a list of currently unresolved promises, arbitrarily, and without any requirement that any be added later.

I could do something like this instead:

const promises = [
    getSomething(),
    getSomethingElse(),
];
const alldone = Promise.all(promises);
await Promise.all([alldone, getAThirdThing()]);

But I want to call .then() on allDone prior to adding getAThirdThing() .

Answer 1

Promise.all returns a Promise itself, so you can call Promise.all consecutively:

let finished = Promise.all([...]);
finished = Promise.all([finished, someFunctionReturningAnotherPromise()]);
finished = Promise.all([finished, anotherFunctionReturningAPromise()]);
// etc...
// finally:
await finished;

However, what you can't do is add to the Promise chain after await ing the promise returned by Promise.all .

Also, things get a little tricky if in that scenario if you want to access the results of all the promises, as you'd end up with nested arrays of the results (which you could use something like lodash.flattenDeep to normalize them).

Answer 2

To add promises to a set of promises and wait on a promise for them all to be fulfilled, with the ability to add additional promises to the set, there are at least two choices:

1. Create an onFulfilled handler, called by then that checks if more promises are waiting to be added, and if so returns a promise for them (all) to be settled chained to another promise using the same then handler. More or less akin to a recursive asynchronous method that adds promises if they are available. Keeping track of fulfilled results and matching them with promise operations, and avoiding uncaught rejection errors would still need attention.

2. Write a custom Promise static method or constructor that does what you want instead without using Promise.all .

As an example of 2., the PromiseGroup constructor below returns an object with

• a promise` property that is settled with an array of values in the order promises were added to the group, and
• an add method that adds promises to be settled in order of presentation.

 function PromiseGroup() { var resolve; var reject; this.promise = new Promise( (r, j) => { resolve = r, reject = j}); this.settled = false; const group = this; var numAdded = 0; var numSettled = 0; const values = []; const quickReject = reason => reject(reason); const fulfill = ( i, value) => { values[i] = value; if( ++numSettled === numAdded) { resolve( values); group.settled = true; } }; this.add = function() { if( group.settled) { console.trace(); throw new Error("Can't add promises to a settled group"); } for( var j = 0; j < arguments.length; ++j) { let i = numAdded + j; Promise.resolve( arguments[j]) .then( value => fulfill( i, value), quickReject); } numAdded += j; }; } //******************************************** and test: async function test() { var group = new PromiseGroup(); group.add( new Promise(resolve=> setTimeout( resolve=>resolve(1), 500, resolve)), new Promise(resolve=> setTimeout( resolve=>resolve(2), 600, resolve))); setTimeout( test2, 100, group); var values = await group.promise; // some more code return values } function test2( group) { // add more after await group.add( new Promise(resolve=> setTimeout( resolve=>resolve(3), 700, resolve)), new Promise(resolve=> setTimeout( resolve=>resolve(4), 400, resolve))); } test().then( values=>console.log(JSON.stringify(values))); 

The reasoning behind this answer is that Promise.all , and Promise.race are a minimal and low level set of promise aggregation methods and their presence need not preclude the development of new ones.

The wisdom of using PromiseGroup or similar is a separate consideration. Personally I would review overall asynchronous design of the application to see if optional promises could be combined with promise operations that determine their need, if possible, before ever reaching the Promise.all or group stage.