只是在原有答案的基础上

原始答案中的平行阅读语法有时令人困惑且难以理解，也许我们可以用不同的方法来编写

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

  const readAndLogFile = async filePath => {
    const contents = await fs.readFile(file, "utf8");
    console.log(contents);
    return contents;
  };

  files.forEach(file => {
    fileReadPromises.push(readAndLogFile(file));
  });

  await Promise.all(fileReadPromises);
}

用于顺序操作，而不仅仅用于。。。的，循环的正常值也将起作用

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

  for (let i = 0; i < files.length; i++) {
    const file = files[i];
    const contents = await fs.readFile(file, "utf8");
    console.log(contents);
  }
}

除了@Bergi的回答，我想提供第三种选择。这与@Bergi的第二个例子非常相似，但不是单独等待每个readFile，而是创建一个承诺数组，每个承诺都在最后等待。

import fs from 'fs-promise';
async function printFiles () {
  const files = await getFilePaths();

  const promises = files.map((file) => fs.readFile(file, 'utf8'))

  const contents = await Promise.all(promises)

  contents.forEach(console.log);
}

注意，传递给.map（）的函数不需要是异步的，因为fs.readFile无论如何都会返回Promise对象。因此，Promise是Promise对象的数组，可以将其发送到Promise.all（）。

在@Bergi的回答中，控制台可以按照文件内容的读取顺序记录文件内容。例如，如果一个非常小的文件在一个非常大的文件之前完成了读取，那么它将首先被记录，即使小文件在文件数组中位于大文件之后。然而，在我上面的方法中，您可以保证控制台将以与提供的阵列相同的顺序记录文件。

只是在原有答案的基础上

原始答案中的平行阅读语法有时令人困惑且难以理解，也许我们可以用不同的方法来编写

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

  const readAndLogFile = async filePath => {
    const contents = await fs.readFile(file, "utf8");
    console.log(contents);
    return contents;
  };

  files.forEach(file => {
    fileReadPromises.push(readAndLogFile(file));
  });

  await Promise.all(fileReadPromises);
}

用于顺序操作，而不仅仅用于。。。的，循环的正常值也将起作用

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

  for (let i = 0; i < files.length; i++) {
    const file = files[i];
    const contents = await fs.readFile(file, "utf8");
    console.log(contents);
  }
}

就像@Bergi的回应，但有一点不同。

承诺。如果一个人被拒绝，所有人都会拒绝所有承诺。

所以，使用递归。

const readFilesQueue = async (files, index = 0) {
    const contents = await fs.readFile(files[index], 'utf8')
    console.log(contents)

    return files.length <= index
        ? readFilesQueue(files, ++index)
        : files

}

const printFiles async = () => {
    const files = await getFilePaths();
    const printContents = await readFilesQueue(files)

    return printContents
}

printFiles()

PS

readFilesQueue在printFiles之外。由于console.log引入了副作用*，所以最好是模拟、测试或监视，因此，使用返回内容的函数（sidenuote）并不酷。

因此，代码可以简单地这样设计：三个独立的函数是“纯”**，不会产生任何副作用，处理整个列表，并且可以很容易地修改以处理失败的案例。

const files = await getFilesPath()

const printFile = async (file) => {
    const content = await fs.readFile(file, 'utf8')
    console.log(content)
}

const readFiles = async = (files, index = 0) => {
    await printFile(files[index])

    return files.lengh <= index
        ? readFiles(files, ++index)
        : files
}

readFiles(files)

未来编辑/当前状态

节点支持顶级等待（它还没有插件，也不会有，可以通过和谐标志启用），这很酷，但不能解决一个问题（策略上我只在LTS版本上工作）。如何获取文件？

使用合成。给出代码后，我觉得这是在一个模块内，所以应该有一个函数来完成。如果没有，你应该使用IIFE将角色代码包装成一个异步函数，创建一个简单的模块，它可以为你做所有的事情，或者你可以采用正确的方式，即组合。

// more complex version with IIFE to a single module
(async (files) => readFiles(await files())(getFilesPath)

注意，变量的名称因语义而改变。您传递一个函子（一个可以被另一个函数调用的函数），并在内存中接收一个指针，该指针包含应用程序的初始逻辑块。

但是，如果不是模块，您需要导出逻辑？

将函数包装在异步函数中。

export const readFilesQueue = async () => {
    // ... to code goes here
}

或者改变变量的名称。。。

*副作用是指应用程序的任何协同作用，它可以改变状态/行为或在应用程序中引入错误，如IO。

**通过“纯”，它是撇号，因为函数不是纯的，当没有控制台输出，只有数据操作时，代码可以聚合为纯版本。

除此之外，为了纯粹起见，您需要使用处理副作用的monad，这些monad容易出错，并将错误与应用程序分开处理。

当然，代码确实有效，但我很确定它并没有达到您期望的效果。它只是触发多个异步调用，但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)
  }));
}

对于TypeScript用户，使用工作类型的Promise.all（array.map（迭代器））包装器

使用Promise.all（array.map（迭代器））具有正确的类型，因为TypeScript的stdlib支持已经处理了泛型。然而，每次需要异步映射时复制粘贴Promise.all（array.map（迭代器））显然不是最佳的，Promise.all（array.ma（迭代））并不能很好地传达代码的意图，因此大多数开发人员都会将其包装成一个asyncMap（）包装函数。然而，要做到这一点，需要使用泛型来确保使用const value＝await asyncMap（）设置的值具有正确的类型。

export const asyncMap = async <ArrayItemType, IteratorReturnType>(
  array: Array<ArrayItemType>,
  iterator: (
    value: ArrayItemType,
    index?: number
  ) => Promise<IteratorReturnType>
): Promise<Array<IteratorReturnType>> => {
  return Promise.all(array.map(iterator));
};

快速测试：

it(`runs 3 items in parallel and returns results`, async () => {
  const result = await asyncMap([1, 2, 3], async (item: number) => {
    await sleep(item * 100);
    return `Finished ${item}`;
  });
  expect(result.length).toEqual(3);
  // Each item takes 100, 200 and 300ms
  // So restricting this test to 300ms plus some leeway
}, 320);

sleep（）只是：

const sleep = async (timeInMs: number): Promise<void> => {
  return new Promise((resolve) => setTimeout(resolve, timeInMs));
};