Promise.all() with limit?

Question

Is there a way/pattern to implement let res = Promise.all([...p], limit)?

• The promise-array holds functions which construct and return the promise
• res should be resolved after all p resolves
• Only limit=3 Promises should run in parallel
• The n+1th Promise should start immediately after n finishes. So that there are always limit resolvers running in parallel.

Especially the last point creates my headaches.

My current solution is to split the promises-array into chunks of limit size and chain them. The disadvantages here is that the second bunch don't start until all Promises from bunch 1 has been resolved.

Answer 1

I came up with the idea of creating n = limit chains which run in parallel and append as long as there are promises:

let promises = [];
for(let i=0; i<11; i++) promises[i] = () => {
  console.log('Construct:',i);
  return new Promise(resolve => {
    setTimeout(function() {
      console.log('Resolve:',i);
      resolve(i);
    }, Math.round(Math.random() * (2000 - 500) + 2000));
  });
}


function parallelLimit(promiseFactories, limit) {
  let result = [];
  let cnt = 0;

  function chain(promiseFactories) {
    if(!promiseFactories.length) return;
    let i = cnt++; // preserve order in result
    return promiseFactories.shift()().then((res) => {
      result[i] = res; // save result
      return chain(promiseFactories); // append next promise
    });
  }

  let arrChains = [];
  while(limit-- > 0 && promiseFactories.length > 0) {
    // create `limit` chains which run in parallel
    arrChains.push(chain(promiseFactories));
  }

  // return when all arrChains are finished
  return Promise.all(arrChains).then(() => result);
}


parallelLimit(promises, 4).then(console.log);

Excited to read your comments and suggestions :)