Question

我是JavaScript（Node.js）和Promises的新手。我目前正在使用AWS Lambda和DynamoDB。

我有一个项目列表，我是异步从数据库中获取的（已经使用bluebird promises API宣传了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.all（）的所有项目等待所有项目完成其处理。如果一个失败，其余的将不会被处理，对吧？我怎么能克服这个？

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

我需要有一种方法来整合所有结果并将其作为回复传递给像这样的东西：

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

我想到的一个解决方案（可能有点丑陋）是在外面有一个全局对象，然后存储在其中的结果中。还有其他优雅的方法吗？

感谢。

Answer 1

可以改进吗？

您使用Bluebird后可以改进一些事项。

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

而不是array.map()后跟promise.all()，您可以通过更改以下代码来使用Bluebird的promise.map()：

               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()处理程序。

如果您处理承诺拒绝并且不重新抛出或返回被拒绝的承诺，承诺状态将从拒绝变为履行。

所以，当你在这里使用.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()被拒绝的承诺的任何错误。偶尔这就是你想要的（你想要处理错误并继续，好像没有出错），但很多时候你需要错误以某种方式传播回来。您可以记录它，但通过重新抛出它来传播错误：

        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);
            })

对于我正在使用的项目的所有异步操作 Promise.all（），从文档中我可以看到，即使是一个承诺被拒绝随后的承诺将被拒绝为好。我不希望这种情况发生，我希望它继续，即使一个单一承诺被拒绝。

在Bluebird中，如果您不希望在一个承诺拒绝时Promise.all()中止，则如果您使用的是Bluebird 2.x，则可以使用Promise.settle()代替Promise.all()。如果您使用的是Bluebird 3.x，那么当您退回承诺时，可以使用.reflect()。 here in the Bluebirds docs解释了如何做到这一点。就个人而言，我喜欢Promise.settle()的工作方式，但必须有一些标准方向的原因来改变它。

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

你可以链接一些你正在做的而不是嵌套。有关排序多个操作的各种方法，请参阅How to chain and share prior results with Promises，而无需嵌套和累积结果。

处理Bluebird中的多个嵌套异步操作（promises）

1 个答案: