Javascript ES6类和同步执行

我正在API中为订单数据实体构建一个模型类。目前，该实体有两个端点，一个用于检索摘要数据

/orders/{id}/summary

，另一个用于支付数据

/orders/{id}/payment

。摘要可以100%工作，支付端点可以获取所有数据，但有辅助数据库查询的情况除外

my order.js模型中的代码：

'use strict';

/* Include MySQL connection */
var dbConnection = require(appDir + process.env.PATH_LIB + 'database');

/* Include PaymentMethod model */
var PaymentMethod = require('./paymentmethod');


class Order {
  constructor (data, requestTemplate) {
    this.data = data;
    switch (requestTemplate) {
      case 'summary':
        this.data.platform = _getPlatform(data.TakeALot);
        this.data.source = _getSource(data.idKalahariOrder,data.idAffiliate,data.TakeALot);
        this.data.reference = _getExternalReference(data.idKalahariOrder,data.AffiliateReference);
        break;
      case 'payment':
        this.data.health = _getHealth(data.Auth);
        this.data.timeline = _getTimeline(data.Auth);
        break;
    };
  }

  getPayments () {
    var paymentList = [];
    var paymentMethods = [];

    if (this.data.PaymentMethod) {
      paymentList.push(this.data.PaymentMethod);
    };
    if (this.data.PaymentMethods) {
      this.data.PaymentMethods.split(',').forEach(function(e){
        if (paymentList.indexOf(e) == -1) {
          paymentList.push(e);
        }
      })
    };
    for (var i = 0; i < paymentList.length; i++) {
      console.log(paymentList[i]);
      paymentMethods.push(new PaymentMethod(this.data.idOrder,paymentList[i]));
    };
    console.log(paymentMethods);
    this.data.payments = paymentMethods;
  }
}

/* Find a single ORDER SUMMARY data */
Order.findSummaryById = function (id, callback) {
  dbConnection(function(err, conn){
    conn.query('SELECT <<query text removed>> WHERE o.idOrder = ?', [id], function(err, rows) {
      if (err) return callback(err);
      callback(null, new Order(rows[0], 'summary'));
    });
    conn.release();
  })
};

/* Find a single ORDER PAYMENT data */
Order.findPaymentById = function (id, callback) {
  dbConnection(function(err, conn){
    conn.query('SELECT <<query text removed>> WHERE o.idOrder = ?', [id], function(err, rows) {
      if (err) return callback(err);
      let order = new Order(rows[0], 'payment');
      order.getPayments();
      callback(null, order);
    });
    conn.release();
  })
};

/* Build order timeline */
function _getTimeline(status) {
  <<business logic removed>>
  return orderTimeline;
}

/* Determine order health */
 function _getHealth(status) {
  <<business logic removed>>
  return health;
}

/* Determine order source */
 function _getSource(idKalahariOrder, idAffiliate, TakeALot) {
  <<business logic removed>>
  return source;
}

/* Determine client platform */
function _getPlatform(clientId) {
  <<business logic removed>>
  return platform;
}

/* Determine external reference */
function _getExternalReference(idKalahariOrder, AffiliateReference) {
  <<business logic removed>>
  return reference;
}

module.exports = Order;

'use strict';

/* Include MySQL connection */
var dbConnection = require(appDir + process.env.PATH_LIB + 'database');

class PaymentMethod {
  constructor(idOrder, paymentType) {
    var SQL = '';
    switch (paymentType) {
      case 'Credit Card':
        SQL = 'SELECT <<query text removed>> WHERE idOrder = ?';
        break;
      default:
        SQL = 'SELECT <<query text removed>> WHERE idOrder = ?';
    };
    dbConnection(function(err, conn){
      conn.query(SQL, [idOrder], function (err, data) {
        if (err) return callback(err);
        if (data) {
          this.paymentType = paymentType;
          this.paymentAmount = data.paymentAmount;
          this.paymentReference = data.paymentReference;
          this.paymentState = data.paymentState;
        }
      });
      conn.release();
    });
  }
}

module.exports = PaymentMethod;

在这里叫它：

  getPayments () {
    var paymentList = [];
    var paymentMethods = [];

    if (this.data.PaymentMethod) {
      paymentList.push(this.data.PaymentMethod);
    };
    if (this.data.PaymentMethods) {
      this.data.PaymentMethods.split(',').forEach(function(e){
        if (paymentList.indexOf(e) == -1) {
          paymentList.push(e);
        }
      })
    };
    for (var i = 0; i < paymentList.length; i++) {
      console.log(paymentList[i]);
      //var paymentDet = new PaymentMethod(this.data.idOrder,paymentList[i]);
      new PaymentMethod(this.data.idOrder,paymentList[i]).then(function(data) {
        console.log('detail:',data);
        paymentMethods.push(data);
      });
    };
    console.log(paymentMethods);
    this.data.payments = paymentMethods;
  }

getPayments（）{
var paymentList=[]；
var paymentMethods=[]；
if（this.data.PaymentMethod）{
paymentList.push（this.data.PaymentMethod）；
};
if（this.data.PaymentMethods）{
this.data.PaymentMethods.split（'，）.forEach（函数（e）{
如果（付款清单索引f（e）=-1）{
付款清单。推送（e）；
}
})
};
对于（变量i=0；i

但是，还是没有运气

最终解决方案 订单类别：

class Order {
  constructor (data, requestTemplate) {
    this.data = data;
    switch (requestTemplate) {
      case 'summary':
        this.data.platform = _getPlatform(data.TakeALot);
        this.data.source = _getSource(data.idKalahariOrder,data.idAffiliate,data.TakeALot);
        this.data.reference = _getExternalReference(data.idKalahariOrder,data.AffiliateReference);
        break;
      case 'payment':
        this.data.health = _getHealth(data.Auth);
        this.data.timeline = _getTimeline(data.Auth);
        break;
    };
  }

  getPayments () {
    var self = this;
    return new Promise(function (resolve) {
      var paymentList = [];
      var paymentMethods = [];

      if (self.data.PaymentMethod) {
        paymentList.push(self.data.PaymentMethod);
      };
      if (self.data.PaymentMethods) {
        self.data.PaymentMethods.split(',').forEach(function(e){
          if (paymentList.indexOf(e) == -1) {
            paymentList.push(e);
          }
        })
      };
      for (var i = 0; i < paymentList.length; i++) {
        new PaymentMethod(self.data.idOrder,paymentList[i]).then(function(data) {
          paymentMethods.push(data);
          if (paymentMethods.length == paymentList.length) {
            self.data.payments = paymentMethods;
            resolve(self);
          }
        })
      };
    })
  }
}

类顺序{
构造函数（数据、请求模板）{
这个数据=数据；
开关（请求模板）{
个案‘摘要’：
this.data.platform=\u getPlatform（data.TakeALot）；
this.data.source=_getSource（data.idKalahariOrder、data.idAffiliate、data.TakeALot）；
this.data.reference=\u getExternalReference（data.idKalahariOrder，data.AffiliateReference）；
打破
“付款”案例：
this.data.health=\u getHealth（data.Auth）；
this.data.timeline=\u getTimeline（data.Auth）；
打破
};
}
获取付款（）{
var self=这个；
返回新承诺（函数（解析）{
var paymentList=[]；
var paymentMethods=[]；
if（self.data.PaymentMethod）{
paymentList.push（self.data.PaymentMethod）；
};
if（self.data.PaymentMethods）{
self.data.PaymentMethods.split（'，）.forEach（函数（e）{
如果（付款清单索引f（e）=-1）{
付款清单。推送（e）；
}
})
};
对于（变量i=0；i

PaymentMethod类：

class PaymentMethod {
  constructor(idOrder, paymentType) {
    var SQL = '';
    switch (paymentType) {
      case 'Credit Card':
        SQL = 'SELECT <<query text>> WHERE idOrder = ?';
        break;
      default:
        SQL = 'SELECT <<query text>> WHERE idOrder = ?';
    };

    var self = this;

    return new Promise(function (resolve) {
      self.loadData(SQL, idOrder).then(function (data) {
        self.paymentType = paymentType;
        self.paymentAmount = data.paymentAmount;
        self.paymentReference = data.paymentReference;
        self.paymentState = data.paymentState;
        resolve (self);
      }).catch(function(error) {
        console.log('Error occurred!', error);
      });
    }).catch(function(error) {
      console.log('Error occurred!', error);
    });
  }

  loadData (SQL, idOrder) {
    return new Promise (function (resolve) {
      dbConnection(function(err, conn){
        conn.query(SQL, [idOrder], function (err, data) {
          if (err) return callback(err);
          if (data) {
            resolve (data[0]);
          }
        });
        conn.release();
      });
    }).catch(function(error) {
      console.log('Error occurred!', error);
    });
  };
}

类付费方式{
构造函数（idOrder，paymentType）{
var-SQL=''；
交换机（paymentType）{
“信用卡”案例：
SQL='选择idOrder=？'的位置；
打破
违约：
SQL='选择idOrder=？'的位置；
};
var self=这个；
返回新承诺（函数（解析）{
self.loadData（SQL，idOrder）.then（函数（数据）{
self.paymentType=paymentType；
self.paymentAmount=data.paymentAmount；
self.paymentReference=data.paymentReference；
self.paymentState=data.paymentState；
决心（自我）；
}).catch（函数（错误）{
log（'发生错误！'，错误）；
});
}).catch（函数（错误）{
log（'发生错误！'，错误）；
});
}
加载数据（SQL、idOrder）{
返回新承诺（函数（解析）{
数据库连接（功能（错误，连接）{
conn.query（SQL，[idOrder]，函数（err，data）{
if（err）返回回调（err）；
如果（数据）{
解析（数据[0]）；
}
});
控制释放（）；
});
}).catch（函数（错误）{
log（'发生错误！'，错误）；
});
};
}

实例化新订单实例的代码：

Order.findPaymentById = function (id, callback) {
  dbConnection(function(err, conn){
    conn.query('SELECT <<query text>> WHERE o.idOrder = ?', [id], function(err, rows) {
      if (err) return callback(err);
      let order = new Order(rows[0], 'payment');
      order.getPayments().then(function(){
        callback(null, order);
      });
    });
    conn.release();
  })
};

Order.findPaymentById=函数（id，回调）{
数据库连接（功能（错误，连接）{
conn.query（'SELECT WHERE o.idOrder=？'，[id]，函数（err，行）{
if（err）返回回调（err）；
let order=新订单（第[0]行，“付款”）；
order.getPayments（）.then（函数（））{
回调（空，顺序）；
});
});
控制释放（）；
})
};

为了打印结果并返回正确的数据，我建议在getPayments函数中返回一个承诺-这样被调用函数就可以访问.then闭包中的所有支付方法

例如：

被调用函数：

getPayments().then(function(paymethods) { 
  //use paymethods array here for something
  console.log(paymethods);
});

function getPayments () {
  var paymentList = [];
  var paymentMethods = [];

  if (this.data.PaymentMethod) {
    paymentList.push(this.data.PaymentMethod);
  };
  if (this.data.PaymentMethods) {
    this.data.PaymentMethods.split(',').forEach(function(e){
      if (paymentList.indexOf(e) == -1) {
        paymentList.push(e);
       }
    })
  };
  return new Promise(function(resolve) {
    var last = false;
    for (var i = 0; i < paymentList.length; i++) {
      if (i === paymentList.length-1) { last=true }
      console.log(paymentList[i]);
      new PaymentMethod(this.data.idOrder,paymentList[i]).then( function(data) {
        console.log('detail:',data);
        paymentMethods.push(data);
        if (last) {
          resolve(paymentMethods);
        }
      });
    };
  });
}

getPayments功能：

getPayments().then(function(paymethods) { 
  //use paymethods array here for something
  console.log(paymethods);
});

function getPayments () {
  var paymentList = [];
  var paymentMethods = [];

  if (this.data.PaymentMethod) {
    paymentList.push(this.data.PaymentMethod);
  };
  if (this.data.PaymentMethods) {
    this.data.PaymentMethods.split(',').forEach(function(e){
      if (paymentList.indexOf(e) == -1) {
        paymentList.push(e);
       }
    })
  };
  return new Promise(function(resolve) {
    var last = false;
    for (var i = 0; i < paymentList.length; i++) {
      if (i === paymentList.length-1) { last=true }
      console.log(paymentList[i]);
      new PaymentMethod(this.data.idOrder,paymentList[i]).then( function(data) {
        console.log('detail:',data);
        paymentMethods.push(data);
        if (last) {
          resolve(paymentMethods);
        }
      });
    };
  });
}

函数getPayments（）{
var paymentList=[]；
var paymentMethods=[]；
if（this.data.PaymentMethod）{
paymentList.push（this.data.PaymentMethod）；
};
if（this.data.PaymentMethods）{
this.data.PaymentMethods.split（'，）.forEach（函数（e）{
如果（付款清单索引f（e）=-1）{
付款清单。推送（e）；
}
})
};
返回新承诺（函数（解析）{
var last=false；
对于（变量i=0；i

只是一些额外的信息：从控制器调用模型，形式为：exports.getOrderPaymentById=function（request，reply）{Order.findPaymentById（request.params.id，function（err，Order）{reply（Order）；}）；DB连接器正在使用node mysql包。因为它是异步的，所以在继续执行之前，您必须等待它完成。请看一下使用承诺和@DanielB，我已经看了本机承诺，但我无法将类实例化封装在承诺中。谢谢，@jsdeveloper。我一直在努力