Devolución de llamada después de completar todas las devoluciones de llamada asíncronas para cada

Como sugiere el título. ¿Cómo hago esto?

Quiero llamar whenAllDone()después de que forEach-loop haya pasado por cada elemento y haya realizado un procesamiento asincrónico.

[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();
  }
);

¿Es posible hacer que funcione así? ¿Cuándo el segundo argumento para forEach es una función de devolución de llamada que se ejecuta una vez que pasó por todas las iteraciones?

Rendimiento esperado:

3 done
1 done
2 done
All done!

Array.forEach no proporciona esta bondad (oh si lo fuera) pero hay varias formas de lograr lo que desea:

Usando un contador simple

function callback () { console.log('all done'); }

var itemsProcessed = 0;

[1, 2, 3].forEach((item, index, array) => {
  asyncFunction(item, () => {
    itemsProcessed++;
    if(itemsProcessed === array.length) {
      callback();
    }
  });
});

(gracias a @vanuan y otros) Este enfoque garantiza que todos los elementos se procesen antes de invocar la devolución de llamada "hecho". Debe usar un contador que se actualice en la devolución de llamada. Dependiendo del valor del parámetro de índice no proporciona la misma garantía, porque el orden de retorno de las operaciones asincrónicas no está garantizado.

Usando promesas ES6

(una biblioteca prometedora se puede utilizar para navegadores antiguos):

1. Procese todas las solicitudes que garanticen la ejecución síncrona (por ejemplo, 1, luego 2 y 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'))

2. Procese todas las solicitudes asíncronas sin ejecución "sincrónica" (2 pueden finalizar más rápido que 1)

   let requests = [1,2,3].map((item) => {
       return new Promise((resolve) => {
         asyncFunction(item, resolve);
       });
   })
   
   Promise.all(requests).then(() => console.log('done'));

Usando una biblioteca asíncrona

Hay otras bibliotecas asincrónicas, asíncronas. es la más popular, que proporcionan mecanismos para expresar lo que desea.

El cuerpo de la pregunta se ha editado para eliminar el código de ejemplo sincrónico anterior, por lo que he actualizado mi respuesta para aclarar. El ejemplo original usaba código síncrono similar para modelar el comportamiento asíncrono, por lo que se aplica lo siguiente:

array.forEaches sincrónico y también lo es res.write, por lo que simplemente puede poner su devolución de llamada después de su llamada a foreach:

  posts.foreach(function(v, i) {
    res.write(v + ". index " + i);
  });

  res.end();

Si encuentra funciones asincrónicas y desea asegurarse de que antes de ejecutar el código finalice su tarea, siempre podemos utilizar la capacidad de devolución de llamada.

Por ejemplo:

var ctr = 0;
posts.forEach(function(element, index, array){
    asynchronous(function(data){
         ctr++; 
         if (ctr === array.length) {
             functionAfterForEach();
         }
    })
});

Nota: functionAfterForEaches la función que se ejecutará una vez finalizadas las tareas foreach. asynchronouses la función asincrónica ejecutada dentro de foreach.

Espero que esto solucione su problema, generalmente trabajo con esto cuando necesito ejecutar para cada uno con tareas asincrónicas dentro.

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
      } 
}

con

function doAsynchronousFunction(entry,callback){
       //asynchronousjob with entry
       callback();
}

¡Es extraño cuántas respuestas incorrectas se han dado al caso asincrónico ! Se puede mostrar simplemente que la comprobación del índice no proporciona el comportamiento esperado:

// INCORRECT
var list = [4000, 2000];
list.forEach(function(l, index) {
    console.log(l + ' started ...');
    setTimeout(function() {
        console.log(index + ': ' + l);
    }, l);
});

salida:

4000 started
2000 started
1: 2000
0: 4000

Si verificamos index === array.length - 1, se llamará a la devolución de llamada al finalizar la primera iteración, ¡mientras que el primer elemento aún está pendiente!

Para resolver este problema sin usar bibliotecas externas como async, creo que su mejor opción es guardar la longitud de la lista y disminuirla después de cada iteración. Dado que solo hay un hilo, estamos seguros de que no hay posibilidad de condición de carrera.

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);
});

Con ES2018 puede usar iteradores asíncronos:

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');
}

Mi solución sin promesa (esto asegura que cada acción finalice antes de que comience la siguiente):

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>

 var counter = 0;
 var listArray = [0, 1, 2, 3, 4];
 function callBack() {
     if (listArray.length === counter) {
         console.log('All Done')
     }
 };
 listArray.forEach(function(element){
     console.log(element);
     counter = counter + 1;
     callBack();
 });

Esta es la solución para Node.js que es asíncrona.

usando el paquete async npm.

(JavaScript) Sincronización para cada bucle con devoluciones de llamada dentro

Mi solución:

//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();
            }
        });
    }
});

Ejemplo:

var arr = ['a', 'b', 'c'];

arr.forEachDone(function(item){
    console.log(item);
}, function(){
   console.log('done');
});

// out: a b c done

Intento con Easy Way para resolverlo, compártelo contigo:

let counter = 0;
            arr.forEach(async (item, index) => {
                await request.query(item, (err, recordset) => {
                    if (err) console.log(err);

                    //do Somthings

                    counter++;
                    if(counter == tableCmd.length){
                        sql.close();
                        callback();
                    }
                });

requestes la función de la biblioteca mssql en el nodo js. Esto puede reemplazar cada función o código que desee. Buena suerte

var i=0;
const waitFor = (ms) => 
{ 
  new Promise((r) => 
  {
   setTimeout(function () {
   console.log('timeout completed: ',ms,' : ',i); 
     i++;
     if(i==data.length){
      console.log('Done')  
    }
  }, ms); 
 })
}
var data=[1000, 200, 500];
data.forEach((num) => {
  waitFor(num)
})

No debería necesitar una devolución de llamada para recorrer una lista. Simplemente agregue la end()llamada después del bucle.

posts.forEach(function(v, i){
   res.write(v + ". Index " + i);
});
res.end();

Una solución simple sería como seguir

function callback(){console.log("i am done");}

["a", "b", "c"].forEach(function(item, index, array){
    //code here
    if(i == array.length -1)
    callback()
}

¿Qué tal setInterval, para verificar el recuento completo de iteraciones, trae garantía? no estoy seguro de si no sobrecargará el alcance, pero lo uso y parece ser el indicado

_.forEach(actual_JSON, function (key, value) {

     // run any action and push with each iteration 

     array.push(response.id)

});


setInterval(function(){

    if(array.length > 300) {

        callback()

    }

}, 100);