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

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

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

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

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

这不会像OP请求的那样使用async/await，只有当您在NodeJS的后端时才有效。尽管这对某些人来说可能还是有帮助的，因为OP给出的示例是读取文件内容，通常在后端进行文件读取。

完全异步和非阻塞：

const fs = require("fs")
const async = require("async")

const obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"}
const configs = {}

async.forEachOf(obj, (value, key, callback) => {
    fs.readFile(__dirname + value, "utf8", (err, data) => {
        if (err) return callback(err)
        try {
            configs[key] = JSON.parse(data);
        } catch (e) {
            return callback(e)
        }
        callback()
    });
}, err => {
    if (err) console.error(err.message)
    // configs is now a map of JSON data
    doSomethingWith(configs)
})

OP的原始问题

在forEach循环中使用async/await有什么问题吗。。。

在@Bergi选择的答案中，它展示了如何串行和并行处理。然而，并行性还存在其他问题-

订单--@chharvey注意到-

例如，如果一个非常小的文件在一个非常大的文件之前完成了读取，那么它将首先被记录，即使小文件在文件数组中位于大文件之后。

可能一次打开太多文件--Bergi在另一个答案下的评论

同时打开数千个文件以同时读取它们也是不好的。人们总是要评估顺序、并行或混合方法是否更好。

因此，让我们来解决这些问题，展示实际的代码，简洁明了，不使用第三方库。易于剪切、粘贴和修改的东西。

并行读取（一次读取），串行打印（每个文件尽可能早）。

最简单的改进是像@Bergi的回答那样执行完全并行，但做了一个小改动，以便在保持顺序的同时尽快打印每个文件。

async function printFiles2() {
  const readProms = (await getFilePaths()).map((file) =>
    fs.readFile(file, "utf8")
  );
  await Promise.all([
    await Promise.all(readProms),                      // branch 1
    (async () => {                                     // branch 2
      for (const p of readProms) console.log(await p);
    })(),
  ]);
}

上面，两个单独的分支同时运行。

分支1：同时并行读取，分支2：连续读取以强制排序，但等待时间不超过必要

这很容易。

在并发限制下并行读取，串行打印（每个文件尽可能早）。

“并发限制”意味着同时读取的文件不超过N个。就像一家一次只允许这么多顾客进入的商店（至少在新冠疫情期间）。

首先引入了一个helper函数-

function bootablePromise(kickMe: () => Promise<any>) {
  let resolve: (value: unknown) => void = () => {};
  const promise = new Promise((res) => { resolve = res; });
  const boot = () => { resolve(kickMe()); };
  return { promise, boot };
}

函数bootablePromise（kickMe:（）=>Promise＜any＞）需要函数kickMe作为启动任务的参数（在本例中为readFile），但不会立即启动。

bootablePromise返回几个财产

承诺类型承诺引导类型函数（）=>void

承诺有两个阶段

承诺开始一项任务作为一个承诺，完成一项已经开始的任务。

当调用boot（）时，promise从第一状态转换到第二状态。

bootablePromise用于printFiles--

async function printFiles4() {
  const files = await getFilePaths();
  const boots: (() => void)[] = [];
  const set: Set<Promise<{ pidx: number }>> = new Set<Promise<any>>();
  const bootableProms = files.map((file,pidx) => {
    const { promise, boot } = bootablePromise(() => fs.readFile(file, "utf8"));
    boots.push(boot);
    set.add(promise.then(() => ({ pidx })));
    return promise;
  });
  const concurLimit = 2;
  await Promise.all([
    (async () => {                                       // branch 1
      let idx = 0;
      boots.slice(0, concurLimit).forEach((b) => { b(); idx++; });
      while (idx<boots.length) {
        const { pidx } = await Promise.race([...set]);
        set.delete([...set][pidx]);
        boots[idx++]();
      }
    })(),
    (async () => {                                       // branch 2
      for (const p of bootableProms) console.log(await p);
    })(),
  ]);
}

和以前一样，有两个分支

分支1：用于运行和处理并发。分支2：用于打印

现在的区别是不允许并发运行超过concurrentLimit Promise。

重要的变量是

boots：要调用以强制其相应Promise转换的函数数组。它仅在分支1中使用。set：在随机访问容器中有Promise，这样一旦实现，就可以很容易地删除它们。此容器仅在分支1中使用。bootableProms：这些是与最初在集合中的Promise相同的Promise，但它是一个数组而不是集合，并且该数组从未更改。它仅在分支2中使用。

使用模拟fs.readFile运行，所需时间如下（文件名与时间（毫秒））。

const timeTable = {
  "1": 600,
  "2": 500,
  "3": 400,
  "4": 300,
  "5": 200,
  "6": 100,
};

可以看到这样的测试运行时间，显示并发正在运行--

[1]0--0.601
[2]0--0.502
[3]0.503--0.904
[4]0.608--0.908
[5]0.905--1.105
[6]0.905--1.005

可在typescript游乐场沙盒中执行

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

目前，Array.forEach原型属性不支持异步操作，但我们可以创建自己的多边形填充来满足我们的需要。

// Example of asyncForEach Array poly-fill for NodeJs
// file: asyncForEach.js
// Define asynForEach function 
async function asyncForEach(iteratorFunction){
  let indexer = 0
  for(let data of this){
    await iteratorFunction(data, indexer)
    indexer++
  }
}
// Append it as an Array prototype property
Array.prototype.asyncForEach = asyncForEach
module.exports = {Array}

就这样！现在，在这些操作之后定义的任何数组上都可以使用asyncforEach方法。

让我们测试一下。。。

// Nodejs style
// file: someOtherFile.js

const readline = require('readline')
Array = require('./asyncForEach').Array
const log = console.log

// Create a stream interface
function createReader(options={prompt: '>'}){
  return readline.createInterface({
    input: process.stdin
    ,output: process.stdout
    ,prompt: options.prompt !== undefined ? options.prompt : '>'
  })
}
// Create a cli stream reader
async function getUserIn(question, options={prompt:'>'}){
  log(question)
  let reader = createReader(options)
  return new Promise((res)=>{
    reader.on('line', (answer)=>{
      process.stdout.cursorTo(0, 0)
      process.stdout.clearScreenDown()
      reader.close()
      res(answer)
    })
  })
}

let questions = [
  `What's your name`
  ,`What's your favorite programming language`
  ,`What's your favorite async function`
]
let responses = {}

async function getResponses(){
// Notice we have to prepend await before calling the async Array function
// in order for it to function as expected
  await questions.asyncForEach(async function(question, index){
    let answer = await getUserIn(question)
    responses[question] = answer
  })
}

async function main(){
  await getResponses()
  log(responses)
}
main()
// Should prompt user for an answer to each question and then 
// log each question and answer as an object to the terminal

我们可以对其他一些数组函数（如map。。。

async function asyncMap(iteratorFunction){
  let newMap = []
  let indexer = 0
  for(let data of this){
    newMap[indexer] = await iteratorFunction(data, indexer, this)
    indexer++
  }
  return newMap
}

Array.prototype.asyncMap = asyncMap

…等等：）

需要注意的一些事项：

迭代器函数必须是异步函数或promise在Array.protocol.<yourAsyncFunc>=<yourAsync Func>之前创建的任何数组都不具有此功能