在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));
}
请注意，虽然您可以将其包含在自己的代码中，但不应将其包含到您分发给其他人的库中（以避免污染其全局）。
其他回答
此解决方案还对内存进行了优化，因此您可以在10000个数据项和请求上运行它。这里的一些其他解决方案将使大型数据集上的服务器崩溃。
在TypeScript中：
export async function asyncForEach<T>(array: Array<T>, callback: (item: T, index: number) => Promise<void>) {
for (let index = 0; index < array.length; index++) {
await callback(array[index], index);
}
}
如何使用？
await asyncForEach(receipts, async (eachItem) => {
await ...
})
一个重要的警告是：等待+等待。。of方法和forEach+异步方式实际上有不同的效果。
在真正的for循环中等待将确保所有异步调用都逐一执行。forEach+异步方式将同时发出所有的承诺，这会更快，但有时会不堪重负（如果您执行一些DB查询或访问一些具有容量限制的web服务，并且不想一次发出100000个呼叫）。
如果您不使用async/await，并且希望确保一个接一个地读取文件，那么也可以使用reduce+promise（不太优雅）。
files.reduce((lastPromise, file) =>
lastPromise.then(() =>
fs.readFile(file, 'utf8')
), Promise.resolve()
)
或者您可以创建一个forEachAsync来帮助，但基本上使用相同的for循环底层。
Array.prototype.forEachAsync = async function(cb){
for(let x of this){
await cb(x);
}
}
在一个文件中弹出几个方法，以串行化的顺序处理异步数据，并为代码提供更传统的风格，这是非常轻松的。例如：
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));
}
您可以使用async包中的async.forEach循环：
async.forEach(dataToLoop(array), async(data, cb) => {
variable = await MongoQuery;
}, function(err) {
console.log(err);
})
})
.catch((err)=>{
console.log(err);
})
我会使用经过良好测试（每周下载数百万次）的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内容//汉堡//汉布尼```
