如何将Promise数组转换为AsyncIterable或普通Iterable以逐个处理结果？

首先修正你原代码里的一个类型问题：reqs 参数应该是可迭代的异步操作函数集合（比如 Array<() => Promise<string>>），而不是单个返回 Promise 的函数，否则无法用 for...of 遍历。

下面针对你的需求给出两种实现方案：

一、异步迭代器版本：并行执行+按完成顺序消费 #

如果你想保持所有异步操作并行启动，同时在每个 Promise 解析时就拿到结果（不管顺序），可以让 foo 返回 AsyncIterable<string>，配合 for await...of 循环消费：

function foo(reqs: Array<() => Promise<string>>): AsyncIterable<string> {
  const resultQueue: string[] = [];
  let completedCount = 0;
  const totalTasks = reqs.length;
  let pendingResolve: ((value: IteratorResult<string>) => void) | null = null;

  // 批量启动所有异步任务
  reqs.forEach(async (task) => {
    try {
      const value = await task();
      resultQueue.push(value);
      // 如果迭代器正等待结果，立即返回当前值
      pendingResolve?.({ value, done: false });
      pendingResolve = null;
    } finally {
      completedCount++;
      // 所有任务完成时，通知迭代器结束
      if (completedCount === totalTasks) {
        pendingResolve?.({ value: undefined, done: true });
      }
    }
  });

  return {
    [Symbol.asyncIterator]() {
      return {
        async next(): Promise<IteratorResult<string>> {
          // 队列中有结果直接返回
          if (resultQueue.length > 0) {
            return { value: resultQueue.shift()!, done: false };
          }
          // 所有任务完成，返回迭代结束标志
          if (completedCount === totalTasks) {
            return { value: undefined, done: true };
          }
          // 等待下一个任务完成
          return new Promise(resolve => {
            pendingResolve = resolve;
          });
        }
      };
    }
  };
}

// 使用示例
async function run() {
  const tasks = [
    () => new Promise(resolve => setTimeout(() => resolve("任务1结果"), 3000)),
    () => new Promise(resolve => setTimeout(() => resolve("任务2结果"), 1000)),
    () => new Promise(resolve => setTimeout(() => resolve("任务3结果"), 2000)),
  ];

  // 按任务完成顺序输出结果：任务2 → 任务3 → 任务1
  for await (const res of foo(tasks)) {
    console.log(res);
  }
}

run();

这个实现的核心是用队列缓存已完成的结果，异步迭代器会在每次 next() 调用时优先取队列数据，无数据则等待下一个任务完成，既保持了并行执行的效率，又能实时消费结果。

二、普通迭代器版本：串行执行+解决背压 #

如果需要控制执行节奏（比如避免一次性启动大量异步操作导致的资源压力），可以让 foo 返回普通迭代器，每次迭代返回一个异步任务函数，由消费者决定何时启动下一个任务：

function foo(reqs: Array<() => Promise<string>>): Iterable<() => Promise<string>> {
  return {
    [Symbol.iterator]() {
      let currentIndex = 0;
      return {
        next(): IteratorResult<() => Promise<string>> {
          if (currentIndex < reqs.length) {
            return { value: reqs[currentIndex++], done: false };
          }
          return { value: undefined, done: true };
        }
      };
    }
  };
}

// 使用示例（串行执行，解决背压）
async function run() {
  const tasks = [
    () => new Promise(resolve => setTimeout(() => resolve("任务1结果"), 1000)),
    () => new Promise(resolve => setTimeout(() => resolve("任务2结果"), 1000)),
    () => new Promise(resolve => setTimeout(() => resolve("任务3结果"), 1000)),
  ];

  // 按任务顺序串行执行并输出：任务1 → 任务2 → 任务3
  for (const task of foo(tasks)) {
    const res = await task();
    console.log(res);
    // 可以在这里添加处理逻辑，前一个任务处理完才会启动下一个
  }
}

run();

这种方案完全由消费者控制任务的启动时机，前一个任务处理完成后才会启动下一个，天然解决了背压问题，适合资源敏感的场景。

内容的提问来源于stack exchange，提问作者David Alsh