Javascript에서 비동기 작업이 완료되기를 기다리는 가장 간단한 방법은 무엇입니까?

mongodb 컬렉션을 삭제하고 싶지만 비동기 작업입니다. 코드는 다음과 같습니다.

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

콘솔에 다음이 표시됩니다.

all dropped
dropped
dropped
dropped

all dropped모든 컬렉션이 삭제 된 후 인쇄 되도록하는 가장 간단한 방법은 무엇입니까 ? 타사를 사용하여 코드를 단순화 할 수 있습니다.

나는 당신이 사용하고 mongoose있으므로 서버 측 JavaScript에 대해 이야기하고 있습니다. 이 경우의 I 조언에보고 비동기 모듈 및 사용 async.parallel(...). 이 모듈은 정말 도움이 될 것입니다. 문제를 해결하기 위해 개발되었습니다. 코드는 다음과 같습니다.

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

약속을 사용하십시오 .

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

이렇게하면 각 컬렉션을 삭제하고 각 컬렉션 후에 "dropped"를 인쇄 한 다음 완료되면 "all drop"을 인쇄합니다. 오류가 발생하면에 표시됩니다 stderr.

이전 답변 (이는 Promises에 대한 Node의 기본 지원 이전 날짜) :

Q promise 또는 Bluebird promise를 사용하세요 .

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

와 블루 버드 :

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

이를 수행하는 방법은 공유 카운터를 업데이트하는 콜백을 태스크에 전달하는 것입니다. 공유 카운터가 0에 도달하면 모든 작업이 완료된 것이므로 정상적인 흐름을 계속할 수 있습니다.

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

물론 이런 종류의 코드를보다 일반적이거나 재사용 가능하게 만드는 방법은 여러 가지가 있으며, 많은 비동기 프로그래밍 라이브러리 에는 이러한 종류의 작업을 수행하는 기능이 적어도 하나는 있어야합니다.

@freakish 답변을 확장하면 async는 각 방법을 제공하며 특히 귀하의 경우에 적합합니다.

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, 이것은 코드를 더 효율적이고 더 읽기 쉽게 만듭니다. 나는 제거의 자유를 얻었습니다 console.log('dropped')-원한다면 이것을 대신 사용하십시오.

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

외부 라이브러리없이이 작업을 수행합니다.

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

모든 답변은 아주 오래되었습니다. 2013 년 초부터 Mongoose는 모든 쿼리에 대해 점진적으로 약속 을 지원하기 시작 했으므로 앞으로 필요한 순서로 여러 비동기 호출을 구성하는 데 권장되는 방법이 될 것입니다.

와 deferred(다른 약속 / 연기 구현) 당신이 할 수 있습니다 :

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

Babel 또는 그러한 트랜스 파일러를 사용하고 async / await를 사용하는 경우 다음을 수행 할 수 있습니다.

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