在forEach循环中使用async/await有什么问题吗？我正在尝试循环浏览一系列文件，并等待每个文件的内容。
import fs from 'fs-promise'
async function printFiles () {
const files = await getFilePaths() // Assume this works fine
files.forEach(async (file) => {
const contents = await fs.readFile(file, 'utf8')
console.log(contents)
})
}
printFiles()
这段代码确实有效，但这段代码会出错吗？我有人告诉我，你不应该在这样的高阶函数中使用async/await，所以我只想问问这是否有问题。
当前回答
@贝吉已经给出了如何正确处理这一特殊案件的答案。我不会在这里重复。
我想解决在异步和等待时使用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。。的，它们按顺序保存。
其他回答
您可以使用async包中的async.forEach循环：
async.forEach(dataToLoop(array), async(data, cb) => {
variable = await MongoQuery;
}, function(err) {
console.log(err);
})
})
.catch((err)=>{
console.log(err);
})
当然，代码确实有效，但我很确定它并没有达到您期望的效果。它只是触发多个异步调用，但printFiles函数在这之后会立即返回。
按顺序读取
如果您想按顺序读取文件，则实际上不能使用forEach。只需使用现代for…of循环，其中await将按预期工作：
async function printFiles () {
const files = await getFilePaths();
for (const file of files) {
const contents = await fs.readFile(file, 'utf8');
console.log(contents);
}
}
并行读取
如果要并行读取文件，则不能使用forEach。每一个异步回调函数调用都会返回一个promise，但您要丢弃它们而不是等待它们。只需使用map，您就可以等待Promise.all提供的一系列承诺：
async function printFiles () {
const files = await getFilePaths();
await Promise.all(files.map(async (file) => {
const contents = await fs.readFile(file, 'utf8')
console.log(contents)
}));
}
与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
@贝吉已经给出了如何正确处理这一特殊案件的答案。我不会在这里重复。
我想解决在异步和等待时使用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。。的，它们按顺序保存。
就像@Bergi的回应，但有一点不同。
承诺。如果一个人被拒绝，所有人都会拒绝所有承诺。
所以，使用递归。
const readFilesQueue = async (files, index = 0) {
const contents = await fs.readFile(files[index], 'utf8')
console.log(contents)
return files.length <= index
? readFilesQueue(files, ++index)
: files
}
const printFiles async = () => {
const files = await getFilePaths();
const printContents = await readFilesQueue(files)
return printContents
}
printFiles()
PS
readFilesQueue在printFiles之外。由于console.log引入了副作用*，所以最好是模拟、测试或监视，因此，使用返回内容的函数（sidenuote）并不酷。
因此，代码可以简单地这样设计：三个独立的函数是“纯”**，不会产生任何副作用，处理整个列表，并且可以很容易地修改以处理失败的案例。
const files = await getFilesPath()
const printFile = async (file) => {
const content = await fs.readFile(file, 'utf8')
console.log(content)
}
const readFiles = async = (files, index = 0) => {
await printFile(files[index])
return files.lengh <= index
? readFiles(files, ++index)
: files
}
readFiles(files)
未来编辑/当前状态
节点支持顶级等待（它还没有插件，也不会有，可以通过和谐标志启用），这很酷，但不能解决一个问题（策略上我只在LTS版本上工作）。如何获取文件？
使用合成。给出代码后，我觉得这是在一个模块内，所以应该有一个函数来完成。如果没有，你应该使用IIFE将角色代码包装成一个异步函数，创建一个简单的模块，它可以为你做所有的事情，或者你可以采用正确的方式，即组合。
// more complex version with IIFE to a single module
(async (files) => readFiles(await files())(getFilesPath)
注意，变量的名称因语义而改变。您传递一个函子（一个可以被另一个函数调用的函数），并在内存中接收一个指针，该指针包含应用程序的初始逻辑块。
但是，如果不是模块，您需要导出逻辑？
将函数包装在异步函数中。
export const readFilesQueue = async () => {
// ... to code goes here
}
或者改变变量的名称。。。
*副作用是指应用程序的任何协同作用，它可以改变状态/行为或在应用程序中引入错误，如IO。
**通过“纯”，它是撇号，因为函数不是纯的，当没有控制台输出，只有数据操作时，代码可以聚合为纯版本。
除此之外，为了纯粹起见，您需要使用处理副作用的monad，这些monad容易出错，并将错误与应用程序分开处理。
