Javascript 如何在使用Nodejs调用回调函数之前等待N个查询完成

我试图创建一个函数，该函数需要数据库并返回对象列表，对于每个对象，我需要查询数据库并返回所有查询的结果

如何等待所有查询完成，或者我应该以同步方式完成它们？如果是，怎么做？我不应该利用这一事实，即它们都是select查询，彼此不依赖，所以并行运行它们以优化时间？那是个糟糕的设计吗？或者我应该为此使用存储过程

getTopActiveUsers:function(callback) {
    pool.connect(function (err, client, done) {
        if (err)
            callback(null, err);
        else {
            User.finAll(client,function(users) {
                for(var i=0;i<users.length;i++) {
                    Application.findByUser(users[i].id,function(applications) {
                        // here i have the applications for user i
                    })
                }
                // need to call the callback function when all queries finishes
            })
        }
    });
}

getTopActiveUsers:函数（回调）{
连接（函数（错误、客户端、完成）{
如果（错误）
回调（null，err）；
否则{
User.finAll（客户端、函数（用户）{
for（var i=0；i异步库是为您准备的。并行方法并行执行您的所有请求，并等待它们全部完成

getTopActiveUsers : function(callback) {
pool.connect(function(err, client, done) {
    if (err) {
        callback(null, err);
    } else {
        User.finAll(client, function(users) {
            var requests = [];

            for (var i = 0; i < users.length; i++) {
                requests.push(function(asyncCallback) {
                    Application.findByUser(users[i].id, function(applications) {
                        // here i have the applications for user i
                        asyncCallback();
                    });
                });

            }

            async.parallel(requests, function(err) {
                // Requests are finished here
            });
        })
    }
});
}

getTopActiveUsers:函数（回调）{
连接（函数（错误、客户端、完成）{
如果（错误）{
回调（null，err）；
}否则{
User.finAll（客户端、函数（用户）{
var请求=[]；
对于（var i=0；i

文档：异步库是为您准备的。并行方法并行执行所有请求，并等待它们全部完成

getTopActiveUsers : function(callback) {
pool.connect(function(err, client, done) {
    if (err) {
        callback(null, err);
    } else {
        User.finAll(client, function(users) {
            var requests = [];

            for (var i = 0; i < users.length; i++) {
                requests.push(function(asyncCallback) {
                    Application.findByUser(users[i].id, function(applications) {
                        // here i have the applications for user i
                        asyncCallback();
                    });
                });

            }

            async.parallel(requests, function(err) {
                // Requests are finished here
            });
        })
    }
});
}

getTopActiveUsers:函数（回调）{
连接（函数（错误、客户端、完成）{
如果（错误）{
回调（null，err）；
}否则{
User.finAll（客户端、函数（用户）{
var请求=[]；
对于（var i=0；i

文档：
由于这些都可以并行运行，因此使用现有代码的最简单方法就是保留一个计数器：

getTopActiveUsers:function(callback) {
    pool.connect(function (err, client, done) {
        if (err)
            callback(null, err);
        else {
            User.findAll(client,function(users) {
                var doneCnt = 0;
                for(var i=0;i<users.length;i++) {
                    Application.findByUser(users[i].id,function(applications) {
                        // here i have the applications for user i
                        ++doneCnt;
                        if (doneCnt === users.length) {
                            callback(null, someResult);
                        }
                    })
                }
            })
        }
    });
}

getTopActiveUsers:函数（回调）{
连接（函数（错误、客户端、完成）{
如果（错误）
回调（null，err）；
否则{
User.findAll（客户端，函数（用户）{
var doneCnt=0；
对于（var i=0；i，由于这些都可以并行运行，因此使用现有代码的最简单方法就是只保留一个计数器：

getTopActiveUsers:function(callback) {
    pool.connect(function (err, client, done) {
        if (err)
            callback(null, err);
        else {
            User.findAll(client,function(users) {
                var doneCnt = 0;
                for(var i=0;i<users.length;i++) {
                    Application.findByUser(users[i].id,function(applications) {
                        // here i have the applications for user i
                        ++doneCnt;
                        if (doneCnt === users.length) {
                            callback(null, someResult);
                        }
                    })
                }
            })
        }
    });
}

getTopActiveUsers:函数（回调）{
连接（函数（错误、客户端、完成）{
如果（错误）
回调（null，err）；
否则{
User.findAll（客户端，函数（用户）{
var doneCnt=0；
对于（var i=0；i