如何在 node.js 中重写一系列带有 Q 承诺的条件语句

Question

exports.create = function(req, res) {
  var company_id = req.company_id;
  var client = new Client(req.body);
  Company.findOne({_id: company_id}, function(err, company) {
    if(err) {
      response = {
        status: 'error',
        error: err
      }
      return res.json(response);
    } else if(!company) {
      response = {
        status: 'error',
        error: 'Invalid company_id'
      }
      return res.json(response);
    } else {
      client.save(function(err) {
        if(err) {
          response = {
            status: 'error',
            error: err
          }
        } else {
          response = {
            status: 'ok',
            client: client
          }
        }
        return res.json(response);
      });
    }
  });
}

这是我的代码（使用Express，如果重要的话）。我正在尝试更多地了解承诺，特别是Q.我觉得这是一种完美的逻辑，可以通过承诺来避免这种毛茸茸的条件巢来实现。但是我不知道如何开始？

Answer 1

但是我不知道如何开始？

首先删除回调并改用 Promise 方法。然后将错误处理放在专用的错误回调中，而不是使用该条件。此外，您可以将用于构建该response对象的代码放在最后（删除重复项），并且仅传递/抛出err。

exports.create = function(req, res) {
  var client = new Client(req.body);
  Q.ninvoke(Company, "findOne", {_id: req.company_id}).then(function(company) {
    if(!company)
      throw 'Invalid company_id';
    else
      return company;
  }).then(function(company) {
    return Q.ninvoke(client, "save");
  }).then(function(saveResult) {
    return {
      status: 'ok',
      client: client
    };
  }, function(err) {
    return {
      status: 'error',
      error: err
    };
  }).done(function(response) {
    res.json(response);
  });
};

Answer 2

这并不是Promises的真正用例。promise 是一种消除 node.js 中深度嵌套回调的方法，而不是像代码中那样处理结果的复杂逻辑。想想这样一种情况：.findOne查询的结果将决定您需要进行的下一个查询 - 这很快就会导致嵌套回调情况，如果您使用 Promises，则可以减少嵌套，并且更自然地读取、评估、重构和构建。

对于.save调用的结果，您确实有一个嵌套回调。因此，您可以使用 Promise 成功重构它，如下所示

new Promise(function() {
    Company.findOne()
    ...
.then(function(company) {
    company.update()
    ...
}, function(err) {
    ...
})

首先是包装您的第一个查询，以便它返回一个承诺，而不是处理回调中的回调。