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

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

正如其他答案所提到的，您可能希望它按顺序而不是并行执行。即，运行第一个文件，等待完成，然后一旦完成，运行第二个文件。这不会发生。

我认为很重要的是要解决为什么没有发生这种情况。

想想forEach是如何工作的。我找不到来源，但我认为它的工作原理如下：

const forEach = (arr, cb) => {
  for (let i = 0; i < arr.length; i++) {
    cb(arr[i]);
  }
};

现在想想当你做这样的事情时会发生什么：

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

在forEach的for循环中，我们调用cb（arr[i]），最后是logFile（file）。logFile函数内部有一个await，所以for循环可能会在继续到i++之前等待这个await？

不，不会的。令人困惑的是，这不是wait的工作方式。从文档中：

await分割执行流，允许异步函数的调用方继续执行。在await延迟异步函数的继续之后，随后执行后续语句。如果此await是其函数执行的最后一个表达式，则继续执行，方法是向函数的调用方返回完成await函数的未决Promise并继续执行该调用方。

因此，如果您有以下内容，则不会在“b”之前记录数字：

const delay = (ms) => {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
};

const logNumbers = async () => {
  console.log(1);
  await delay(2000);
  console.log(2);
  await delay(2000);
  console.log(3);
};

const main = () => {
  console.log("a");
  logNumbers();
  console.log("b");
};

main();

循环回到forEach，forEach就像main，logFile就像logNumbers。main不会因为logNumbers等待而停止，forEach不会因为logFile等待而停止。

然而，上述两种解决方案都有效，Antonio的代码更少，这是它如何帮助我从数据库中解析数据，从几个不同的子引用中，然后将它们全部推到一个数组中，并在完成所有任务后以承诺的方式进行解析：

Promise.all(PacksList.map((pack)=>{
    return fireBaseRef.child(pack.folderPath).once('value',(snap)=>{
        snap.forEach( childSnap => {
            const file = childSnap.val()
            file.id = childSnap.key;
            allItems.push( file )
        })
    })
})).then(()=>store.dispatch( actions.allMockupItems(allItems)))

我会使用经过良好测试（每周下载数百万次）的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内容//汉堡//汉布尼```

使用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的博客文章。

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