Devolución de llamada después de terminar for-loop en node.js

Question

Necesito ayuda con la naturaleza asincrónica de node.js. Tengo un bucle for, que recopila datos de la base de datos. "resultado" es una matriz, que luego debería devolverse a la función principal.

user_collection.findOne({ 
      _id : uid 
     }, function(error, user) { 
      if(error) 
       callback(error) 
      else { 
       for(var j = 0; j < user.contacts.length; j++) { 
        if(user.contacts[j].accepted == 'true') { 
         user_collection.findOne({ 
          _id : user.contacts[j].contactId 
         }, function(error, user) { 
          result.push(user); 
         }) 
        } 
       } 
       callback(null, result); // This callback executes before the for-loop ends, ofc 
      } 
     }); 

¿Cómo puedo garantizar que la devolución de llamada se ejecute una vez finalizado el ciclo?

Answer 1

Es posible que desee considerar el uso de una biblioteca de ayuda como asíncrono https://github.com/caolan/async

Ayuda a mantener el código más consistente ..

En su caso, usted puede mirar en el forEach() método

forEach(arr, iterator, callback) 

Se llama al iterador con un elemento de la lista y una devolución de llamada cuando finaliza.

de partida de los pruebas de unidad para los ejemplos

https://github.com/caolan/async/blob/master/mocha_test/each.js

Answer 2

Con v1.5.2 de Async.js, Es each.

each(arr, iterator, [callback]) 

arr - Una matriz para iterar sobre.
iterador (artículo, devolución de llamada) - Una función para aplicar a cada elemento en arr.
devolución de llamada (err) - Opcional. Una devolución de llamada que se llama cuando todas las funciones del iterador han terminado, o se produce un error.

Answer 3

Usando ES6 Promises (una biblioteca promesa se puede utilizar para navegadores antiguos):

Proceso de todas las solicitudes que garantizan la ejecución síncrona (por ejemplo 1 a continuación 2 a continuación, 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')) 

Proceso de todas las solicitudes asíncronas sin "sincrónica" ejecución (2 puede terminar 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')); 

lo hice en ese camino

Promise.all(body.schedules.map(function(scheduleId) { 
     return new Promise(function(resolve, reject) { 
      return scheduleSchema.findOneAndRemove({ 
        _id: scheduleId 
       }) 
       .then(function() { 
        logSchema.insert({ 
         userId: req.user.id, 
         actId: constants.LOG_SCHEDULE_DELETE.id, 
         extData: scheduleId 
        }); 
        resolve(); 
       }) 
       .catch(function(err) { 
        reject(err); 
       }); 
     }); 
    })).then(function() { 
     return res.json({ 
      code: constants.SUCCESS_CODE 
     }); 
    }).catch(function(err) { 
     return res.json(constants.DATABASE_ERROR); 
    }); 

El último ejemplo

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

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

Esto no garantiza que la devolución de llamada se ejecutará después de que todos los artículos se procesan. Solo garantiza que la devolución de llamada se ejecutará después de procesar el último elemento.

More information

Michael.