Question

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

我尝试了内置 bluebird promises ，甚至还有async.waterfall实现，但无法成功。

简而言之，我正在为执行数据库查询的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

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

这不会导致超时，但奇怪的是它不应该在应用时更新文档。

由于我们不知道LineUp的模型定义而且我们在lineup调用之前和之后都不知道update的内容，因此很难说是怎么回事。你确定LineUp.update()跑了吗？为什么不在回调中添加console.log()来查看结果？

到目前为止，我该如何应对呢？

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

我该如何处理水线和蓝鸟的承诺和回调？

1 个答案: