javascript - 在 Bluebird 中处理多个嵌套异步操作(promises)

Question

我对 JavaScript (Node.js) 和 Promises 还很陌生。我目前正在使用 AWS Lambda 和 DynamoDB。

我有一个从数据库异步获取的项目列表(已使用 bluebird Promise API promise 了 AWS SDK。)

对于其中每个项目，我可能需要检索多个子项目(也是异步的)，然后对于每个子项目，我必须执行另一个异步操作并确定此异步操作是否成功。

对某个项目完成所有异步操作(即子项目的所有异步操作成功或失败)后，我需要更新数据库中项目的状态(失败/成功。)

这(如下)是我到目前为止所拥有的。你能告诉我我这样做是否正确吗？其中是否存在逻辑错误？可以改进吗？

var doc = require('dynamodb-doc');
var promise = require("bluebird");

var dynamodb = new doc.DynamoDB();

var params = { /* ... */ };

promise.promisifyAll(Object.getPrototypeOf(dynamodb));

dynamodb.queryAsync(params)
    .then(function(data) {
        var items = data.Items;

        var promises = items.map(function(item) {
            params = { /* ...*/ };

            return dynamodb.queryAsync(params)
                .then(function(data2) {
                    var childItems = data2.Items;

                    var morePromises = childItems.map(function(device) {
                        return doAsyncWork()
                            .then(function success() {
                                console.log("Success!");
                            })
                            .catch(function error(err) {
                                console.log("Error!");
                            })
                    });

                    return promise.all(morePromises);
                })
                .then(function() {
                    // Update status for item in DB
                    params = { /* ...*/ };
                    return dynamodb.updateItemAsync(params);
                });
        });

        return promise.all(promises);
    })
    .then(function() {
        var response = { /* ... */ };

        context.succeed(response);
    })
    .catch(function(err) {
        context.fail(err);
    });

其他一些事情:

对于要完成的一项的所有异步操作，我使用 Promise.all()，从文档中我可以看到，即使一个 promise 被拒绝，后续的 promise 也将被拒绝。我不希望这种情况发生，我希望它继续下去，即使有一个 promise 被拒绝。

同样，对于所有项目，我最终都使用 Promise.all() 等待所有项目完成处理。如果其中一个失败了，其他的就不会被处理了，对吗？我该如何克服这个问题？

有很多嵌套，我该如何改进这段代码？

我需要一种方法来整合所有结果并将其作为响应传递，例如像这样的东西:

{
    "Results": [{
        "ItemId": " ... ",
        "Status": "Success",
        "ChildItems": [{
            "ChildItemId": " ... ",
            "Status": "Success"
                /*  ...
                ...
                ...
            */
        }]
    }, {
        "ItemId": " ... ",
        "Status": "Error",
        "ChildItems": [{
            "ChildItemId": " ... ",
            "Status": "Success"
        }, {
            "ChildItemId": " ... ",
            "Status": "Error"
        }]
    }]
}

我想到的一个解决方案(可能有点难看)是在外部有一个全局对象，然后将结果存储在其中。还有其他优雅的方法吗？

谢谢。

Answer 1

Can it be improved?

自从您使用 Bluebird 以来，您可以改进一些事情。

使用 Bluebird 的 promise.map() 保存代码:

您可以使用 Bluebird 的 promise.map() 来代替 array.map() 后跟 promise.all()像这样更改代码:

               var childItems = data2.Items;

                var morePromises = childItems.map(function(device) {
                    return doAsyncWork()
                        .then(function success() {
                            console.log("Success!");
                        })
                        .catch(function error(err) {
                            console.log("Error!");
                        })
                });

                return promise.all(morePromises);

对此:

               return promise.map(data2.Items, function(item) {
                    // do something with item
                    return doAsyncWork();
               });

要小心仅记录的 .catch() 处理程序。

如果您处理 Promise 拒绝并且不重新抛出或返回被拒绝的 Promise，则 Promise 状态将从拒绝更改为已完成。

所以，当您使用像这里一样的 .catch() 时:

        return dynamodb.queryAsync(params)
            .then(function(data2) {
                var childItems = data2.Items;

                var morePromises = childItems.map(function(device) {
                    return doAsyncWork()
                        .then(function success() {
                            console.log("Success!");
                        })
                        .catch(function error(err) {
                            console.log("Error!");
                        })
                });

                return promise.all(morePromises);
            })

这将“吃掉”来自 doAsyncWork() 被拒绝的 Promise 的任何错误。有时这就是您想要的(您希望处理错误并继续，就像没有发生任何错误一样)，但很多时候您需要错误以某种方式传播回来。您可以记录它，但通过重新抛出错误来传播它:

        return dynamodb.queryAsync(params)
            .then(function(data2) {
                var childItems = data2.Items;

                var morePromises = childItems.map(function(device) {
                    return doAsyncWork()
                        .then(function success() {
                            console.log("Success!");
                        })
                        .catch(function error(err) {
                            console.log("doAsyncWork Error: ", err);
                            //rethrow so error propagates
                            throw err;
                        })
                });

                return promise.all(morePromises);
            })

For all async operations of an item to complete I'm using Promise.all(), and from the documentation I can see that if even one promise got rejected the subsequent promises will get rejected as well. I don't want this to happen, I want it to continue even if a single promise is rejected.

在 Bluebird 中，如果您不希望 Promise.all() 在一个 Promise 拒绝时中止，则可以使用 Promise.settle() 而不是 Promise.all() 如果您使用的是 Bluebird 2.x。如果您使用的是 Bluebird 3.x，则在返回您的 Promise 时可以使用 .reflect()。解释了如何执行此操作 here in the Bluebirds docs 。就我个人而言，我喜欢 Promise.settle() 的工作方式，但必须有一些标准方向的原因来更改它。

There is a lot of nesting, how may I improve upon this code?

您可以链接您正在做的一些事情而不是嵌套。请参阅How to chain and share prior results with Promises用于对多个操作进行排序的多种方法，而无需太多嵌套和累积结果。