NODEJS节点mysql无法在嵌套查询中传递查询结果

我使用的是node、angular和mysql，节点路由将返回一个json，该json将由angular处理，该json是通过首先使用node mysql模块查询mysql数据库返回的， 在下面的代码中，我无法设置

CreatedID

的值，但该值已正确记录在终端中。我在第一个查询中遇到了相同的问题，但随后在下面的代码中对其进行了排序，现在无法访问嵌套查询结果

           var mysql =  require('node-mysql/node_modules/mysql');

 var connection =  mysql.createConnection({
    host : 'localhost',
    user : "root",
    password: "",
    database:'designtaskmanager'
  });
 connection.connect();
var allDbCalls = function() {
   var sendData = {};
   var rowData = {};
   var temp={};
   var _this = this;
   this.sendTask = function(callback) {
     module.exports.taskData =  rowData;
     callback['success']();
  };



  this.getTask = function(callback) {
    var strQuery = "select * from  task"; 
    connection.query( strQuery, function(err, rows){
      if(err) 
      {
        callback['failure']();
        throw err;
      }
      else
      {
        //rowData = rows;
        var tasks=[];

        for (var i in rows) 
        {
            var Title = rows[i].task_title;
            var TaskDescription=rows[i].task_description;
            var TaskCategory=rows[i].task_category;
            var TaskID=rows[i].task_id;
            var TaskStatus=rows[i].task_status;
            var TaskStatusMessage
            var CreatedBy;
            var TaskCreationDate=rows[i].task_creation_date;
            var _MS_PER_DAY = 1000 * 60 * 60 * 24;



            var currentdate = new Date(); 

            var ddd=dateDiffInDays(TaskCreationDate,currentdate);

            function dateDiffInDays(a, b) {
              // Discard the time and time-zone information.
              var utc1 = Date.UTC(a.getFullYear(), a.getMonth(), a.getDate());
              var utc2 = Date.UTC(b.getFullYear(), b.getMonth(), b.getDate());

              return Math.floor((utc2 - utc1) / _MS_PER_DAY);
            }

            if(TaskStatus==0)
            {
              TaskStatus="label-info";
              TaskStatusMessage="Ongoing since";

            }
            else if(TaskStatus==1)
            {
              TaskStatus="label-default";
              TaskStatusMessage="Paused since"

            } 
            else if(TaskStatus==2)
            {
              TaskStatus="label-success";
              TaskStatusMessage="Completed in"

            }

            //USER DETAILS QUERY
            var crid=rows[i].task_created_by;
            var creatorQuery = "select user_email from  users where user_id like ?";

            connection.query( creatorQuery,[crid], function(err, createdbyrows){
              if(err) 
              {
                callback['failure']();
                throw err;
              }
              else
              {
                for(var j=0; j< createdbyrows.length;j++)
                {
                  CreatedBy=createdbyrows[0].user_email;
                  console.log(j);


                }

                  console.log(CreatedBy);

              }
          });


            var taskItem={"TaskID":TaskID,"TaskTitle":Title,"TaskDescription":TaskDescription,"TaskCategory":TaskCategory,"CreatedBy":CreatedBy,"TaskStatus":TaskStatus,"TaskStatusMessage":TaskStatusMessage,"DifferenceInDays":ddd};

          tasks.push(taskItem);

        }

          rowData=tasks;
           _this.sendTask(callback);   
      }
    });
  }

}
module.exports = function () {
  var instance = new allDbCalls();
  return instance;
};

var mysql=require（'node-mysql/node_modules/mysql'）；
var connection=mysql.createConnection({
主机：“localhost”，
用户：“根”，
密码：“”，
数据库：'designtaskmanager'
});
connection.connect（）；
var allDbCalls=function（）{
var sendData={}；
var rowData={}；
var temp={}；
var_this=这个；
this.sendTask=函数（回调）{
module.exports.taskData=行数据；
回调['success']（）；
};
this.getTask=函数（回调）{
var strQuery=“从任务中选择*”；
connection.query（strQuery，函数（err，行）{
如果（错误）
{
回调['failure']（）；
犯错误；
}
其他的
{
//rowData=行；
var任务=[]；
用于（行中的变量i）
{
变量标题=行[i]。任务标题；
var taskscription=行[i]。任务描述；
var TaskCategory=行[i]。任务类别；
var TaskID=行[i]。任务\u id；
var TaskStatus=行[i]。任务状态；
var任务状态消息
var-CreatedBy；
var TaskCreationDate=行[i]。任务创建日期；
var _MS_/天=1000*60*60*24；
var currentdate=新日期（）；
var ddd=日期差异天数（TaskCreationDate，currentdate）；
函数dateDiffInDays（a，b）{
//丢弃时间和时区信息。
var utc1=Date.UTC（a.getFullYear（）、a.getMonth（）、a.getDate（））；
var utc2=Date.UTC（b.getFullYear（），b.getMonth（），b.getDate（））；
返回数学楼层（（utc2-utc1）/\u MS\u/天）；
}
如果（任务状态==0）
{
TaskStatus=“标签信息”；
TaskStatusMessage=“自开始进行”；
}
else if（TaskStatus==1）
{
TaskStatus=“标签默认值”；
TaskStatusMessage=“暂停自”
} 
else if（TaskStatus==2）
{
TaskStatus=“标签成功”；
TaskStatusMessage=“在中完成”
}
//用户详细信息查询
var crid=rows[i]。任务是由创建的；
var creatorQuery=“从用户id喜欢的用户中选择用户电子邮件？”；
query（creatorQuery，[crid]，函数（err，createdbyrows）{
如果（错误）
{
回调['failure']（）；
犯错误；
}
其他的
{
对于（var j=0；j

您在控制台上看到它而在回调中看不到它的原因是对异步编程的误解。当您：

for(var i in rows) {}

实际上，您正在同时对所有这些查询进行排队，然后，在尝试将rowData设置为空数组后，立即：

rowData=tasks; // remember, none of the queries have finished yet
_this.sendTask(callback);  

因此，当任务仍然是空数组时，您几乎可以调用回调。记住，在所有嵌套查询完成之前，不能调用最终回调

要实现这一点，您可能需要查看异步库：

这将帮助你实现你真正想要的

var async = require("async");
async.eachSeries(rows, function(row, cb) {
   // Do each query here
   // then call cb() when done, which tells the async library 
   // to "go to the next item in the array"
}, function(err) {
   // This will get called when all of the single queries are finished
   // Check err, then call your callback
   _this.sendTask(callback);   
});

---

你能给我举一个mysql的基本示例，它将json返回到一个路由吗？你可能想看看这样的ORM，它可以帮你完成大部分工作（使用Express、将行转换为对象等）。你可能还想考虑使用连接。在许多情况下，使用循环查找更多数据的效率会降低。例如，您的查询将是

SELECT t.*，e.user\u email FROM tasks t JOIN users u ON（u.user\u id=t.task\u created\u by）

。这将为您提供任务表中的所有内容，以及创建每个任务的用户id的电子邮件。