使用节点（ES6）和蓝鸟承诺混淆

Question

我在异步调用完成之前分配值时遇到问题，所以我选择使用 Promises（在本例中为 Bluebird）。我认为这可以解决问题，但鉴于我对 promises / or node 一点都不熟悉，它仍然在做同样的事情。

我将如何着手修改下面的代码，以正确使用 promises？并保持流程，因此我可以根据之前的 row ?

验证 modules

var Promise         = require('bluebird');
var db              = require('../shared/db');
var queryHelper     = require('../shared/queryHelper');
var schemas         = require('../schemas/schemas');
var _               = require('lodash');
var serverSettings  = require('../shared/coreServerSettings');

// Create new instance of mysql module
var connection      = new db();
var queryhelper     = new queryHelper();

// Promised methods
var queryAndWait = Promise.promisify(connection.query);

..剪断..

queryAndWait(query + '; ' + queryFoundRows, params).then(function (result) {
  var payload = [];
  var site_access = [];
  var module_access = [];

  _.each(result[0], function (row) {
    var sites = row.site_access.split(',');
    _.each(sites, function (site_id) {
      site_access.push(site_id);
    });

    row.site_access = site_access;
    site_access = [];

    queryAndWait(queryModules, [row.priv_id]).then(function (result) {
      _.each(result, function (module) {
        var modulePriv = {
          priv_name: module.priv_name,
          priv_num: module.priv_num,
          enabled: module.enabled
        };

        module_access.push(modulePriv);
      });

      //console.log("am assigning " + JSON.stringify(module_access));
      row.module_access = module_access;
      module_access = []
    });

    payload.push(row);
  });
});

澄清一下：

抱歉，模块是用户（行）有权访问的产品组，它们是动态计算的（按位 - 因此没有可用的连接和单独的查询），模块查询 returns 类似于以下内容，然后我循环遍历并在返回有效负载之前附加到该行：

[{"priv_name":"INTERACT","priv_num":1,"enabled":1},{"priv_name":"STAFF_ADMIN","priv_num":32,"enabled":1},{"priv_name":"INT_EDIT","priv_num":64,"enabled":0},{"priv_name":"FAILED_LOGIN","priv_num":128,"enabled":0},{"priv_name":"INT_TAGS","priv_num":256,"enabled":0},{"priv_name":"NC","priv_num":512,"enabled":0},{"priv_name":"CC_TIMETABLE_MGR","priv_num":1024,"enabled":0}]

Answer 1

是的，内部 queryAndWait 将运行独立于每一行，因为您没有链接承诺。

由于您使用的是 bluebird，因此您需要这样的东西来维持流量

queryAndWait(query + '; ' + queryFoundRows, params).then(function (result) {
    return Promise.map(result[0], function (row) {
        var site_access = [];
        var module_access = [];

        var sites = row.site_access.split(',');
        _.each(sites, function (site_id) {
            site_access.push(site_id);
        });

        row.site_access = site_access;

        return queryAndWait(queryModules, [row.priv_id]).then(function (result) {
            _.each(result, function (module) {
                var modulePriv = {
                    priv_name: module.priv_name,
                    priv_num: module.priv_num,
                    enabled: module.enabled
                };

                module_access.push(modulePriv);
            });
            row.module_access = module_access;
            return row;
        });
    });
}).then(function(payload) {
    console.log(payload);
}).catch(function(error) {
    console.log(error);
});

Answer 2

Promise 帮助您以简单的方式控制应用程序的流向。我鼓励您阅读有关 promise 的基本原则，至少阅读 Promise A+ 规范。

您的代码可以用多种方式编写，这是我推荐的方式，因为它是模块化的：

var Promise         = require('bluebird');
var queryAndWait = Promise.promisify(connection.query);

function getRows(params) {
  return queryAndWait(query + '; ' + queryFoundRows, params)
          .then(function (result) {
            var site_access = [];
            _.each(result[0], function (row) {
              var sites = row.site_access.split(',');
              _.each(sites, function (site_id) {
                site_access.push(site_id);
              });
              row.site_access = site_access;
              site_access = [];
              return row;
            });
          });
}


function getModules(row) {
 return queryAndWait(queryModules, [row.priv_id])
         .then(function (result) {
          var payload = [];
          var module_access = [];
          _.each(result, function (module) {
            var modulePriv = {
              priv_name: module.priv_name,
              priv_num: module.priv_num,
              enabled: module.enabled
            };

            module_access.push(modulePriv);
          });              
          row.module_access = module_access;

          payload.push(row);
          return payload;
        });
}

getRows(params)
  .then(getModules)
  .then(function(payload) {
    // Do something with your payload
  })

我做了下一个：

在他自己的函数中分离每个逻辑（为什么？，因为你可以在另一个 promise 中重用逻辑，在另一个库中导出方法等）
我return 每个功能中的承诺。 promise可以嵌套，按顺序执行。
每个实习生承诺解析一个值。 getRows -> 解析行，getModules -> 解析有效载荷

你也可以使用promises的catch方法管理erros，例如：

getRows(params)
  .catch(function(err) {
    // Something went wrong with getRows
    // If i can't recovery must return a reject.
  })
  .then(getModules)
  .catch(function(err) {
    //Something went wrong with getModules
    // If i can't recovery must return a reject.
  })
  .then(function(payload) {
    // Do something with your payload
  })

使用节点（ES6）和蓝鸟承诺混淆

Promise confusion using node (ES6) and Bluebird

javascript

node.js

promise

bluebird