Nodejs exceeds the maximum call stack error problem solution

This article mainly introduces the problem of nodejs exceeding the maximum call stack error. Friends in need can refer to it. I hope it can help everyone.

The code implemented by the program is roughly as follows

function modify(cursor) {
  cursor.hasNext(function(err,bool) {
   if(err) {
      return console.log(err); 
    } 
    if(bool) {
      cursor.next(function(err, item){
       if(err) {
       return console.log(err);
     }
     /* 此处为对数据进行update操作 */
     // 递归调用modify方法 
     return modify(cursor);
   }); 
    }else{
      console.log('finished');
    }
  })
}
var cursor = collection.find();
modify(cursor);

Then let it run slowly, but something depressing me happened. When the cursor reached close to 5 million, the program crashed, prompting Uncaught RangeError: Maximum call stack size exceeded

and actually told me that the stack was exploded. What happened? Hey, check the code and start filling in the holes. I found that I called modify() recursively above, and the number of recursions was a bit small (for a table with more than 10 million records). It may be that the function's constant recursive calls caused its call stack to continue to increase, and then get bigger and bigger, and finally There is no more, the stack explodes. It seems that we need to give the node a chance to perform garbage collection. If we want it to have a chance to perform garbage collection, we have to terminate the recursion. Use the system's setTimeout(); to jump out of the recursive call stack.

The code is modified as follows

function modify(cursor) { 
  cursor.hasNext(function(err,bool) {
    if(err) {
      return console.log(err); 
    }
    if(bool) {      
      cursor.next(function(err, item){
        if(err) {
          return console.log(err);
        }
        /* 此处对数据进行update操作 */
        // 递归调用modify方法 
        return setTimeout(function(){ 
              //跳出递归调用栈
              modify(cursor);
            },0);
      }); 
    }else{
      console.log('finished');
    }
  })
}
var cursor = collection.find();
modify(cursor);

Try running it. . . . ok, it works. But it runs a bit slowly, because I have to make it jump out of the recursive call stack every time. Although this is okay, it is not necessary, because the stack will only explode after more than 4 million. Add a counter and pop it out when the call stack gets a little big.

var count = 0;
function modify(cursor) { 
  count++;
  cursor.hasNext(function(err,bool) {
    if(err) {
      return console.log(err); 
    }
    if(bool) {
      cursor.next(function(err, item){
        if(err) {
         return console.log(err);
        }
        /* 此处对数据进行update操作 */
        // 递归调用modify方法 
        if(count%10000 === 0) {
          return setTimeout(function(){ 
              //跳出递归调用栈
              modify(cursor);
              },0);
        }else{
          return modify(cursor);
        }    
      }); 
    }else{
      console.log('finished');
    }
  })
}
var cursor = collection.find();
modify(cursor);

Related recommendations:

Detailed introduction to JavaScript call stack, tail recursion and manual optimization

Front-end advanced (6): Observe function call stack, scope chain and closure

Front-end basic advanced (6): Observe function call stack in chrome developer tools , scope chain and closure

The above is the detailed content of Nodejs exceeds the maximum call stack error problem solution. For more information, please follow other related articles on the PHP Chinese website!