返回 q.all() 不等待解析，除非包装在 deferred.resolve

Question

所以我今天意识到我一直在使用递归和嵌套承诺来严重迭代承诺，并想学习如何正确使用Q.all()。我正在尝试遍历一系列异步函数，并等待所有函数解决，然后再继续。在此当前实现中，Q.all 将立即返回，而无需等待承诺解析。这是我的迭代函数代码

var updateNewReleasePlaylists = function () {
    var self = this;
    var promises = [];
    var deferred = Q.defer();
    // query for all users who have new releases
    User.find({
            $and: [{
                    'new_releases': {
                        $exists: true,
                        $ne: []
                    }
                },
                {
                    'refresh_token': {
                        $exists: true
                    }
                }
            ]
        }, 'new_releases',
        function (err, users) {
            if (err) {
                throw new Error(err);
            }
            for (var i = 0; i < users.length; i++) {
                console.log('when?')
                promises.push(updatePlaylist(users[i]));
            }
        });
return Q.all(promises);
}

这是它调用的异步函数：

function updatePlaylist(user) {
    var deferred = Q.defer();
    User.findOne({'_id': user._id}, function(err, user) {
        if (err) {
            deferred.reject(err);
        }
        console.log(user);
        deferred.resolve();
    })
    return deferred.promise;
}

如果我像这样更改实现，它完全可以正常工作：

var updateNewReleasePlaylists = function () {
    var self = this;
    var promises = [];
    var deferred = Q.defer();
    // query for all users who have new releases
    User.find({
            $and: [{
                    'new_releases': {
                        $exists: true,
                        $ne: []
                    }
                },
                {
                    'refresh_token': {
                        $exists: true
                    }
                }
            ]
        }, 'new_releases',
        function (err, users) {
            if (err) {
                throw new Error(err);
            }
            for (var i = 0; i < users.length; i++) {
                console.log('when?')
                promises.push(updatePlaylist(users[i]));
            }
            deferred.resolve(Q.all(promises)); // DIFFERENT
        });
        return deferred.promise; // DIFFERENT
}

据我所知，这是一种不正确的实现方式，我想第一次就把它做好。如果有任何帮助，这里是我调用 updateNewReleasePlaylists 函数进行测试的地方。

it('updateNewReleasePlaylists should properly resolve after all users playlists have been updated', function (done) {
        this.timeout(60000);
        testHelper.stageSpotifyUser(20)
            .then(testHelper.stageSpotifyUser(20))
            .then(testHelper.stageSpotifyUser(20))
            .then(function () {
                playlist.updateNewReleasePlaylists()
                    .then(function (promises) {
                        console.log(promises.length);
                        console.log('should be after');
                        done();
                    })
            })
    })

感谢您提前的帮助。

Answer 1

如果 promise 数组为空，那么获得回报似乎是正确的，因为没有什么可等待的。当find（）完成时，由于其异步性质，promises数组仍然是空的，因为函数（err，users）还没有被调用。

因此，如果我对find（）

是异步的是正确的，那么如果需要，您应该返回整个User.find（）或promise-wrap并返回它。