当然，代码确实有效，但我很确定它并没有达到您期望的效果。它只是触发多个异步调用，但printFiles函数在这之后会立即返回。

按顺序读取

如果您想按顺序读取文件，则实际上不能使用forEach。只需使用现代for…of循环，其中await将按预期工作：

async function printFiles () {
  const files = await getFilePaths();

  for (const file of files) {
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  }
}

并行读取

如果要并行读取文件，则不能使用forEach。每一个异步回调函数调用都会返回一个promise，但您要丢弃它们而不是等待它们。只需使用map，您就可以等待Promise.all提供的一系列承诺：

async function printFiles () {
  const files = await getFilePaths();

  await Promise.all(files.map(async (file) => {
    const contents = await fs.readFile(file, 'utf8')
    console.log(contents)
  }));
}

若要查看如何出错，请在方法末尾打印console.log。

一般情况下可能出错的事情：

任意顺序。printFiles可以在打印文件之前完成运行。性能差。

这些并不总是错误的，但通常在标准用例中。

通常，使用forEach将导致除最后一个之外的所有结果。它将在不等待函数的情况下调用每个函数，这意味着它将告诉所有函数开始，然后完成，而不等待函数完成。

import fs from 'fs-promise'

async function printFiles () {
  const files = (await getFilePaths()).map(file => fs.readFile(file, 'utf8'))

  for(const file of files)
    console.log(await file)
}

printFiles()

这是本机JS中的一个示例，它将保持顺序，防止函数过早返回，并在理论上保持最佳性能。

这将：

启动所有并行文件读取。通过使用映射将文件名映射到要等待的承诺来保持顺序。按照数组定义的顺序等待每个承诺。

使用此解决方案，第一个文件将在其可用时立即显示，而无需等待其他文件首先可用。

它还将同时加载所有文件，而不必等待第一个文件完成后才能开始第二次文件读取。

这和原始版本的唯一缺点是，如果一次启动多个读取，则由于一次可能发生更多错误，因此处理错误更困难。

对于一次读取一个文件的版本，则会在出现故障时停止，而不会浪费时间尝试读取更多文件。即使有一个精心设计的取消系统，也很难避免它在第一个文件上失败，但也很难读取大部分其他文件。

性能并不总是可预测的。虽然许多系统的并行文件读取速度会更快，但有些系统更倾向于顺序读取。有些是动态的，可能会在负载下发生变化，提供延迟的优化在激烈竞争下并不总能产生良好的吞吐量。

该示例中也没有错误处理。如果有什么东西要求他们要么全部成功展示，要么根本不展示，那它就做不到。

建议在每个阶段使用console.log进行深入实验，并使用假文件读取解决方案（随机延迟）。尽管许多解决方案在简单的情况下似乎都是一样的，但它们都有细微的差异，需要额外的仔细检查才能挤出。

使用此模拟来帮助区分解决方案之间的差异：

(async () => {
  const start = +new Date();
  const mock = () => {
    return {
      fs: {readFile: file => new Promise((resolve, reject) => {
        // Instead of this just make three files and try each timing arrangement.
        // IE, all same, [100, 200, 300], [300, 200, 100], [100, 300, 200], etc.
        const time = Math.round(100 + Math.random() * 4900);
        console.log(`Read of ${file} started at ${new Date() - start} and will take ${time}ms.`)
        setTimeout(() => {
          // Bonus material here if random reject instead.
          console.log(`Read of ${file} finished, resolving promise at ${new Date() - start}.`);
          resolve(file);
        }, time);
      })},
      console: {log: file => console.log(`Console Log of ${file} finished at ${new Date() - start}.`)},
      getFilePaths: () => ['A', 'B', 'C', 'D', 'E']
    };
  };

  const printFiles = (({fs, console, getFilePaths}) => {
    return async function() {
      const files = (await getFilePaths()).map(file => fs.readFile(file, 'utf8'));

      for(const file of files)
        console.log(await file);
    };
  })(mock());

  console.log(`Running at ${new Date() - start}`);
  await printFiles();
  console.log(`Finished running at ${new Date() - start}`);
})();

OP的原始问题

在forEach循环中使用async/await有什么问题吗。。。

在@Bergi选择的答案中，它展示了如何串行和并行处理。然而，并行性还存在其他问题-

订单--@chharvey注意到-

例如，如果一个非常小的文件在一个非常大的文件之前完成了读取，那么它将首先被记录，即使小文件在文件数组中位于大文件之后。

可能一次打开太多文件--Bergi在另一个答案下的评论

同时打开数千个文件以同时读取它们也是不好的。人们总是要评估顺序、并行或混合方法是否更好。

因此，让我们来解决这些问题，展示实际的代码，简洁明了，不使用第三方库。易于剪切、粘贴和修改的东西。

并行读取（一次读取），串行打印（每个文件尽可能早）。

最简单的改进是像@Bergi的回答那样执行完全并行，但做了一个小改动，以便在保持顺序的同时尽快打印每个文件。

async function printFiles2() {
  const readProms = (await getFilePaths()).map((file) =>
    fs.readFile(file, "utf8")
  );
  await Promise.all([
    await Promise.all(readProms),                      // branch 1
    (async () => {                                     // branch 2
      for (const p of readProms) console.log(await p);
    })(),
  ]);
}

上面，两个单独的分支同时运行。

分支1：同时并行读取，分支2：连续读取以强制排序，但等待时间不超过必要

这很容易。

在并发限制下并行读取，串行打印（每个文件尽可能早）。

“并发限制”意味着同时读取的文件不超过N个。就像一家一次只允许这么多顾客进入的商店（至少在新冠疫情期间）。

首先引入了一个helper函数-

function bootablePromise(kickMe: () => Promise<any>) {
  let resolve: (value: unknown) => void = () => {};
  const promise = new Promise((res) => { resolve = res; });
  const boot = () => { resolve(kickMe()); };
  return { promise, boot };
}

函数bootablePromise（kickMe:（）=>Promise＜any＞）需要函数kickMe作为启动任务的参数（在本例中为readFile），但不会立即启动。

bootablePromise返回几个财产

承诺类型承诺引导类型函数（）=>void

承诺有两个阶段

承诺开始一项任务作为一个承诺，完成一项已经开始的任务。

当调用boot（）时，promise从第一状态转换到第二状态。

bootablePromise用于printFiles--

async function printFiles4() {
  const files = await getFilePaths();
  const boots: (() => void)[] = [];
  const set: Set<Promise<{ pidx: number }>> = new Set<Promise<any>>();
  const bootableProms = files.map((file,pidx) => {
    const { promise, boot } = bootablePromise(() => fs.readFile(file, "utf8"));
    boots.push(boot);
    set.add(promise.then(() => ({ pidx })));
    return promise;
  });
  const concurLimit = 2;
  await Promise.all([
    (async () => {                                       // branch 1
      let idx = 0;
      boots.slice(0, concurLimit).forEach((b) => { b(); idx++; });
      while (idx<boots.length) {
        const { pidx } = await Promise.race([...set]);
        set.delete([...set][pidx]);
        boots[idx++]();
      }
    })(),
    (async () => {                                       // branch 2
      for (const p of bootableProms) console.log(await p);
    })(),
  ]);
}

和以前一样，有两个分支

分支1：用于运行和处理并发。分支2：用于打印

现在的区别是不允许并发运行超过concurrentLimit Promise。

重要的变量是

boots：要调用以强制其相应Promise转换的函数数组。它仅在分支1中使用。set：在随机访问容器中有Promise，这样一旦实现，就可以很容易地删除它们。此容器仅在分支1中使用。bootableProms：这些是与最初在集合中的Promise相同的Promise，但它是一个数组而不是集合，并且该数组从未更改。它仅在分支2中使用。

使用模拟fs.readFile运行，所需时间如下（文件名与时间（毫秒））。

const timeTable = {
  "1": 600,
  "2": 500,
  "3": 400,
  "4": 300,
  "5": 200,
  "6": 100,
};

可以看到这样的测试运行时间，显示并发正在运行--

[1]0--0.601
[2]0--0.502
[3]0.503--0.904
[4]0.608--0.908
[5]0.905--1.105
[6]0.905--1.005

可在typescript游乐场沙盒中执行

一个重要的警告是：等待+等待。。of方法和forEach+异步方式实际上有不同的效果。

在真正的for循环中等待将确保所有异步调用都逐一执行。forEach+异步方式将同时发出所有的承诺，这会更快，但有时会不堪重负（如果您执行一些DB查询或访问一些具有容量限制的web服务，并且不想一次发出100000个呼叫）。

如果您不使用async/await，并且希望确保一个接一个地读取文件，那么也可以使用reduce+promise（不太优雅）。

files.reduce((lastPromise, file) => 
 lastPromise.then(() => 
   fs.readFile(file, 'utf8')
 ), Promise.resolve()
)

或者您可以创建一个forEachAsync来帮助，但基本上使用相同的for循环底层。

Array.prototype.forEachAsync = async function(cb){
    for(let x of this){
        await cb(x);
    }
}

files.forEach（异步（文件）=>{const contents=await fs.readFile（文件，'utf8'）})

问题是，forEach（）忽略了迭代函数返回的promise。在每个异步代码执行完成后，forEach不会等待移动到下一个迭代。所有fs.readFile函数将在同一轮事件循环中调用，这意味着它们是并行启动的，而不是顺序启动的，并且在调用forEach（）后立即继续执行等待所有fs.readFile操作完成。由于forEach不等待每个promise解析，因此循环实际上在解析promise之前完成了迭代。您希望在forEach完成后，所有异步代码都已执行，但事实并非如此。您最终可能会尝试访问尚未可用的值。

您可以使用以下示例代码测试行为

常量数组=[1，2，3]；const sleep=（ms）=>new Promise（解析=>setTimeout（解析，ms））；常量delayedSquare=（num）=>睡眠（100）。然后（（）=>num*num）；const testForEach=（numbersArray）=>{常量存储=[]；//此处将此代码视为同步代码numbersArray.forEach（异步（num）=>{const squaredNum=等待延迟平方（num）；//这将控制相应的squaredNum值console.log（平方数）；store.push（平方数）；});//您希望存储阵列已填充，但未填充//这将返回[]console.log（“存储”，存储）；};testForEach（数组）；//注意，当您测试时，将记录第一个“store[]”//然后squaredNum的内部forEach将记录

解决方案是使用for of循环。

for (const file of files){
    const contents = await fs.readFile(file, 'utf8')
}

替换forEach（）等待循环的一个简单的解决方案是用map替换forEach，并在开头添加Promise.all（）。

例如：

await y.forEach（异步（x）=>{

to

await Promise.all（y.map（异步（x）=>{

结尾处需要一个额外的）。