Le moyen le plus simple d'attendre la fin de certaines tâches asynchrones, en Javascript?

Je veux supprimer certaines collections mongodb, mais c'est une tâche asynchrone. Le code sera:

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 console affiche:

all dropped
dropped
dropped
dropped

Quelle est la manière la plus simple de s'assurer all droppedqu'elle sera imprimée une fois que toutes les collections auront été supprimées? N'importe quel tiers peut être utilisé pour simplifier le code.

Je vois que vous utilisez mongoosedonc vous parlez de JavaScript côté serveur. Dans ce cas, je conseille de regarder le module async et de l'utiliser async.parallel(...). Vous trouverez ce module très utile - il a été développé pour résoudre le problème avec lequel vous êtes aux prises. Votre code peut ressembler à ceci

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

Utilisez des promesses .

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

Cela supprime chaque collection, l'impression «abandonnée» après chacune d'elles, puis imprime «tout abandonné» une fois terminé. Si une erreur se produit, elle s'affiche sous stderr.

Réponse précédente (ceci est antérieur au support natif de Node pour Promises):

Utilisez les promesses Q ou les promesses Bluebird .

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

Avec 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 façon de le faire est de transmettre aux tâches un rappel qui met à jour un compteur partagé. Lorsque le compteur partagé atteint zéro, vous savez que toutes les tâches sont terminées afin que vous puissiez continuer votre flux 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);

Bien sûr, il existe de nombreuses façons de rendre ce type de code plus générique ou réutilisable et n'importe laquelle des nombreuses bibliothèques de programmation asynchrone devrait avoir au moins une fonction pour faire ce genre de chose.

En développant la réponse @freakish, async propose également une méthode à chaque, qui semble particulièrement adaptée à votre cas:

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

À mon humble avis, cela rend le code à la fois plus efficace et plus lisible. J'ai pris la liberté de supprimer le console.log('dropped')- si vous le souhaitez, utilisez ceci à la place:

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

Je fais cela sans bibliothèques externes:

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

Toutes les réponses sont assez anciennes. Depuis le début de 2013, Mongoose a commencé à prendre en charge les promesses progressivement pour toutes les requêtes, ce serait donc la manière recommandée de structurer plusieurs appels asynchrones dans l'ordre requis à l'avenir, je suppose.

Avec deferred(une autre promesse / mise en œuvre différée), vous pouvez faire:

// 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 vous utilisez Babel ou de tels transpilers et utilisez async / await, vous pouvez faire:

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