在循环中使用async/有什么问题吗？我正在尝试遍历文件数组和每个文件的内容。awaitforEachawait
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
当然代码确实可以工作，但我很确定它没有按照您的预期做。它只是触发多个异步调用，但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每个async回调函数调用都会返回一个 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)
}));
}
使用 ES2018，您可以大大简化上述所有答案：
async function printFiles () {
const files = await getFilePaths()
for await (const contents of files.map(file => fs.readFile(file, 'utf8'))) {
console.log(contents)
}
}
2018-09-10：这个答案最近引起了很多关注，有关异步迭代的更多信息，请参阅Axel Rauschmayer 的博客文章。
Promise.all我没有与 with 结合使用Array.prototype.map（它不能保证Promises 的解析顺序），而是使用以Array.prototype.reduceresolved 开头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());
}
npm 上的p-iteration模块实现了 Array 迭代方法，因此它们可以以非常直接的方式与 async/await 一起使用。
以您的情况为例：
const { forEach } = require('p-iteration');
const fs = require('fs-promise');
(async function printFiles () {
const files = await getFilePaths();
await forEach(files, async (file) => {
const contents = await fs.readFile(file, 'utf8');
console.log(contents);
});
})();
这里有一些forEachAsync原型。请注意，您需要await它们：
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 函数作为 foreach 参数。结果是无法预料的。当我对我的代码进行 3 次测试时，它运行了 2 次没有问题并且失败了 1 次。（有点奇怪）
最后我明白了，做了一些便笺簿测试。
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();
for - of循环作为上面的 @Bergi 建议
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();
我希望这对某人有帮助，美好的一天，干杯！
该解决方案还针对内存进行了优化，因此您可以在 10,000 个数据项和请求上运行它。这里的一些其他解决方案会使服务器在大型数据集上崩溃。
在打字稿中：
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 ...
})
除了@Bergi 的回答之外，我还想提供第三种选择。它与@Bergi 的第二个示例非常相似，但不是单独等待每个readFile，而是创建一个承诺数组，每个你在最后等待。
import fs from 'fs-promise';
async function printFiles () {
const files = await getFilePaths();
const promises = files.map((file) => fs.readFile(file, 'utf8'))
const contents = await Promise.all(promises)
contents.forEach(console.log);
}
请注意，传递给的函数.map()不需要是async，因为fs.readFile无论如何都会返回一个 Promise 对象。因此promises是一个 Promise 对象数组，可以发送到Promise.all().
在@Bergi 的回答中，控制台可能会按照读取的顺序记录文件内容。例如，如果一个非常小的文件在一个非常大的文件之前完成读取，它将首先被记录，即使小文件在数组中的大文件之后也是如此。files但是，在我上面的方法中，您可以保证控制台将以与提供的数组相同的顺序记录文件。
在一个文件中弹出几个方法非常容易，这些方法将按序列化顺序处理异步数据并为您的代码提供更传统的风格。例如：
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));
}
forEach()替换不起作用的等待循环的一个简单的插入式解决方案是forEach替换map并添加Promise.all(到开头。
例如：
await y.forEach(async (x) => {
至
await Promise.all(y.map(async (x) => {
最后需要一个额外)的。
@Bergi 已经给出了如何正确处理这种特殊情况的答案。我不会在这里复制。
我想解决使用forEach和for循环之间async的区别await
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)
}
所以，基本上callback返回一个承诺，因为它是用async. 内部forEach，callback只是以正常方式调用，如果回调本身返回一个promise，javascript引擎不会等待它被解析或拒绝。相反，它将 放入promise作业队列，并继续执行循环。
await fs.readFile(file, 'utf8')里面怎么样callback？
基本上，当你的 asynccallback有机会被执行时，js 引擎将暂停直到fs.readFile(file, 'utf8')被解决或拒绝，并在完成后恢复执行 async 函数。所以contents变量存储来自 的实际结果fs.readFile，而不是 a promise。因此，console.log(contents)注销文件内容而不是Promise
为什么for ... of有效？
当我们编写一个通用for of循环时，我们获得了比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)
}
}
当评估for循环时，我们await在函数内部有promise async，执行将暂停，直到awaitpromise 被解决。因此，您可以认为文件是按照确定的顺序逐一读取的。
依次执行
有时，我们确实需要按顺序执行异步函数。例如，我有一些新记录存储在要保存到数据库的数组中，我希望它们按顺序保存，这意味着数组中的第一条记录应该首先保存，然后是第二条，直到最后一条记录被保存。
这是一个例子：
const records = [1, 2, 3, 4];
async function saveRecord(record) {
return new Promise((resolved, rejected) => {
setTimeout(()=> {
resolved(`record ${record} saved`)
}, Math.random() * 500)
});
}
async function forEachSaveRecords(records) {
records.forEach(async (record) => {
const res = await saveRecord(record);
console.log(res);
})
}
async function forofSaveRecords(records) {
for (const record of records) {
const res = await saveRecord(record);
console.log(res);
}
}
(async () => {
console.log("=== for of save records ===")
await forofSaveRecords(records)
console.log("=== forEach save records ===")
await forEachSaveRecords(records)
})()我setTimeout用来模拟将记录保存到数据库的过程 - 它是异步的并且花费随机时间。使用forEach，记录以不确定的顺序保存，但使用for..of，它们按顺序保存。
Bergi 的解决方案在基于承诺的情况下效果很好fs。您可以使用bluebird,fs-extra或fs-promise为此。
但是， node 的原生库的解决方案fs如下：
const result = await Promise.all(filePaths
.map( async filePath => {
const fileContents = await getAssetFromCache(filePath, async function() {
// 1. Wrap with Promise
// 2. Return the result of the Promise
return await new Promise((res, rej) => {
fs.readFile(filePath, 'utf8', function(err, data) {
if (data) {
res(data);
}
});
});
});
return fileContents;
}));
注意：
require('fs')强制将函数作为第三个参数，否则抛出错误：
TypeError [ERR_INVALID_CALLBACK]: Callback must be a function
从循环中调用异步方法是不好的。这是因为每次循环迭代都会延迟到整个异步操作完成。这不是很高效。它还避免了async/的并行化优势await。
更好的解决方案是一次创建所有 Promise，然后使用Promise.all(). 否则，每个后续操作将在前一个操作完成之前不会开始。
因此，代码可以重构如下；
const printFiles = async () => {
const files = await getFilePaths();
const results = [];
files.forEach((file) => {
results.push(fs.readFile(file, 'utf8'));
});
const contents = await Promise.all(results);
console.log(contents);
}
上述两种解决方案都有效，但是，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)))
一个重要的警告是：await + for .. of方法和forEach + async方式实际上有不同的效果。
拥有await一个真正的for循环将确保所有异步调用都被一一执行。而且这种forEach + async方式会同时触发所有承诺，速度更快但有时会不堪重负（如果您执行一些数据库查询或访问一些有容量限制的 Web 服务并且不想一次触发 100,000 个调用）。
reduce + promise如果您不使用async/await并希望确保文件被一个接一个地读取，您也可以使用（不太优雅） 。
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);
}
}
只是添加到原来的答案
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);
}
}
就像@Bergi 的回应一样，但有一点不同。
Promise.all如果一个被拒绝，则拒绝所有承诺。
所以，使用递归。
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()
附言
readFilesQueue超出了printFiles由 引入的副作用* 的原因console.log，最好模拟、测试和/或监视，所以拥有一个返回内容的函数（旁注）并不酷。
因此，代码可以简单地设计为：三个独立的“纯”函数**并且没有引入副作用，处理整个列表并且可以轻松修改以处理失败的情况。
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)
未来编辑/当前状态
Node 支持顶级等待（它还没有插件，不会有并且可以通过和谐标志启用），它很酷但不能解决一个问题（从战略上讲，我只在 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，它们容易出错，并将该错误与应用程序分开处理。
目前 Array.forEach 原型属性不支持异步操作，但我们可以创建自己的 poly-fill 来满足我们的需求。
// 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}
就是这样！您现在可以在这些操作之后定义的任何数组上使用 async forEach 方法。
让我们测试一下...
// 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
... 等等 ：）
需要注意的一些事项：
Array.prototype.<yourAsyncFunc> = <yourAsyncFunc>都不会提供此功能今天我遇到了多种解决方案。在 forEach 循环中运行异步等待函数。通过构建包装器，我们可以做到这一点。
关于它如何在内部工作的更详细说明，对于本机 forEach 以及为什么它无法进行异步函数调用以及各种方法的其他详细信息在此处的链接中提供
可以通过多种方式完成，如下所示，
方法1：使用包装器。
await (()=>{
return new Promise((resolve,reject)=>{
items.forEach(async (item,index)=>{
try{
await someAPICall();
} catch(e) {
console.log(e)
}
count++;
if(index === items.length-1){
resolve('Done')
}
});
});
})();
方法二：和Array.prototype的泛型函数一样使用
Array.prototype.forEachAsync.js
if(!Array.prototype.forEachAsync) {
Array.prototype.forEachAsync = function (fn){
return new Promise((resolve,reject)=>{
this.forEach(async(item,index,array)=>{
await fn(item,index,array);
if(index === array.length-1){
resolve('done');
}
})
});
};
}
用法 ：
require('./Array.prototype.forEachAsync');
let count = 0;
let hello = async (items) => {
// Method 1 - Using the Array.prototype.forEach
await items.forEachAsync(async () => {
try{
await someAPICall();
} catch(e) {
console.log(e)
}
count++;
});
console.log("count = " + count);
}
someAPICall = () => {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve("done") // or reject('error')
}, 100);
})
}
hello(['', '', '', '']); // hello([]) empty array is also be handled by default
方法3：
使用 Promise.all
await Promise.all(items.map(async (item) => {
await someAPICall();
count++;
}));
console.log("count = " + count);
方法 4：传统的 for 循环或现代的 for 循环
// Method 4 - using for loop directly
// 1. Using the modern for(.. in..) loop
for(item in items){
await someAPICall();
count++;
}
//2. Using the traditional for loop
for(let i=0;i<items.length;i++){
await someAPICall();
count++;
}
console.log("count = " + count);
您可以使用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.prototype.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)
}
files.forEach(async (file) => { const contents = await fs.readFile(file, 'utf8') })
问题是，迭代函数返回的承诺被forEach(). 因此，所有fs.readFile函数都在同一轮事件循环中被调用，这意味着它们是并行启动的，而不是顺序启动的，并且在调用 forEach() 后立即继续执行，而无需等待所有fs.readFile操作完成。由于 forEach 不等待每个 Promise 解决，因此循环实际上在 Promise 解决之前完成迭代。您最终可能会尝试访问尚不可用的值。
使用 Task、futurize 和一个可遍历的 List，你可以简单地做
async function printFiles() {
const files = await getFiles();
List(files).traverse( Task.of, f => readFile( f, 'utf-8'))
.fork( console.error, console.log)
}
这是您的设置方式
import fs from 'fs';
import { futurize } from 'futurize';
import Task from 'data.task';
import { List } from 'immutable-ext';
const future = futurizeP(Task)
const readFile = future(fs.readFile)
构建所需代码的另一种方法是
const printFiles = files =>
List(files).traverse( Task.of, fn => readFile( fn, 'utf-8'))
.fork( console.error, console.log)
或者甚至更注重功能
// 90% of encodings are utf-8, making that use case super easy is prudent
// handy-library.js
export const readFile = f =>
future(fs.readFile)( f, 'utf-8' )
export const arrayToTaskList = list => taskFn =>
List(files).traverse( Task.of, taskFn )
export const readFiles = files =>
arrayToTaskList( files, readFile )
export const printFiles = files =>
readFiles(files).fork( console.error, console.log)
然后从父函数
async function main() {
/* awesome code with side-effects before */
printFiles( await getFiles() );
/* awesome code with side-effects after */
}
如果您真的想在编码中获得更大的灵活性，您可以这样做（为了好玩，我正在使用建议的Pipe Forward 运算符）
import { curry, flip } from 'ramda'
export const readFile = fs.readFile
|> future,
|> curry,
|> flip
export const readFileUtf8 = readFile('utf-8')
PS - 我没有在控制台上尝试这个代码，可能有一些错别字......“直自由泳，从圆顶顶部！” 正如 90 后的孩子所说。:-p
要查看如何出错，请在方法末尾打印 console.log。
一般可能出错的事情：
这些并不总是错误的，但经常出现在标准用例中。
通常，使用 forEach 将导致除最后一个之外的所有结果。它会在不等待函数的情况下调用每个函数，这意味着它告诉所有函数开始然后完成而不等待函数完成。
import fs from 'fs-promise'
async function printFiles () {
const files = (await getFilePaths()).map(file => fs.readFile(file, 'utf8'))
for(const file of files)
console.log(await file)
}
printFiles()
这是本机 JS 中的一个示例，它将保持顺序，防止函数过早返回并在理论上保持最佳性能。
这将：
使用此解决方案，第一个文件将在可用时立即显示，而无需先等待其他文件可用。
它还将同时加载所有文件，而不必等待第一个文件完成才能开始读取第二个文件。
此版本和原始版本的唯一缺点是，如果一次启动多个读取，则由于一次可能发生更多错误，因此处理错误会更加困难。
对于一次读取文件的版本，然后将在失败时停止，而不会浪费时间尝试读取更多文件。即使有一个精心设计的取消系统，也很难避免它在第一个文件上失败，但也已经读取了大多数其他文件。
性能并不总是可预测的。虽然许多系统使用并行文件读取会更快，但有些系统更喜欢顺序读取。有些是动态的，可能会在负载下发生变化，提供延迟的优化并不总是在激烈的争用下产生良好的吞吐量。
该示例中也没有错误处理。如果某些事情要求它们要么全部成功显示，要么根本不显示，它不会那样做。
建议在每个阶段使用 console.log 和假文件读取解决方案（改为随机延迟）进行深入实验。尽管许多解决方案在简单的情况下似乎都做了同样的事情，但它们都有细微的差异，需要一些额外的审查才能挤出来。
使用这个模拟来帮助区分解决方案：
(async () => {
const start = +new Date();
const mock = () => {
return {
fs: {readFile: file => new Promise((resolve, reject) => {
// Instead of this just make three files and try each timing arrangement.
// IE, all same, [100, 200, 300], [300, 200, 100], [100, 300, 200], etc.
const time = Math.round(100 + Math.random() * 4900);
console.log(`Read of ${file} started at ${new Date() - start} and will take ${time}ms.`)
setTimeout(() => {
// Bonus material here if random reject instead.
console.log(`Read of ${file} finished, resolving promise at ${new Date() - start}.`);
resolve(file);
}, time);
})},
console: {log: file => console.log(`Console Log of ${file} finished at ${new Date() - start}.`)},
getFilePaths: () => ['A', 'B', 'C', 'D', 'E']
};
};
const printFiles = (({fs, console, getFilePaths}) => {
return async function() {
const files = (await getFilePaths()).map(file => fs.readFile(file, 'utf8'));
for(const file of files)
console.log(await file);
};
})(mock());
console.log(`Running at ${new Date() - start}`);
await printFiles();
console.log(`Finished running at ${new Date() - start}`);
})();
编写自己的 asyncForEach
async function asyncForEach(array, callback) {
for (let index = 0; index < array.length; index++) {
await callback(array[index], index, array)
}
}
你可以像这样使用它
await asyncForEach(array, async function(item,index,array){
//await here
}
)
正如其他答案所提到的，您可能希望它按顺序而不是并行执行。IE。运行第一个文件，等到它完成，然后一旦它完成运行第二个文件。那不是会发生的。
我认为重要的是要解决为什么不会发生这种情况。
想想如何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的内部循环中，最终是. 该函数内部有一个，所以循环可能会在继续之前等待这个？forcb(arr[i])logFile(file)logFileawaitforawaiti++
不，不会的。令人困惑的是，这不是如何await工作的。从文档：
等待拆分执行流程，允许异步函数的调用者恢复执行。在 await 推迟了 async 函数的继续执行之后，随后的语句就会执行。如果此 await 是其函数执行的最后一个表达式，则继续通过向函数的调用者返回待处理的 Promise 以完成 await 的函数并恢复该调用者的执行。
因此，如果您有以下情况，则之前不会记录这些数字"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。不会因为做了一些事情而停止，也不会因为做了一些事情而停止。logNumbersmainlogNumbersawaitforEachlogFileawait
OP的原始问题
在 forEach 循环中使用 async/await 有什么问题吗？...
@Bergi's selected answer在一定程度上涵盖了该答案，该答案显示了如何串行和并行处理。然而，并行性还有其他问题 -
例如，如果一个非常小的文件在一个非常大的文件之前完成读取，它将首先被记录，即使文件数组中小文件在大文件之后也是如此。
一次打开数千个文件以同时读取它们也不好。人们总是需要评估顺序、并行或混合方法是否更好。
因此，让我们解决这些问题，展示简洁明了的实际代码，并且不使用第三方库。可以轻松剪切、粘贴和修改的东西。
最简单的改进是在@Bergi 的回答中执行完全并行，但做一个小改动，以便在保留 order 的同时尽快打印每个文件。
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);
})(),
]);
}
上面，两个单独的分支同时运行。
那很简单。
“并发限制”意味着不能同时N读取多个文件。
就像一家商店一次只允许这么多顾客进来（至少在 COVID 期间）。
首先介绍一个辅助函数——
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返回几个属性
promise类型Promiseboot类型函数()=>voidpromise人生有两个阶段
promiseboot()调用时从第一个状态转换到第二个状态。
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);
})(),
]);
}
和以前一样有两个分支
concurLimit现在的不同之处在于允许同时运行的承诺不超过承诺。
重要的变量是
boots：要调用的函数数组以强制其转换相应的承诺。它仅用于分支 1。set：随机访问容器中有承诺，因此一旦履行就可以轻松删除它们。此 contianer 仅在分支 1 中使用。bootableProms：这些是最初的 smae 承诺set，但它是一个数组而不是一个集合，并且该数组永远不会改变。它仅用于分支 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
与 Antonio Val 类似p-iteration，另一种 npm 模块是async-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）：
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();
如果您想同时迭代所有元素：
async function asyncForEach(arr, fn) {
await Promise.all(arr.map(fn));
}
如果您想非并发地迭代所有元素（例如，当您的映射函数有副作用或一次在所有数组元素上运行映射器时资源成本太高）：
选项 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);
}
}
如果你不能使用 async/await（IE11、旧打包器等），那么你可以试试这个递归函数。我用作fetch我的异步调用，但您可以使用任何返回承诺的函数。
var urlsToGet = ['https://google.com', 'https://yahoo.com'];
fetchOneAtATime(urlsToGet);
function fetchOneAtATime(urls) {
if (urls.length === 0) {
return;
}
fetch(urls[0]).finally(() => fetchOneAtATime(urls.slice(1)));
}
这不会按照 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)
})
我会使用经过充分测试（每周数百万次下载）的pify和async模块。如果您不熟悉异步模块，我强烈建议您查看它的文档。我已经看到多个开发人员浪费时间重新创建其方法，或者更糟糕的是，当高阶异步方法可以简化代码时，他们制作了难以维护的异步代码。
const async = require('async')
const fs = require('fs-promise')
const pify = require('pify')
async function getFilePaths() {
return Promise.resolve([
'./package.json',
'./package-lock.json',
]);
}
async function printFiles () {
const files = await getFilePaths()
await pify(async.eachSeries)(files, async (file) => { // <-- run in series
// await pify(async.each)(files, async (file) => { // <-- run in parallel
const contents = await fs.readFile(file, 'utf8')
console.log(contents)
})
console.log('HAMBONE')
}
printFiles().then(() => {
console.log('HAMBUNNY')
})
// ORDER OF LOGS:
// package.json contents
// package-lock.json contents
// HAMBONE
// HAMBUNNY
```您可以使用 async 包中的 async.forEach 循环：
async.forEach(dataToLoop(array), async(data, cb) => {
variable = await MongoQuery;
}, function(err) {
console.log(err);
})
})
.catch((err)=>{
console.log(err);
})