与Antonio Val的p迭代类似，另一种npm模块是异步af：

const AsyncAF = require('async-af');
const fs = require('fs-promise');

function printFiles() {
  // since AsyncAF accepts promises or non-promises, there's no need to await here
  const files = getFilePaths();

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

printFiles();

或者，async-af有一个静态方法（log/logAF）来记录promise的结果：

const AsyncAF = require('async-af');
const fs = require('fs-promise');

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

  AsyncAF(files).forEach(file => {
    AsyncAF.log(fs.readFile(file, 'utf8'));
  });
}

printFiles();

然而，该库的主要优点是您可以链接异步方法来执行以下操作：

const aaf = require('async-af');
const fs = require('fs-promise');

const printFiles = () => aaf(getFilePaths())
  .map(file => fs.readFile(file, 'utf8'))
  .forEach(file => aaf.log(file));

printFiles();

异步af

我会使用经过良好测试（每周下载数百万次）的pify和异步模块。如果您不熟悉异步模块，我强烈建议您查看它的文档。我见过多个开发人员浪费时间重新创建其方法，或者更糟的是，当高阶异步方法会简化代码时，很难维护异步代码。

const async=要求（'async'）const fs=要求（'s-fromise'）const pify=要求（'pify'）异步函数getFilePaths（）{return Promise.resolve(['./“package.json”，'./package-lock.json'，]);}异步函数printFiles（）{const files=等待getFilePaths（）await pify（async.eachSeries）（files，async（file）=>{//<--串联运行//await pify（async.each）（files，async（file）=>{//<--并行运行const contents=await fs.readFile（文件，'utf8'）console.log（内容）})console.log（'HAMBONE'）}printFiles（）.then（（）=>{console.log（'HAMBUNY'）})//日志顺序：//package.json内容//package-lock.json内容//汉堡//汉布尼```

npm上的p-iteration模块实现了Array迭代方法，因此它们可以以非常简单的方式与async/await一起使用。

您的案例示例：

const { forEach } = require('p-iteration');
const fs = require('fs-promise');

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

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

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')
}

当fs基于承诺时，Bergi的解决方案非常有效。您可以使用bluebird、fs extra或fs promise。

然而，节点的本地fs库的解决方案如下：

const result = await Promise.all(filePaths
    .map( async filePath => {
      const fileContents = await getAssetFromCache(filePath, async function() {

        // 1. Wrap with Promise    
        // 2. Return the result of the Promise
        return await new Promise((res, rej) => {
          fs.readFile(filePath, 'utf8', function(err, data) {
            if (data) {
              res(data);
            }
          });
        });
      });

      return fileContents;
    }));

注：require（'fs'）强制将函数作为第三个参数，否则抛出错误：

TypeError [ERR_INVALID_CALLBACK]: Callback must be a function

在一个文件中弹出几个方法，以串行化的顺序处理异步数据，并为代码提供更传统的风格，这是非常轻松的。例如：

module.exports = function () {
  var self = this;

  this.each = async (items, fn) => {
    if (items && items.length) {
      await Promise.all(
        items.map(async (item) => {
          await fn(item);
        }));
    }
  };

  this.reduce = async (items, fn, initialValue) => {
    await self.each(
      items, async (item) => {
        initialValue = await fn(initialValue, item);
      });
    return initialValue;
  };
};

现在，假设保存在'/myAsync.js'您可以在相邻文件中执行类似以下操作：

...
/* your server setup here */
...
var MyAsync = require('./myAsync');
var Cat = require('./models/Cat');
var Doje = require('./models/Doje');
var example = async () => {
  var myAsync = new MyAsync();
  var doje = await Doje.findOne({ name: 'Doje', noises: [] }).save();
  var cleanParams = [];

  // FOR EACH EXAMPLE
  await myAsync.each(['bork', 'concern', 'heck'], 
    async (elem) => {
      if (elem !== 'heck') {
        await doje.update({ $push: { 'noises': elem }});
      }
    });

  var cat = await Cat.findOne({ name: 'Nyan' });

  // REDUCE EXAMPLE
  var friendsOfNyanCat = await myAsync.reduce(cat.friends,
    async (catArray, friendId) => {
      var friend = await Friend.findById(friendId);
      if (friend.name !== 'Long cat') {
        catArray.push(friend.name);
      }
    }, []);
  // Assuming Long Cat was a friend of Nyan Cat...
  assert(friendsOfNyanCat.length === (cat.friends.length - 1));
}