¿La forma más sencilla de esperar que se completen algunas tareas asincrónicas, en Javascript?

Quiero eliminar algunas colecciones de mongodb, pero esa es una tarea asincrónica. El código será:

var mongoose = require('mongoose');

mongoose.connect('mongo://localhost/xxx');

var conn = mongoose.connection;

['aaa','bbb','ccc'].forEach(function(name){
    conn.collection(name).drop(function(err) {
        console.log('dropped');
    });
});
console.log('all dropped');

La consola muestra:

all dropped
dropped
dropped
dropped

¿Cuál es la forma más sencilla de asegurarse de all droppedque se imprima después de que se hayan eliminado todas las colecciones? Se puede utilizar cualquier tercero para simplificar el código.

Veo que está utilizando, mongoosepor lo que está hablando de JavaScript del lado del servidor. En ese caso, aconsejo mirar el módulo async y usar async.parallel(...). Este módulo le resultará realmente útil: fue desarrollado para resolver el problema con el que está luchando. Tu código puede verse así

var async = require('async');

var calls = [];

['aaa','bbb','ccc'].forEach(function(name){
    calls.push(function(callback) {
        conn.collection(name).drop(function(err) {
            if (err)
                return callback(err);
            console.log('dropped');
            callback(null, name);
        });
    }
)});

async.parallel(calls, function(err, result) {
    /* this code will run after all calls finished the job or
       when any of the calls passes an error */
    if (err)
        return console.log(err);
    console.log(result);
});

Utilice promesas .

var mongoose = require('mongoose');

mongoose.connect('your MongoDB connection string');
var conn = mongoose.connection;

var promises = ['aaa', 'bbb', 'ccc'].map(function(name) {
  return new Promise(function(resolve, reject) {
    var collection = conn.collection(name);
    collection.drop(function(err) {
      if (err) { return reject(err); }
      console.log('dropped ' + name);
      resolve();
    });
  });
});

Promise.all(promises)
.then(function() { console.log('all dropped)'); })
.catch(console.error);

Esto descarta cada colección, imprimiendo "descartadas" después de cada una y luego imprime "todas descartadas" cuando se completa. Si ocurre un error, se muestra a stderr.

Respuesta anterior (esto es anterior al soporte nativo de Node para Promises):

Use promesas Q o promesas Bluebird .

Con Q :

var Q = require('q');
var mongoose = require('mongoose');

mongoose.connect('your MongoDB connection string');
var conn = mongoose.connection;

var promises = ['aaa','bbb','ccc'].map(function(name){
    var collection = conn.collection(name);
    return Q.ninvoke(collection, 'drop')
      .then(function() { console.log('dropped ' + name); });
});

Q.all(promises)
.then(function() { console.log('all dropped'); })
.fail(console.error);

Con Bluebird :

var Promise = require('bluebird');
var mongoose = Promise.promisifyAll(require('mongoose'));

mongoose.connect('your MongoDB connection string');
var conn = mongoose.connection;

var promises = ['aaa', 'bbb', 'ccc'].map(function(name) {
  return conn.collection(name).dropAsync().then(function() {
    console.log('dropped ' + name);
  });
});

Promise.all(promises)
.then(function() { console.log('all dropped'); })
.error(console.error);

La forma de hacerlo es pasar a las tareas una devolución de llamada que actualiza un contador compartido. Cuando el contador compartido llegue a cero, sabrá que todas las tareas han finalizado para que pueda continuar con su flujo normal.

var ntasks_left_to_go = 4;

var callback = function(){
    ntasks_left_to_go -= 1;
    if(ntasks_left_to_go <= 0){
         console.log('All tasks have completed. Do your stuff');
    }
}

task1(callback);
task2(callback);
task3(callback);
task4(callback);

Por supuesto, hay muchas formas de hacer que este tipo de código sea más genérico o reutilizable y cualquiera de las muchas bibliotecas de programación asíncrona que existen debería tener al menos una función para hacer este tipo de cosas.

Ampliando la respuesta @freakish, async también ofrece cada método, que parece especialmente adecuado para su caso:

var async = require('async');

async.each(['aaa','bbb','ccc'], function(name, callback) {
    conn.collection(name).drop( callback );
}, function(err) {
    if( err ) { return console.log(err); }
    console.log('all dropped');
});

En mi humilde opinión, esto hace que el código sea más eficiente y más legible. Me he tomado la libertad de eliminar el console.log('dropped'), si lo desea, use esto en su lugar:

var async = require('async');

async.each(['aaa','bbb','ccc'], function(name, callback) {
    // if you really want the console.log( 'dropped' ),
    // replace the 'callback' here with an anonymous function
    conn.collection(name).drop( function(err) {
        if( err ) { return callback(err); }
        console.log('dropped');
        callback()
    });
}, function(err) {
    if( err ) { return console.log(err); }
    console.log('all dropped');
});

Hago esto sin bibliotecas externas:

var yourArray = ['aaa','bbb','ccc'];
var counter = [];

yourArray.forEach(function(name){
    conn.collection(name).drop(function(err) {
        counter.push(true);
        console.log('dropped');
        if(counter.length === yourArray.length){
            console.log('all dropped');
        }
    });                
});

Todas las respuestas son bastante antiguas. Desde principios de 2013, Mongoose comenzó a admitir promesas gradualmente para todas las consultas, por lo que supongo que esa sería la forma recomendada de estructurar varias llamadas asíncronas en el orden requerido en el futuro.

Con deferred(otra promesa / implementación diferida) puede hacer:

// Setup 'pdrop', promise version of 'drop' method
var deferred = require('deferred');
mongoose.Collection.prototype.pdrop =
    deferred.promisify(mongoose.Collection.prototype.drop);

// Drop collections:
deferred.map(['aaa','bbb','ccc'], function(name){
    return conn.collection(name).pdrop()(function () {
      console.log("dropped");
    });
}).end(function () {
    console.log("all dropped");
}, null);

Si está usando Babel o tales transpilers y usa async / await, puede hacer:

function onDrop() {
   console.log("dropped");
}

async function dropAll( collections ) {
   const drops = collections.map(col => conn.collection(col).drop(onDrop) );
   await drops;
   console.log("all dropped");
}