La forma más sencilla de esperar a que se completen algunas tareas asíncronas, en Javascript?

Use 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 elimina cada colección, imprimiendo "dropped" después de cada una, y luego imprime "all dropped" cuando se completa. Si se produce un error, se muestra en stderr.

Respuesta anterior (esto es anterior al soporte nativo del Nodo para Promises):

Use Qpromesas o promesas de 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 llega a cero, sabe que todas las tareas han terminado 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 maneras 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ían tener al menos una función para hacer este tipo de cosas.

Ampliando la respuesta @ freakish, async también ofrece un método cada, 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, utilice 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 externas bibliotecas:

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 Mangoose comenzó a soportar promises gradualmente para todas las consultas, por lo que supongo que esa sería la forma recomendada de estructurar varias llamadas asincrónicas en el orden requerido en el futuro.

Si está utilizando Babel o dichos transpilers y utilizando async / await, puede hacer lo siguiente:

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

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