Najprostszy sposób na czekanie na zakończenie niektórych zadań asynchronicznych w JavaScript?

Chcę usunąć niektóre kolekcje mongodb, ale jest to zadanie asynchroniczne. Kod będzie wyglądał następująco:

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

Konsola wyświetla:

all dropped
dropped
dropped
dropped

Jaki jest najprostszy sposób, aby upewnić się, że all droppedzostanie wydrukowany po upuszczeniu wszystkich kolekcji? Aby uprościć kod, można użyć dowolnej firmy zewnętrznej.

Widzę, że używasz, mongoosewięc mówisz o JavaScript po stronie serwera. W takim razie radzę spojrzeć na moduł asynchroniczny i użyć async.parallel(...). Ten moduł okaże się bardzo pomocny - został opracowany, aby rozwiązać problem, z którym się borykasz. Twój kod może wyglądać tak

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

Użyj obietnic .

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

Spowoduje to usunięcie każdej kolekcji, drukowanie „porzuconych” po każdej z nich, a następnie wydrukowanie „wszystkich usuniętych” po zakończeniu. Jeśli wystąpi błąd, zostanie wyświetlony stderr.

Poprzednia odpowiedź (poprzedza natywną obsługę obietnic przez Node):

Użyj obietnic Q lub obietnic Bluebird .

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

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

Można to zrobić, przekazując zadaniom wywołanie zwrotne, które aktualizuje udostępniony licznik. Kiedy wspólny licznik osiągnie zero, wiesz, że wszystkie zadania zostały zakończone, więc możesz kontynuować normalny przepływ.

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

Oczywiście istnieje wiele sposobów na uczynienie tego rodzaju kodu bardziej ogólnym lub wielokrotnego użytku, a każda z wielu bibliotek programowania asynchronicznego powinna mieć co najmniej jedną funkcję do tego rodzaju.

Rozwijając @freakish odpowiedź, async oferuje również każdą metodę, która wydaje się szczególnie odpowiednia dla twojego przypadku:

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

IMHO, dzięki temu kod jest zarówno wydajniejszy, jak i bardziej czytelny. Pozwoliłem sobie usunąć console.log('dropped')- jeśli chcesz, użyj zamiast tego:

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

Robię to bez zewnętrznych bibliotek:

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

Wszystkie odpowiedzi są dość stare. Od początku 2013 roku Mongoose zaczął stopniowo obsługiwać obietnice dla wszystkich zapytań, więc myślę, że byłby to zalecany sposób tworzenia struktury kilku wywołań asynchronicznych w wymaganej kolejności.

Dzięki deferred(kolejnej obietnicy / odroczonej realizacji) możesz:

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

Jeśli używasz Babel lub takich transpilerów i używasz async / await, możesz zrobić:

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