在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，所以我只想问问这是否有问题。
当前回答
下面是一些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));
}
请注意，虽然您可以将其包含在自己的代码中，但不应将其包含到您分发给其他人的库中（以避免污染其全局）。
其他回答
只是在原有答案的基础上
原始答案中的平行阅读语法有时令人困惑且难以理解，也许我们可以用不同的方法来编写
async function printFiles() {
const files = await getFilePaths();
const fileReadPromises = [];
const readAndLogFile = async filePath => {
const contents = await fs.readFile(file, "utf8");
console.log(contents);
return contents;
};
files.forEach(file => {
fileReadPromises.push(readAndLogFile(file));
});
await Promise.all(fileReadPromises);
}
用于顺序操作，而不仅仅用于。。。的，循环的正常值也将起作用
async function printFiles() {
const files = await getFilePaths();
for (let i = 0; i < files.length; i++) {
const file = files[i];
const contents = await fs.readFile(file, "utf8");
console.log(contents);
}
}
@贝吉已经给出了如何正确处理这一特殊案件的答案。我不会在这里重复。
我想解决在异步和等待时使用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。。的，它们按顺序保存。
您可以使用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)
}
对于TypeScript用户，使用工作类型的Promise.all（array.map（迭代器））包装器
使用Promise.all（array.map（迭代器））具有正确的类型，因为TypeScript的stdlib支持已经处理了泛型。然而，每次需要异步映射时复制粘贴Promise.all（array.map（迭代器））显然不是最佳的，Promise.all（array.ma（迭代））并不能很好地传达代码的意图，因此大多数开发人员都会将其包装成一个asyncMap（）包装函数。然而，要做到这一点，需要使用泛型来确保使用const value＝await asyncMap（）设置的值具有正确的类型。
export const asyncMap = async <ArrayItemType, IteratorReturnType>(
array: Array<ArrayItemType>,
iterator: (
value: ArrayItemType,
index?: number
) => Promise<IteratorReturnType>
): Promise<Array<IteratorReturnType>> => {
return Promise.all(array.map(iterator));
};
快速测试：
it(`runs 3 items in parallel and returns results`, async () => {
const result = await asyncMap([1, 2, 3], async (item: number) => {
await sleep(item * 100);
return `Finished ${item}`;
});
expect(result.length).toEqual(3);
// Each item takes 100, 200 and 300ms
// So restricting this test to 300ms plus some leeway
}, 320);
sleep（）只是：
const sleep = async (timeInMs: number): Promise<void> => {
return new Promise((resolve) => setTimeout(resolve, timeInMs));
};
图片值1000字-仅用于顺序方法
背景：昨晚我也遇到了类似的情况。我使用异步函数作为foreach参数。结果是不可预测的。当我对代码进行了3次测试时，它运行了2次没有问题，1次失败。（有些奇怪）
最后我改变了主意，做了一些擦试板测试。
场景1-foreach中的异步如何实现不连续
const getPromise = (time) => {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(`Promise resolved for ${time}s`)
}, time)
})
}
const main = async () => {
const myPromiseArray = [getPromise(1000), getPromise(500), getPromise(3000)]
console.log('Before For Each Loop')
myPromiseArray.forEach(async (element, index) => {
let result = await element;
console.log(result);
})
console.log('After For Each Loop')
}
main();
场景2-使用上面@Bergi建议的for-of循环
const getPromise = (time) => {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(`Promise resolved for ${time}s`)
}, time)
})
}
const main = async () => {
const myPromiseArray = [getPromise(1000), getPromise(500), getPromise(3000)]
console.log('Before For Each Loop')
// AVOID USING THIS
// myPromiseArray.forEach(async (element, index) => {
// let result = await element;
// console.log(result);
// })
// This works well
for (const element of myPromiseArray) {
let result = await element;
console.log(result)
}
console.log('After For Each Loop')
}
main();
如果你是像我这样的小老派，你可以简单地使用经典for循环，这也很有效：）
const getPromise = (time) => {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(`Promise resolved for ${time}s`)
}, time)
})
}
const main = async () => {
const myPromiseArray = [getPromise(1000), getPromise(500), getPromise(3000)]
console.log('Before For Each Loop')
// AVOID USING THIS
// myPromiseArray.forEach(async (element, index) => {
// let result = await element;
// console.log(result);
// })
// This works well too - the classic for loop :)
for (let i = 0; i < myPromiseArray.length; i++) {
const result = await myPromiseArray[i];
console.log(result);
}
console.log('After For Each Loop')
}
main();
我希望这对某人有所帮助，祝你愉快！
