Question

考虑到这个例子：

app.get('/url/:param', function(req, res, next) {
  var param = req.params.param;
  method1(param, function(err, model) {
    if(err) return next(err);
    method2(model, function(err, models) {
      if(err) return next(err);
      if(models.length > 0) {
        method3(mode, models, function(err, models2) {
          res.render("index.html", {model: model, models: models, models2: models2});
        });
      } else {
        res.render("index.html", {model: model, models: models});
      }
    });
  });
}

有没有办法使用promises简化这个例子？看看所有方法都是依赖项并且具有if(models.length > 0)之类的验证此外，我需要将res.render分组到一个独特的地方。

Answer 1

假设Bluebird，利用库功能并删除嵌套：

var api = Promise.promisifyAll({method1:method1,method2:method2:method3:method3});
api.method1Async(req.params.param).then(function(res){
     return [method2Async(res),{model:res}];
}).spread(function(res,result){
     result.models = res;
     if(models.length > 0){
         return method3Async(mode,res).then(function(res){
             result.models2 = res;
         }).return(result);
     }
     return results;
}).then(function(results){
     res.render("index.html",results);
}).catch(next); // also handle render errors

或者，您可以执行更少嵌套的操作：

var api = Promise.promisifyAll({method1:method1,method2:method2:method3:method3});
var p1 = api.method1Async(req.params.param);
var p2 = p1.then(api.method2Async);
var p3 = p2.then(function(models){ 
    if(models.length > 0) return api.method3Async(mode,models);
});
Promise.all([p1,p2,p3]).spread(function(r1,r2,r3){
    var results = {model:r1,models:r2};
    if(models.length > 0) results.models2 = r3;
    res.render("index.html",results);
}).catch(next)

或者，您可以使用Bluebird协同程序（需要--harmony-generators标志）

var api = Promise.promisifyAll({method1:method1,method2:method2:method3:method3});
Promise.coroutine(function*(){
    var model = yield method1Async(req.params.param);
    var models = yield method2Async(model);
    if(models.length > 0){
        var models2 = yield method3Async(mode,models);     
    }
    res.render("index.html",{model:model,models:models,models2:models2});
})().catch(next); // should probably extract to a clear method rather than self invoke

Answer 2

是的，有。您可以将此减少为一个失败或成功的承诺，并安装next和res.render作为相应的处理程序。但是，由于结果取决于以前的所有结果，因此金字塔保持最简单。假设Q.js：

app.get('/url/:param', function(req, res, next) {
  Q.nfcall(method1, req.params.param).then(function(model) {
    return Q.nfcall(method2, model).then(function(models) {
      if(models.length > 0)
        return Q.nfcall(method3, mode, models).catch(function(err) {
          // you're not dealing with errors here
          // omit this `.catch()` call if you want to let it reach the `next()`
        }).then(function(models2) {
          return {model: model, models: models, models2: models2};
        });
      else
        return {model: model, models: models};
      }
    });
  }).done(function(results) {
    res.render("index.html", results);
  }, next);
}

Answer 3

如果我说得对，如果你需要制作很多嵌套语句，也许你可以查看this。 Async可以帮助您调用行上的各种函数（有很多方法可以使用Async完成它，请参阅其文档）并且您可以将所有语句放在一起。

如何将回调转化为承诺？

3 个答案: