正如标题所示，我该如何做到这一点？
我想在forEach循环已经遍历了每个元素并完成了一些异步处理之后调用whenAllDone()。
[1, 2, 3].forEach(
function(item, index, array, done) {
asyncFunction(item, function itemDone() {
console.log(item + " done");
done();
});
}, function allDone() {
console.log("All done");
whenAllDone();
}
);
能够像这样使它工作吗？当forEach的第二个参数是一个回调函数，它会在遍历所有迭代之后运行一次？
期望输出：
3 done
1 done
2 done
All done!
Array.forEach没有提供这种便利（如果它能）但是有几种方法可以实现你想要的：
function callback () { console.log('all done'); }
var itemsProcessed = 0;
[1, 2, 3].forEach((item, index, array) => {
asyncFunction(item, () => {
itemsProcessed++;
if(itemsProcessed === array.length) {
callback();
}
});
});
（可以为旧浏览器使用Promise库）：
Process all requests guaranteeing synchronous execution (e.g. 1 then 2 then 3)
function asyncFunction (item, cb) {
setTimeout(() => {
console.log('done with', item);
cb();
}, 100);
}
let requests = [1, 2, 3].reduce((promiseChain, item) => {
return promiseChain.then(() => new Promise((resolve) => {
asyncFunction(item, resolve);
}));
}, Promise.resolve());
requests.then(() => console.log('done'))
Process all async requests without "synchronous" execution (2 may finish faster than 1)
let requests = [1,2,3].map((item) => {
return new Promise((resolve) => {
asyncFunction(item, resolve);
});
})
Promise.all(requests).then(() => console.log('done'));
还有其他异步库，async 是最受欢迎的，它提供了表达你想要的内容的机制。
问题的主体已经被编辑以删除之前同步示例代码，因此我更新了我的答案以澄清。
原始示例使用同步代码来模拟异步行为，因此以下内容适用：
array.forEach是同步的，res.write也是如此，因此您可以在调用foreach后直接放置回调函数：
posts.foreach(function(v, i) {
res.write(v + ". index " + i);
});
res.end();
if (index === array.length - 1)，并删除 itemsProcessed 呢？ - Amin Jafariif(index === array.length) { 而不是 if(itemsProcessed === array.length) {？这样可以节省一个变量的内存和增量处理。 - Inzamam Malikvar ctr = 0;
posts.forEach(function(element, index, array){
asynchronous(function(data){
ctr++;
if (ctr === array.length) {
functionAfterForEach();
}
})
});
functionAfterForEach是在foreach任务完成后要执行的函数。asynchronous是在foreach内部执行的异步函数。希望这可以解决你的问题，我通常在需要执行异步任务的forEach时使用它。
foo = [a,b,c,d];
waiting = foo.length;
foo.forEach(function(entry){
doAsynchronousFunction(entry,finish) //call finish after each entry
}
function finish(){
waiting--;
if (waiting==0) {
//do your Job intended to be done after forEach is completed
}
}
function doAsynchronousFunction(entry,callback){
//asynchronousjob with entry
callback();
}
很奇怪，有这么多错误答案被给出来了关于 异步 的情况！简单地说，检查索引并不能提供预期的行为：
// INCORRECT
var list = [4000, 2000];
list.forEach(function(l, index) {
console.log(l + ' started ...');
setTimeout(function() {
console.log(index + ': ' + l);
}, l);
});
输出：
4000 started
2000 started
1: 2000
0: 4000
如果我们检查 index === array.length - 1，回调函数将在第一次迭代完成时被调用，而第一个元素仍然是未决的！
为了解决这个问题，不使用外部库（如async），我认为你最好的选择是保存列表长度并在每次迭代后递减。由于只有一个线程，我们可以确保没有竞争条件。
var list = [4000, 2000];
var counter = list.length;
list.forEach(function(l, index) {
console.log(l + ' started ...');
setTimeout(function() {
console.log(index + ': ' + l);
counter -= 1;
if ( counter === 0)
// call your callback here
}, l);
});
使用ES2018，您可以使用异步迭代器：
const asyncFunction = a => fetch(a);
const itemDone = a => console.log(a);
async function example() {
const arrayOfFetchPromises = [1, 2, 3].map(asyncFunction);
for await (const item of arrayOfFetchPromises) {
itemDone(item);
}
console.log('All done');
}
itemDone函数调用仍将在最后执行。 - undefined我提供了一个没有使用Promise的解决方案（这确保每个动作在下一个动作开始之前都已经结束）：
Array.prototype.forEachAsync = function (callback, end) {
var self = this;
function task(index) {
var x = self[index];
if (index >= self.length) {
end()
}
else {
callback(self[index], index, self, function () {
task(index + 1);
});
}
}
task(0);
};
var i = 0;
var myArray = Array.apply(null, Array(10)).map(function(item) { return i++; });
console.log(JSON.stringify(myArray));
myArray.forEachAsync(function(item, index, arr, next){
setTimeout(function(){
$(".toto").append("<div>item index " + item + " done</div>");
console.log("action " + item + " done");
next();
}, 300);
}, function(){
$(".toto").append("<div>ALL ACTIONS ARE DONE</div>");
console.log("ALL ACTIONS ARE DONE");
});<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div class="toto">
</div>这个主题上有许多解决方案和方法来实现此目标！
但是，如果您需要使用 map 和 async/await 来完成此操作，则可以按如下方式进行。
// Execution Starts
console.log("start")
// The Map will return promises
// the Execution will not go forward until all the promises are resolved.
await Promise.all(
[1, 2, 3].map( async (item) => {
await asyncFunction(item)
})
)
// Will only run after all the items have resolved the asynchronous function.
console.log("End")
start
2
3
1
end
注意：如果在 map 中使用 await，它将始终返回一个 Promise 数组。
我的解决方案：
//Object forEachDone
Object.defineProperty(Array.prototype, "forEachDone", {
enumerable: false,
value: function(task, cb){
var counter = 0;
this.forEach(function(item, index, array){
task(item, index, array);
if(array.length === ++counter){
if(cb) cb();
}
});
}
});
//Array forEachDone
Object.defineProperty(Object.prototype, "forEachDone", {
enumerable: false,
value: function(task, cb){
var obj = this;
var counter = 0;
Object.keys(obj).forEach(function(key, index, array){
task(obj[key], key, obj);
if(array.length === ++counter){
if(cb) cb();
}
});
}
});
例子：
var arr = ['a', 'b', 'c'];
arr.forEachDone(function(item){
console.log(item);
}, function(){
console.log('done');
});
// out: a b c done
$(document).ready(function(){
let arr = ["a1", "a2", "a3","a1", "a2", "a3","a1", "a2", "a3","a1", "a2", "a3","a1", "a2", "a3"];
let motherArray = new Array();
let arrayPushDone = arr.reduce((prevPromise, currentValue)=>{
return prevPromise.then(()=>{
console.log("currentValue: ", currentValue);
return new Promise((resolve) =>resolve(motherArray.push(currentValue)));
});
}, Promise.resolve());
arrayPushDone.then(()=>console.log("array push done: ", motherArray));
});
forEach方法有一个done回调参数和一个allDone回调，那就太好了！ - Vanuan