Question

我试图弄清楚如何使用promises，尤其是Q实现来清理node.js程序中一些混乱的嵌套回调。不幸的是，似乎很少有简单的例子可以说明我想做什么。

以下是我现在拥有的嵌套回调的简化版本：

    var parent = this;
    this.receiveMessage(params, function(err, request) {
    if (err) console.log(err, err.stack);
    else {
       parent.handleMessage(request, function(response) {
           parent.sendMessage(JSON.stringify(response), function() {
               console.log("response sent");
               var params = { ReceiptHandle:request.Messages[0].ReceiptHandle };
               parent.deleteMessage(params, function() {
                   parent.waitForMessage();
               });
           });
       });
    }
});

正如您所看到的那样，它非常混乱，并且有4级嵌套回调。

使用Q，我发现你从以下内容开始：

Q.nfcall(this.connection.receiveMessage, params)
    .then(function(err, request) {
        return(Q.nfcall(this.handleMessage(request));
    })
    .then(function(response)) { 
        return(Q.nfcall(this.sendMessage(JSON.stringify(response))));
    } ...

依此类推......但这似乎并不合适。首先，我是否需要在链中的每个函数上调用Q.nfcall？另外，我是否避免了＆＃34;这个＆＃34;的范围问题？当我使用回调时，我得到了什么？我甚至以正确的方式使用承诺吗？

Answer 1

我有类似的问题，后来才意识到这是因为Q.在我看来，Q有一个混乱的API，并且使用很少的简单例子很麻烦。我建议尝试任何其他库，但我推荐Bluebird。使用Bluebird，您可以执行以下操作：

var Promise = require('bluebird');
var parent = this;
Promise.promisifyAll(parent, { suffix: "P" });
parent.receiveMessageP(params)
  .then(function (request) {
    return [request, parent.handleMessageP(request)];
  })
  .spread(function (request, response) {
    return [request, parent.sendMessageP(JSON.stringify(response))];
  })
  .spread(function (request) {
    console.log("response sent");
    var params = { ReceiptHandle: request.Messages[0].ReceiptHandle };
    return parent.deleteMessageP(params);
  })
  .then(function () {
    parent.waitForMessage();
  })
  .catch(function (err) {
    console.log(err, err.stack);
  });

如果您不喜欢返回数组的样式并使用.spread，则可以在外部范围内使用映射对象。

var Promise = require('bluebird');
var parent  = this;
Promise.promisifyAll(parent, { suffix: "P" });
var cache = {};
parent.receiveMessageP(params)
  .then(function (request) {
    cache.request = request;
    return parent.handleMessageP(request);
  })
  .then(function (response) {
    return parent.sendMessageP(JSON.stringify(response));
  })
  .then(function () {
    console.log("response sent");
    var params = { ReceiptHandle: cache.request.Messages[0].ReceiptHandle };
    return parent.deleteMessageP(params);
  })
  .then(function () {
    parent.waitForMessage();
  })
  .catch(function (err) {
    console.log(err, err.stack);
  });

如果您需要访问链中稍后解析过的链中的变量，您可以继续将它们添加到cache对象中以便于访问。有时如果你有很多这样的方法，这种方法更清晰，更容易阅读。在大多数情况下，我通常更喜欢第一个示例，只是为了避免污染父作用域并可能保留应以其他方式处理的引用。

并不是说你不能在Q中做类似于promisifyAll的事情，但Bluebird更高效，更直观。

如果您的回调不符合function (err, successValue)的典型节点样式签名（您的某些人不会出现，这意味着promisifyAll无法工作在他们身上）然后你可以定义一个自定义＆＃34; promisifier＆＃34;在蓝鸟。或者修改您的回调API以符合node-style callbacks。

https://github.com/petkaantonov/bluebird/blob/master/API.md#option-promisifier

Answer 2

Promise确实让你不用回调，但是应用nfcall内联是很麻烦的。您可以将nbind作为装饰器应用于原始函数，因此您可以将其用作承诺返回函数来构建链：

obj.receiveMessage = Q.nbind(obj.receiveMessage, obj);
obj.deleteMessage = ...

现在会更好地阅读：

this.receiveMessage(params)
  .then(function(request) {
    return parent.handleMessage(request);
  })
  .then(function(response) {
    var params = {ReceiptHandle: request.Messages[0].ReceiptHandle};
    return parent.deleteMessage(params);
  })
  .then(parent.waitForMessage)
  .catch(function(err) {
    console.log(err, err.stack);
  });

如何在node.js中使用promises来清理一系列回调？

2 个答案: