使用ES2018，您可以大大简化以上所有答案：

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

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

参见规范：建议异步迭代

简化：

  for await (const results of array) {
    await longRunningTask()
  }
  console.log('I will wait')

2018-09-10：这个答案最近受到了很多关注，有关异步迭代的更多信息，请参阅AxelRauschmayer的博客文章。

若要查看如何出错，请在方法末尾打印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}`);
})();

就像@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容易出错，并将错误与应用程序分开处理。

您可以使用Array.prototype.forEach，但async/await不太兼容。这是因为从异步回调返回的promise需要解析，但Array.prototype.forEach不会解析其回调执行中的任何promise。因此，您可以使用forEach，但您必须自己处理承诺决议。

以下是使用Array.prototype.forEach读取和打印每个文件的方法

async function printFilesInSeries () {
  const files = await getFilePaths()

  let promiseChain = Promise.resolve()
  files.forEach((file) => {
    promiseChain = promiseChain.then(() => {
      fs.readFile(file, 'utf8').then((contents) => {
        console.log(contents)
      })
    })
  })
  await promiseChain
}

这里有一种并行打印文件内容的方法（仍然使用Array.protocol.forEach）

async function printFilesInParallel () {
  const files = await getFilePaths()

  const promises = []
  files.forEach((file) => {
    promises.push(
      fs.readFile(file, 'utf8').then((contents) => {
        console.log(contents)
      })
    )
  })
  await Promise.all(promises)
}

您可以使用async包中的async.forEach循环：

async.forEach(dataToLoop(array), async(data, cb) => {
                variable = await MongoQuery;
            }, function(err) {
                console.log(err);  
              })
            })
            .catch((err)=>{
              console.log(err);
            })

我使用Array.prototype.reduce代替Promise.all和Array.prototy.map（这不能保证Promise的解析顺序），从解析的Promise开始：

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

  await files.reduce(async (promise, file) => {
    // This line will wait for the last async function to finish.
    // The first iteration uses an already resolved Promise
    // so, it will immediately continue.
    await promise;
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  }, Promise.resolve());
}