Javascript 节点mysql定时

我有这样一个递归查询（注意：这只是一个示例）：

这不起作用，因为timmings都错了，代码不等待查询

我尝试过这样做：

var MyQuery = function(QueryString){
    var Data;
    var Done = false;
    database.query(QueryString, function(err, result, fields) { 
        Data = result;
        Done = true;
    });
    while(Done != true){};
    return Data;
}

var user = function(data)
{
  this.minions = [];
  this.loadMinions = function()
  {
    _user = this;
    result= MyQuery('select * from users where owner='+data.id);
    for(var m in result)
    {
      _user.minions[result[m].id] = new user(result[m]); 
      _user.minions[result[m].id].loadMinions();
    }
    console.log("loaded all minions");
  }
}
currentUser = new user(ID);
for (var m in currentUser.minions)
{
  console.log("minion found!");
}

---

但是他只是僵住了，我是不是遗漏了什么？

每个Node.js进程都是单线程的，所以

while(Done != true){};

接管线程，并且将

Done

设置为true的回调永远不会运行，因为thead被无限循环阻塞

您需要重构程序，使依赖于查询结果的代码包含在回调本身中。例如，使

MyQuery

接受回调参数：

MyQuery = function(QueryString, callback){

---

然后在

数据库的末尾调用回调。query

回调--甚至将其作为

数据库提供。query

回调。

由于节点是单线程的，因此冻结行为很不幸是正确的

---

您需要一个计划程序包来修复此问题。就我个人而言，我一直在用光纤来解决这类问题。您可能想看看这个或另一个promise库或async，解决问题的第一个障碍是理解Node.js中的I/O是异步的。一旦您知道这如何应用于您的问题，递归部分就会容易得多（特别是如果您使用像Async或Step这样的流控制库）

下面是一个示例，它完成了您尝试执行的一些操作（减去递归）。就我个人而言，我会避免递归加载可能未知数量/深度的记录；而是按需加载，如本例所示：

var User = function(data) {
    this.data = data
    this.minions;
};

User.prototype.getMinions = function(primaryCallback) {
    var that = this; // scope handle
    if(this.minions) { // bypass the db query if results cached
        return primaryCallback(null, this.minions);
    }

    // Callback invoked by database.query when it has the records
    var aCallback = function(error, results, fields) {
        if(error) {
            return primaryCallback(error);
        }

        // This is where you would put your recursive minion initialization
        // The problem you are going to have is callback counting, using a library
        // like async or step would make this party much much easier

        that.minions = results; // bypass the db query after this
        primaryCallback(null, results);
    }

    database.query('SELECT * FROM users WHERE owner = ' + data.id, aCallback);
};

var user = new User(someData);    
user.getMinions(function(error, minions) {
    if(error) {
        throw error;
    }

    // Inside the function invoked by primaryCallback(...)
    minions.forEach(function(minion) {
        console.log('found this minion:', minion);
    });
});

---

本例中需要注意的最大问题是回调。

database.query（…）

是异步的，您不希望占用事件循环等待它完成。通过向查询提供回调，

aCallback

，可以解决这一问题，该回调在结果就绪时执行。一旦启动回调，在您对记录执行任何您想执行的处理之后，您就可以启动带有最终结果的

primaryCallback

。

您基本上错过了Node.js和您可能习惯于编程的环境之间记录最完整、最重要的变化。你是怎么做到的？

var User = function(data) {
    this.data = data
    this.minions;
};

User.prototype.getMinions = function(primaryCallback) {
    var that = this; // scope handle
    if(this.minions) { // bypass the db query if results cached
        return primaryCallback(null, this.minions);
    }

    // Callback invoked by database.query when it has the records
    var aCallback = function(error, results, fields) {
        if(error) {
            return primaryCallback(error);
        }

        // This is where you would put your recursive minion initialization
        // The problem you are going to have is callback counting, using a library
        // like async or step would make this party much much easier

        that.minions = results; // bypass the db query after this
        primaryCallback(null, results);
    }

    database.query('SELECT * FROM users WHERE owner = ' + data.id, aCallback);
};

var user = new User(someData);    
user.getMinions(function(error, minions) {
    if(error) {
        throw error;
    }

    // Inside the function invoked by primaryCallback(...)
    minions.forEach(function(minion) {
        console.log('found this minion:', minion);
    });
});