如何在并行执行Promise时按完成顺序处理结果且汇总全部结果？

这问题问到点子上了！Promise.all确实会严格遵循输入数组的顺序返回结果，哪怕某些Promise更早resolve。如果我们想并行运行所有Promise的同时，按它们完成的顺序处理结果，最后还能拿到完整的汇总结果，完全可以实现一个可复用的工具函数，而且全程用现代的async/await语法。

核心思路 #

我们不需要放弃Promise的并行执行，只需要给每个Promise包装一层逻辑：在它resolve时，立即把结果存入一个数组（这样数组的顺序就是完成顺序），同时让Promise.all等待所有Promise执行完毕，确保不会遗漏任何结果。

方案1：获取按完成顺序排列的最终结果数组 #

这个函数会返回一个按Promise完成顺序排列的结果数组，同时保证所有Promise并行执行：

async function promiseAllInResolveOrder(promises) {
  const orderedResults = [];
  
  // 给每个Promise包装一层，resolve时将结果加入顺序数组
  const wrappedPromises = promises.map(promise => 
    promise.then(result => {
      orderedResults.push(result);
      return result;
    })
  );
  
  // 等待所有Promise完成，确保所有结果都被收集
  await Promise.all(wrappedPromises);
  
  return orderedResults;
}

测试示例 #

用你提供的Promise数组测试：

const promises = [
  new Promise(res => setTimeout(() => res("A"), 3000)),
  new Promise(res => setTimeout(() => res("B"), 1000)),
  new Promise(res => setTimeout(() => res("C"), 2000)),
];

const results = await promiseAllInResolveOrder(promises);
console.log(results); // 输出 ["B", "C", "A"]

方案2：实时处理完成的结果 + 最终汇总 #

如果你想在每个Promise完成时就立即处理（比如拿到结果就打印或做业务逻辑），同时最后拿到完整的顺序结果数组，可以给函数加一个可选的回调参数：

async function promiseAllInResolveOrder(promises, onResolve) {
  const orderedResults = [];
  
  const wrappedPromises = promises.map(promise => 
    promise.then(result => {
      orderedResults.push(result);
      // 如果传入了回调，立即处理当前完成的结果
      if (typeof onResolve === 'function') {
        onResolve(result);
      }
      return result;
    })
  );
  
  await Promise.all(wrappedPromises);
  return orderedResults;
}

测试示例 #

const promises = [
  new Promise(res => setTimeout(() => res("A"), 3000)),
  new Promise(res => setTimeout(() => res("B"), 1000)),
  new Promise(res => setTimeout(() => res("C"), 2000)),
];

const finalResults = await promiseAllInResolveOrder(promises, (result) => {
  console.log(`已完成并处理结果：${result}`); // 依次打印 "B"、"C"、"A"
});

console.log("全部完成，汇总结果：", finalResults); // 输出 ["B", "C", "A"]

方案3：异步迭代器（实时顺序处理） #

如果喜欢用for-await-of语法来逐个处理完成的结果，可以实现一个异步迭代器，这样代码更优雅：

function resolveOrderIterator(promises) {
  const resultQueue = [];
  let resolveQueue;
  
  // 初始化队列的等待Promise
  let queueWaiter = new Promise(resolve => {
    resolveQueue = resolve;
  });

  // 遍历所有Promise，完成时加入队列并通知迭代器
  promises.forEach(promise => {
    promise.then(result => {
      resultQueue.push(result);
      resolveQueue();
      // 重置等待Promise，等待下一个结果
      queueWaiter = new Promise(resolve => {
        resolveQueue = resolve;
      });
    });
  });

  // 返回异步迭代器
  return {
    [Symbol.asyncIterator]() {
      return {
        async next() {
          // 如果队列有结果，直接返回
          if (resultQueue.length > 0) {
            return { value: resultQueue.shift(), done: false };
          }
          // 检查所有Promise是否都完成了
          const allCompleted = await Promise.all(promises).then(() => true);
          if (allCompleted && resultQueue.length === 0) {
            return { done: true };
          }
          // 等待队列有新结果
          await queueWaiter;
          return this.next();
        }
      };
    }
  };
}

测试示例 #

const promises = [
  new Promise(res => setTimeout(() => res("A"), 3000)),
  new Promise(res => setTimeout(() => res("B"), 1000)),
  new Promise(res => setTimeout(() => res("C"), 2000)),
];

// 用for-await-of按完成顺序处理每个结果
for await (const result of resolveOrderIterator(promises)) {
  console.log(`处理完成结果：${result}`); // 依次打印 "B"、"C"、"A"
}

// 如果需要汇总结果，依然可以调用方案1的函数
const finalResults = await promiseAllInResolveOrder(promises);

为什么这些方案可行？ #

所有方案都保持了Promise的并行执行特性——我们只是给每个Promise加了一个then回调来跟踪完成顺序，并没有让Promise串行执行。Promise.all依然会等待所有Promise完成，确保我们不会丢失任何结果。

内容的提问来源于stack exchange，提问作者Anayo Samson Oleru