我应该如何用水平线和蓝知更鸟来处理承诺和回调呢？

Question

我在使用sails时遇到了多个问题，因为我无法理解水线承诺及其逻辑。

我尝试了两个内置在中的蓝鸟承诺，甚至一个async.waterfall实现，但都没有成功。

简单地说，我正在为一个执行db查询的API编写代码，通过尝试使用回调，它永远不会响应。

这就是我尝试过的纯粹的承诺：

changeFormation: function (request,response) {

  console.log("changeFormation");
  var lineupId = request.params.id;
  var newFormation = request.param('formation');
  var newLineUp = request.param('lineup');
  console.log("Receiving" + newFormation);

  if ( ["5-4-1", "5-3-2", "4-5-1", "4-4-2", "4-3-3", "3-5-2", "3-4-3"].indexOf(newFormation) === -1 ) {
    console.log("No válida");
    return response.send(409, "La táctica elegida no es válida");
  }

  LineUp.findOne({id: lineupId}).
  then(function (foundLineUp) {

    console.log(foundLineUp);
    if (!foundLineUp)
      return response.send(404);

    if (! foundLineUp.formation) {

      foundLineUp.formation = newFormation;

    LineUp.update({id: foundLineUp.id}, foundLineUp).exec(function (err, saved) {

      if (err)
        return response.send(500, JSON.stringify(err));

      return response.send(202, JSON.stringify(saved));
    });

    }

    // If a formation was previously set
    else if (Array.isArray(newLineUp) &&  newLineUp.length > 0) {

      newLineUp.formation = newFormation;

      LineUp.update({id: newLineUp.id}, newLineUp).exec(function (err,saved) {
        if (err)
          return response.send(500,JSON.stringify(err));
        return response.stringify(202, JSON.stringify(saved));
      });
    }
    console.log("Never reached");
  }).
  catch(function (err) {
    console.log(err);
    response.send(500,JSON.stringify(err));
  });
},

在上面的内容中，我可以在控制台"Never reached".中看到为什么！？

这就是我尝试使用异步模块的地方：

addPlayer: function (request,response) {

  // console.log("Add player");
  var lineupId = request.params.id;

  var receivedPlayer = request.param('player');
  var playerId = receivedPlayer.id;
  var bench = receivedPlayer.bench;
  var place = receivedPlayer.place;
  var e, r;

  async.waterfall([

    function (cb) {

      LineUp.findOne().where({id: lineupId}).exec(function (err, foundLineUp) {
        cb(err,foundLineUp);
      });},

    function (lineup,cb) {

      Player.findOne().where({id: playerId}).exec(function (err,foundPlayer) {
        cb(err,lineup, foundPlayer);
      });},

    function (lineup, player, cb) {
      if (!player) {
        console.log("Jugador no existe");
        cb(null, {status: 409, msg: "El jugador " + playerId + " no existe"});
      }

      if (!lineup.formation) {
        console.log("No hay táctica")
        cb(null, {status: 409, msg: "No se ha elegido una táctica para esta alineación"});
      }

      if (lineup.squadIsComplete()) {
        console.log("Ya hay 15");
        cb(null, {status: 409, msg: "La plantilla ya contiene el máximo de 15 jugadores"});
      }

      if (lineup.playerWasAdded(player.id)) {
        console.log("Jugador ya en alineación")
        cb(null, {status: 409, msg: "El jugador ya ha sido agregado a la alineación"});
      }

      if (lineup.fieldIsComplete() && !bench) {
        console.log("Ya hay 11 en el campo");
        cb(null, {status: 409, msg: "Ya se han agregado los 11 jugadores de campo"});
      }

      player.bench = bench;
      player.place = place;

      lineup.players.push(player);

      console.log("MaxForeign " + lineup.reachesMaxForeignPlayers());
      console.log("BudgetLimit " + lineup.reachesBudgetLimit());
      console.log("SameTeam " + lineup.reachesMaxSameTeamLimit());
      console.log("reachesMaxSameFavoriteTeamLimit " + lineup.reachesMaxSameFavoriteTeamLimit());


      // If any of rule restrictions evaluates to true ...
      // Using lodash _.some with out second argument which defaults to _.identity
/*      if ( _.some([ lineup.reachesMaxForeignPlayers(),
                    lineup.reachesBudgetLimit(),
                    lineup.reachesMaxSameTeamLimit(),
                    lineup.reachesMaxSameFavoriteTeamLimit()]) ) {

        return response.send(409, "La inclusión de este jugador no satisface las reglas del juego");
      }*/

      LineUp.update({id: playerId}, lineup).exec(function (err, saved) {
        cb(err, {status: 202, msg: JSON.stringify(saved)});
      });
    }
  ],

  function (err, result) {
    console.log("About to respond");
    if (err)
      respond.send(500);
    else
      response.send(result.status, result.msg);
  });

  console.log("Never reached");
},

这不会给出超时，但奇怪的是，在文档应该更新的时候没有更新。这是日志记录"never reached"，然后是"about to respond"，但我想这是正常的。

到目前为止，我应该如何处理这一切呢？

Answer 1

在上面，我可以在控制台中看到“从未到达”。为什么！？

因为你把异步代码和同步代码混为一谈。如果你这样做了：

function(){
  console.log('init');
  someAsyncMethod(function callback(){
    return console.log('async done');
  });
  console.log('Never reached');
}

你会得到：

init
Never reached
async done

因为异步代码将在随后执行。我建议您阅读这和这以更好地理解异步回调。

这不会给出超时，但奇怪的是，在文档应该更新的时候没有更新。

很难说发生了什么，因为我们不知道LineUp的模型定义，也不知道lineup调用前后的内容。你确定LineUp.update()跑了吗？为什么不在回调中添加一个console.log()来查看结果呢？

到目前为止，我应该如何处理这一切呢？

在我看来，你已经接近实现你的目标了。如果您共享LineUp的模型定义和更多的日志记录，我们将能够为您提供更多帮助。