Node.js Mongodb使用承诺以同步方式迭代

我有一个方法（参见代码示例），我正试图将承诺列表返回给父方法。我的问题是在我的承诺列表数组中推送承诺时

getDistance是一种返回承诺的方法。如果我在getDistance方法中使用.then（），则一切正常。然而，如果我尝试将承诺推入数组，当我这样做时，那么在父方法中，它是空的

我认为这可能是因为每个循环都是异步的

var promiseList = [];
    res = db.collection.find query statement... 
    res.each(function(err, doc) {
        if (doc!==null) {
            promiseList.push(
                 getDistance(orgLat, orgLon, destLat, desLon)
            );
        }
    });
    return Promise.all(promTimeList);

我使用MongoDB作为数据库，在服务器端使用NodeJS，MongoDB作为驱动程序连接到我的数据库，Bluebird作为库来实现承诺

---

提前谢谢

我认为您是正确的，因为问题是由于每个都是异步的。您可以使用

defer

将回调API（如

每个

）包装成承诺。它的工作原理如下：

res = db.collection.find query statement... 
processResponse(res)
    .then(function(promiseList) {
        // execute all the promises
        return Promise.all(promiseList);
    }, function (err) {
        // handle error
    });    

function processResponse(res) {
    var deferred = Promise.pending();
    var promiseList = [];
    res.each(function(err, doc) {
        if (err) {
            // error, abort
            deferred.reject(err);
            return;
        }
        else if (doc != null) {
            promiseList.push(
                getDistance(orgLat, orgLon, destLat, desLon)
            );
        }
        else {
           // finished looping through all results, return the promise list
           deferred.resolve(promiseList);
        }
    });
    return deferred.promise;
}

function processResponse(res) {
    return new Promise(function(resolve, reject) {
        var promiseList = [];
        res.each(function(err, doc) {
            if (err) {
                // error, abort
                reject(err);
                return;
            }
            else if (doc != null) {
                promiseList.push(
                    getDistance(orgLat, orgLon, destLat, desLon)
                );
            }
            else {
               // finished looping through all results, return the promise list
               resolve(promiseList);
            }
        });
    });
}

请在下面的链接中查看有关蓝鸟延迟的更多信息（查看“那么什么时候应该使用延迟？”）：

更新：根据这篇文章：

看起来有一个Promise构造函数可能是实现这一点的首选方法。

processResponse

方法如下所示：

res = db.collection.find query statement... 
processResponse(res)
    .then(function(promiseList) {
        // execute all the promises
        return Promise.all(promiseList);
    }, function (err) {
        // handle error
    });    

function processResponse(res) {
    var deferred = Promise.pending();
    var promiseList = [];
    res.each(function(err, doc) {
        if (err) {
            // error, abort
            deferred.reject(err);
            return;
        }
        else if (doc != null) {
            promiseList.push(
                getDistance(orgLat, orgLon, destLat, desLon)
            );
        }
        else {
           // finished looping through all results, return the promise list
           deferred.resolve(promiseList);
        }
    });
    return deferred.promise;
}

function processResponse(res) {
    return new Promise(function(resolve, reject) {
        var promiseList = [];
        res.each(function(err, doc) {
            if (err) {
                // error, abort
                reject(err);
                return;
            }
            else if (doc != null) {
                promiseList.push(
                    getDistance(orgLat, orgLon, destLat, desLon)
                );
            }
            else {
               // finished looping through all results, return the promise list
               resolve(promiseList);
            }
        });
    });
}

---

感谢@Bergi。如果我错了，请纠正我。与bluebird相比，我更熟悉Q库（）。

使用

wait

和

cursor同步迭代集合。下一步（）

在

while

循环中：

var cursor = db.collection.find({});

while ((doc = await cursor.next()) != null) {
        promiseList.push(
             getDistance(doc.orgLat, doc.orgLon, doc.destLat, doc.desLon);
        );
}

---

你怎么知道每个什么时候都完成了？是的，你真的应该使用

承诺

构造函数，而不是这里的延迟构造函数。哦。这就是你所指的吗我对蓝鸟不太熟悉。