如何使给定数量的 Promise 在 Nodejs 上同时运行？[复制]

// Function to chunk an array into smaller arrays
function chunkArray(array, chunkSize) {
  const chunks = [];
  for (let i = 0; i < array.length; i += chunkSize) {
    chunks.push(array.slice(i, i + chunkSize));
  }
  return chunks;
}

// Assuming scrapingProcessForAnEntity returns a Promise
const scrapingProcessForAnEntity = (query) => {
  // Your asynchronous API call logic here
  return new Promise((resolve, reject) => {
    // Example asynchronous operation (replace with your actual API call)
    setTimeout(() => {
      console.log(`API call for query: ${query}`);
      resolve(`Data for query: ${query}`);
    }, 1000); // Simulated delay of 1 second
  });
};

const entities = ['entity1', 'entity2', 'entity3', 'entity4', 'entity5', 'entity6'];

// Chunk the entities into arrays of size 3
const chunkedEntities = chunkArray(entities, 3);

// Map over the chunks and perform asynchronous operations using Promise.all
const allPromises = chunkedEntities.map(chunk => {
  const promiseQuery = chunk.map(entity => scrapingProcessForAnEntity(entity));
  return Promise.all(promiseQuery);
});

// Flatten the results if needed (if you want a flat array of fulfilled promises)
const fullfilledPromises = Promise.all(allPromises.flat());

fullfilledPromises.then(results => {
  console.log('All API calls completed:', results);
}).catch(error => {
  console.error('Error:', error);
});

class LimitedResourceExecutor {
  #size
  #queue
  #running

  constructor(size=1) {
    this.#size = size
    this.#queue = []
    this.#running = 0
  }
  
  get size() { return this.#size }

  // enqueue a task, then check if it should be run
  call(obj, func, ...args) {
    return new Promise((resolve, reject) => {
      this.#queue.push([resolve, reject, obj, func, args])
      this.#runQueue()
    })
  }

  // run a task if it can be run, check again afterwards
  async #runQueue() {
    if (this.#queue.length && this.#running < this.size) {
      this.#running++
      const [resolve, reject, obj, func, args] = this.#queue.shift()
      try {
        const result = await func.call(obj, ...args)
        resolve(result)
      } catch (err) {
        reject(err)
      } finally {
        this.#running--
        this.#runQueue()
      }
    }
  }
}


// From https://stackoverflow.com/a/39914235/240443
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms))
}

// just a little test function
let id = 0
let start = new Date().getTime()
async function sleepAndLog(ms) {
  const thisId = ++id
  console.log(new Date() - start, thisId, "starting", ms)
  await sleep(ms)
  console.log(new Date() - start, thisId, "finished", ms)
  return thisId
}

// only two tasks in parallel
const lre = new LimitedResourceExecutor(2)
const timings = [4000, 1000, 1000, 2000, 3000, 1000]
// construct a promise list
const promises = timings.map(ms => lre.call(null, sleepAndLog, ms))
// Promise.all still works, results coming in the correct order
Promise.all(promises).then(results => {
  console.log("DONE")
  console.log(JSON.stringify(results))
})