Scope chains and closures in JavaScript

• Scope
o Global scope
o Local scope
• Scope chain
• Execution context
• Active object
• Closure
• Closure optimization
There is a concept in JavaScript that has not been learned before—— Closure. What is closure? From the surface understanding, it is a closed package, which is related to scope. Therefore, before talking about closures, let’s talk about scope. C



Generally speaking, the variables and functions used in a program code are not always available. The scope of its availability is the scope of action. Reliability, reducing name conflicts.
          Global Scope
        Objects that can be accessed anywhere in the code have global scope. The following situations have global scope:
    1. The outermost function and the outermost function defined outside Variables have global scope, for example:
[javascript]
1. var outSide="var outside";
2. function outFunction(){
3. var name="var inside";
4. function inSideFunction(){
5.         alert(name); ; "
3. All properties of the window object have a global scope. For example: the built-in properties of the window object have a global scope, such as window.name, window.location, window.top, etc.
Local Scope (Local Scope)
[ javascript]
1. function outFunction(){
2. var name="inside name";
3. function inFunction(){
4. alert(name ; )
                                               In JavaScript, everything in JavaScript is an object, including functions. Function objects, like other objects, have properties that can be accessed through code and a set of internal properties that are only accessible to the JavaScript engine. One of the internal properties is scope, which contains the collection of objects in the scope in which the function was created, called the function's scope chain, which determines what data can be accessed by the function.
　When a function is created, its scope chain will be filled with data objects accessible in the scope in which the function was created. For example, function:
[javascript]
1. function add(num1,num2) {
2. var sum = num1 + num2;
3. return sum;
4. }

When the function add is created, its scope A global object will be filled in the chain, which contains all global variables, as shown in the picture below (note: the picture only illustrates a part of all variables):

It can be seen that the scope chain of a function is created when the function is created.
Execution context (Execute context)
The scope of the function add will be used during execution, for example:
[javascript]
1. var total = add(5,10);

When the add function is executed, JavaScript An Execute context will be created, which contains all the information needed by the add function during runtime. Execute context also has its own Scope chain. When the function runs, the JavaScript engine will first initialize the execution context's scope chain from the scope chain using the add function.
Active Object
Then the JavaScript engine will create an Active Object. These values ​​​​are copied to the scope chain of the runtime context in the order they appear in the function. Together they form a new object—— "Activation object", this object contains all local variables, parameters and this and other variables during the function runtime. This object will be pushed to the front end of the scope chain. When the runtime context is destroyed, the activation object will also Then destroyed. The new scope chain is shown in the figure below:

Execution context is a dynamic concept. It is created when the function is running. The active object Active Object is also a dynamic concept. It is referenced by the scope chain of the execution context. , it can be concluded that execution context and active objects are both dynamic concepts, and the scope chain of the execution context is initialized by the function scope chain.过 During the function execution process, every time you encounter a variable, you will retrieve where to obtain and store data from. This process starts from the domain chain head, that is, starting from the object of the activity to find the identifier of the same name. If you find it, use it. If there is no variable corresponding to this identifier, continue to search for the next object in the scope chain. If all objects are not found after searching, the identifier is considered undefined. During the execution of the function, each identifier must go through Such search process.
Closure (closure)
Let’s look at an example first, javascript code:
[javascript]
1.