About the calculation method of JS function call stack stack size

This article shares with you the relevant knowledge points about the calculation method of JS function call stack stack size. Interested friends can refer to it for reference.

If you write an infinite loop that keeps calling itself, congratulations, you will soon see an error: Uncaught RangeError: Maximum call stack size exceeded. So what is the call stack size?

1. Calculation method

The following method can calculate for you how deep the call can be supported by the JavaScript engine you are using (inspired by a piece of code by Ben Alman ):

function computeMaxCallStackSize() {
    try {
      return 1 + computeMaxCallStackSize();
    } catch (e) {
      // Call stack overflow
      return 1;
    }
  }

The following three results are obtained by running:

• Node.js: 11034

• Firefox: 50994

• Chrome: 10402
  

##What do these numbers represent? Mr.Aleph told me that in V8, the number of callable layers is based on two aspects: 1. The size of the stack; 2. The size of each stack frame (used to record function parameters and local variables). You can declare a local variable in computeMaxCallStackSize to test and you will find that the number becomes smaller.

2. Tail recursion optimization in ECMAScript 6

ECMAScript 6 supports tail recursion optimization: If the last operation of a function is a function call, then "jump" will be used ” instead of “subcall”. In other words, if you rewrite computeMaxCallStackSize into the following form, it will always run in ES6 strict mode.

function computeMaxCallStackSize(size) {
    size = size || 1;
    return computeMaxCallStackSize(size + 1);
  }

3. Highlight comments

Andrei: The "ECMAScript 6" version of the code doesn't work at all. Although the size will be changed, no value will be returned in the end.

Reply to Andrei: Interesting! You cannot use this code to calculate stack size. Under ES6, this code will run forever, so no data will be returned. In other cases, RangeError will be returned. In order to make it work, I rewrote the code:

var computeMaxCallStackSize = (function() {
 return function() {
  var size = 0;
  function cs() {
   try {
    size++;
    return cs();
   } catch(e) {
    return size + 1;
   }
  }
  return cs();
 };
}());

The above is the entire content of this article, I hope it will be helpful to everyone's learning, more Please pay attention to the PHP Chinese website for related content!

Related recommendations:

jQuery implements obtaining dynamically added tag objects

How does the WeChat applet obtain data in javascript

How to determine whether the iframe is loaded through JS

##

The above is the detailed content of About the calculation method of JS function call stack stack size. For more information, please follow other related articles on the PHP Chinese website!