A brief discussion on execution environment (scope) and scope chain in JavaScript

I believe that many beginners do not have a good understanding of the execution environment and scope chain in JavaScript. Here, I will share with you according to my own understanding.

Generally, we divide the execution environment into global execution environment and local execution environment. The local execution environment can also be called function execution environment. So what exactly is an execution environment? In layman's terms, the execution environment is the environment in which the code is executed. Let's take a look at the following code and analyze it further.

<script><br>var name="zhuzhenwei";
function changeName(){
    if (name=="zhuzhenwei"){
          name="heting";
    }else{
          name="zhuzhenwei";
    }
}
changeName();
console.log(name); //heting<br></script>

As shown in the above code, when the first statement is executed, the environment where the statement is located is the global execution environment. It should be noted that: each execution environment has a variable object associated with it. For The global execution environment, and the object associated with it is the window object. Immediately afterwards, the following statement declares a function (note: this only declares the function, the internal code will not be executed until it is called).​ This function is also in the global execution environment. Finally, we called the changeName() function. Once the function is called, it immediately jumps to the execution environment of the changeName() function (that is, the function execution environment). Once it enters the execution environment, it starts to create the corresponding variables inside the function (such as Suppose var appears in the function a=12; code like this), it will not be created without calling the function, and the variable object related to it is considered to be an active object (the active object initially contains only one variable, that is, the arguments object), from top to Execute the statement below. At the same time, when the code is executed in the function environment, a scope chain of the variable object will be created. This scope chain contains the variable object of changeName() and the global variable object.

The scope chain is actually the scope that we can access from the front end to the end, that is, ensuring orderly access to all variables and functions that have access to the execution environment, where the front end refers to the variable object where the currently executing code is located , here is now the variable object of the changeName() function, and the end is the global variable object. For example: when we execute the function, we need to find an identifier. This is to search through the end of the scope chain. If the scope chain If you can't find it at the end, you keep searching upward until you reach the window object. Although I did not mention the scope chain in the global environment, in fact the scope chain also exists in the global environment, but there is only one global variable object. It's obvious: accessing local variables is faster than accessing global variables because there is no need to search up the scope chain. Obviously, the scope chain changes dynamically depending on the execution environment in which the code is located.

After the changeName() function is executed, that is, after the execution of the code in the function execution environment is completed, the local variables and local objects in the environment will be destroyed immediately (if the variable is not declared with var, it indicates that it is a global variable and will not Destroyed after the code in the local environment is executed), then the execution environment changes from the function execution environment to the global execution environment, and continues to execute the console.log(name); statement. However, if we close the web page or browser, the global environment will also be destroyed.

The summary is as follows:

The execution environment also becomes the scope, and the execution environment determines the life cycle of variables.

The execution environment is divided into global execution environment and local execution environment. Every time you enter an execution environment, a scope chain for searching for variables and functions will be created, so we think that this scope chain changes dynamically.

The local environment of a function not only has access to variables in the function scope, but also has access to its containing environment (parent environment) and even the global environment; while the global environment can only access variables and functions defined in the global environment (local Variables in the environment that are not declared using var are also global variables) and cannot access data in the local environment (not all data is said, precisely because global variables can be accessed). Note: Parameters in a function are local variables of the function.

The above is the entire content of the execution environment (scope) and scope chain in JavaScript. I hope the content of this article can bring some help to everyone's study or work. If you have any questions, you can leave a message to communicate, and you want to know more. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!