Question

下面，您将看到我在评论代码中遇到问题的位置。我有一个嵌套的promise，它在集合中创建一个对象，然后返回它。

但是，我认为我遇到异步问题。该函数在嵌套的promise返回创建的对象之前完成。

我仍然抓着承诺链，我可能在这里犯了很多错误。如果我可以清理/压扁其中的一部分，大部分可能会被清除。

 PostSchema.statics.createPost = function (o, user) {
    var whiskey;
    return Whiskey
        .createWhiskey(o.whiskey.value)
        .then(function (whiskeyData) {
            whiskey = whiskeyData.whiskey;
            o.post.whiskey = whiskeyData.whiskey._id;

            if (whiskeyData.whiskey.distiller) {
                o.post.distiller = whiskeyData.whiskey.distiller;
            }

            return o.distiller.new === true && !whiskey.distiller ? Distiller.newDistiller(o.distiller.value) : Promise.resolve()
                .then(function (distiller) {
                    //this never invokes   <---- it's called from the function below
                    console.log('never invokes', distiller).
                    if (distiller) {
                        whiskey.distiller = distiller._id;
                        //test this save
                        whiskey.save();
                        o.post.distiller = distiller._id;
                    }

                    var post = o.post;
                    post.user = user._id;
                    return Post
                        .createAsync(post)
                        .then(function (data) {
                            return Post
                                .populate(data, {
                                    path: 'user whiskey',
                                    populate: {
                                        path: 'distiller style',
                                    }
                                })
                        })

                        .then(function (populatedData) {
                            return (user.shareFB ? social.checkFB(user, populatedData) : Promise.resolve())
                                .then(function (FBres) {
                                    return (user.shareTWT ? social.checkTWT(user, populatedData) : Promise.resolve())
                                        .then(function (TWTres) {
                                            var socialData = [TWTres, FBres];
                                            return {
                                                'post': populatedData,
                                                'social': socialData
                                            };
                                        })
                                })
                        })
                })
        })
        .catch(function (err) {
            console.log('post create err : ', err);
        })
};

这是蒸馏器的创建和尝试返回的地方：

DistillerSchema.statics.newDistiller = function (o) {

    return Distiller
        .findAsync({
            'name': o.name
        })
        .then(function (distiller) {
            if (distiller.length) {
                return distiller[0];
            }
            return Distiller
            .createAsync(o)
            .then(function (data) {
                //console.log here indicates that is is created <-- created and returned here
                console.log('distiller created ', data)
                return data;
            })
        })
        .catch(function(err) {
            console.log('create distiller err ', err);
        })
};

Answer 1

听起来像是一个分组错误。而不是

return o.distiller.new === true && !whiskey.distiller
  ? Distiller.newDistiller(o.distiller.value)
  : Promise.resolve().then(…) // callback only called when no new distiller

你想要

return (o.distiller.new && !whiskey.distiller
  ? Distiller.newDistiller(o.distiller.value)
  : Promise.resolve()
).then(…) // callback always called

至少那是所有其他条件： - ）

我仍然抓着承诺链接

在了解到你总是需要return来自你的异步函数（你做得很好）之后，你应该看一下how it is possible to flatten a chain（当所有条件都是本地的时候它适用于你的代码只有表达式，而不是早期的回报）。此外，我建议不要缩进链式方法调用，因为嵌套then回调时很快就会失控，但这只是我个人的偏好。

无法获得嵌套的promises将值返回到下一个promise链

1 个答案: