return 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

如果 promises 数组为空，那么获取 return 似乎是正确的，因为没有什么可等待的。当 find() 完成时，由于其异步性质，promises 数组仍然是空的，因为函数 (err, users) 尚未被调用。

所以，如果我关于 find() 是异步的是正确的，你应该 return 整个 User.find() 或 promise-wrap 如果需要的话 return 那。

return q.all() 不等待解决，除非包裹在 deferred.resolve

return q.all() not waiting to resolve unless wrapped in deferred.resolve

javascript

node.js

promise

q