目前，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>之前创建的任何数组都不具有此功能

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

我想解决在异步和等待时使用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。。的，它们按顺序保存。

然而，上述两种解决方案都有效，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)))

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

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

我使用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());
}

您可以使用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)
}