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

例如：

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

to

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

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

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

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

想想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等待而停止。

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

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

如果要同时迭代所有元素：

async function asyncForEach(arr, fn) {
  await Promise.all(arr.map(fn));
}

如果您希望非并发地遍历所有元素（例如，当映射函数具有副作用或同时在所有数组元素上运行mapper时，资源成本太高）：

选项A：承诺

function asyncForEachStrict(arr, fn) {
  return new Promise((resolve) => {
    arr.reduce(
      (promise, cur, idx) => promise
        .then(() => fn(cur, idx, arr)),
      Promise.resolve(),
    ).then(() => resolve());
  });
}

选项B：异步/等待

async function asyncForEachStrict(arr, fn) {
  for (let idx = 0; idx < arr.length; idx += 1) {
    const cur = arr[idx];

    await fn(cur, idx, arr);
  }
}

下面是一些forEachAsync原型。注意，您需要等待他们：

Array.prototype.forEachAsync = async function (fn) {
    for (let t of this) { await fn(t) }
}

Array.prototype.forEachAsyncParallel = async function (fn) {
    await Promise.all(this.map(fn));
}

请注意，虽然您可以将其包含在自己的代码中，但不应将其包含到您分发给其他人的库中（以避免污染其全局）。

@贝吉已经给出了如何正确处理这一特殊案件的答案。我不会在这里重复。

我想解决在异步和等待时使用forEach和for循环之间的区别

forEach的工作原理

让我们看看forEach是如何工作的。根据ECMAScript规范，MDN提供了一种可以用作polyfill的实现。我将其复制并粘贴到此处，并删除注释。

Array.prototype.forEach = function (callback, thisArg) {
  if (this == null) { throw new TypeError('Array.prototype.forEach called on null or undefined'); }
  var T, k;
  var O = Object(this);
  var len = O.length >>> 0;
  if (typeof callback !== "function") { throw new TypeError(callback + ' is not a function'); }
  if (arguments.length > 1) { T = thisArg; }
  k = 0;
  while (k < len) {
    var kValue;
    if (k in O) {
      kValue = O[k];
      callback.call(T, kValue, k, O); // pay attention to this line
    }
    k++;
  }
};

让我们回到代码，将回调作为函数提取。

async function callback(file){
  const contents = await fs.readFile(file, 'utf8')
  console.log(contents)
}

所以，回调基本上返回一个promise，因为它是用异步声明的。在forEach内部，回调只是以正常方式调用，如果回调本身返回一个promise，javascript引擎不会等待它被解析或拒绝。相反，它将承诺放入作业队列中，并继续执行循环。

如何在回调中等待fs.readFile（文件，'utf8'）？

基本上，当异步回调有机会被执行时，js引擎将暂停，直到fs.readFile（文件，'utf8'）被解析或拒绝，并在完成后继续执行异步函数。因此contents变量存储fs.readFile的实际结果，而不是promise。因此，console.log（contents）注销文件内容，而不是Promise

为什么。。。作品？

当我们编写循环的泛型for时，我们获得了比forEach更多的控制权。让我们重构printFiles。

async function printFiles () {
  const files = await getFilePaths() // Assume this works fine

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

当为循环求值时，我们在异步函数中有await promise，执行将暂停，直到await promice得到解决。因此，您可以认为文件是按确定的顺序逐个读取的。

按顺序执行

有时，我们确实需要以顺序执行异步函数。例如，我有几个新记录存储在一个数组中，要保存到数据库中，我希望它们按顺序保存，这意味着数组中的第一个记录应该先保存，然后再保存，直到保存最后一个记录。

下面是一个示例：

常量记录=[1，2，3，4]；异步函数saveRecord（record）{return new Promise（（已解决，已拒绝）=>{setTimeout（（）=>{已解析（`record$｛record｝已保存`）}，数学随机（*500）});}EachSaveRecords（记录）的异步函数{records.forEach（异步（记录）=>{const res=等待saveRecord（记录）；console.log（res）；})}SaveRecords（记录）的异步函数{for（记录的常量记录）{const res=等待saveRecord（记录）；console.log（res）；}}（异步（）=>{console.log（“===保存记录的===”）等待保存记录（记录）console.log（“==对于每个保存记录==”）等待EachSaveRecords（记录）})()

我使用setTimeout来模拟将记录保存到数据库的过程——这是异步的，花费了随机时间。使用forEach，记录将按未确定的顺序保存，但使用for。。的，它们按顺序保存。