Detailed explanation of js variables and their scope_javascript skills

1. Variable type
Javascript is different from languages ​​such as Java and C. It is an untyped and weakly detected language. Its definition of variables does not require declaring the variable type. We can assign various types of data to the same variable through assignment. For example:

Copy code The code is as follows:

i=100;//Number type
i="variable";//String type
i={x:4};//Object type
i=[1,2,3];//Array type

Although this feature of JS makes our coding more flexible, it also brings a drawback, which is not conducive to debugging. The compiler's weak detection makes it quite painful for us to maintain lengthy code.
2. Variable declaration
Variable declaration in JS is divided into explicit declaration and implicit declaration.
var i=100;//Explicit declaration
i=100;//Implicit declaration
Variables explicitly declared using the var keyword in a function are used as local variables and are useless The var keyword declares global variables using direct assignment.
When we access an undeclared variable, JS will report an error. When we assign a value to an undeclared variable, JS will not report an error. On the contrary, it will think that we want to implicitly declare a global variable. This must be paid attention to.
3. Global variables and local variables
When the JS parser is executed, it will first build a global object in the execution environment. The global properties we define are properties of the object. Read, in the top-level code we can access it using the this keyword and the window object. The local variables in the function body only exist in the calling object generated when the function is executed. The local variables are destroyed immediately when the function is executed. Therefore, in programming, we need to consider how to declare variables reasonably, which not only reduces unnecessary memory overhead, but also largely avoids the debugging trouble caused by repeated definition of variables and overwriting previously defined variables.
4. Variable Scope
The scope of variables is a critical detail in any programming language. The scope of variables in JS is relatively free compared to languages ​​​​such as JAVA and C. A big feature is that JS variables do not have block-level scope. The variables in the function are valid in the entire function. Run the following code:

Copy code The code is as follows:

Output The result is 0 1 0. From the above, it can be proved that if JS uses var to declare a variable in the function body, then this variable is valid in and only within the function body. When the function ends, the local variable can be destroyed.
Due to the above JS features, there is another key issue that needs attention. ActionScript has been used before. Although it and JS are both based on the ECMA standard, it is slightly different here. For example, the following code:

Copy code The code is as follows:

You may think that the output result is 0 0 1 0. In fact, this is indeed the case in AS, but the input in JS is 0 undefined 1 0. Why is this happening? We just mentioned that the local variables declared in the JS function body are valid in the entire function, so in the above code var　i = 1; are valid in the inner function. In fact, the explicitly declared variable i is precompiled. It has been compiled into the calling object. Unlike implicitly declared variables, which are defined as global variables when interpreted, only when outPut(i) is called, the variable has not been initialized. At this time, the local variable i is an unassigned variable. , instead of undefined variables, so undefined is output. The above code is equivalent to the following code:

Copy code The code is as follows:

function inner( ){
var i; //Define but not assign
outPut(i); //undefiend
i=1;
outPut(i); //1
}

In order to avoid the above problems, it is highly recommended to make function declarations at the beginning of the function.
5. Basic types and reference types
JS is different from languages ​​such as JAVA and C. It does not need to declare the storage space of the variable when declaring the variable. The data stored in variables can be divided into two categories: basic types and reference types. Among them, numeric values, Boolean values, null and undefined are basic types, and objects, arrays and functions are reference types.
Basic types have a fixed memory size in memory. For example: Numeric type occupies eight bytes in memory, and Boolean value only occupies one byte. For reference data, they can have any length, so their memory size is variable, so what is stored in the variable is actually a reference to the data, usually a memory address or pointer, through which we can find the data.
There are also differences in usage behavior between reference types and basic types:

Copy code The code is as follows:

When assigning a value to basic type b, another area is actually opened up memory space, so changing the value of variable a has no effect on variable b.

Copy code The code is as follows:

The above are variable assignments of reference types. In fact, what they pass is a reference to the memory address, so the access to a_array and b_array are actually both It is the same memory area that is operated on. If I want to reallocate memory space to store reference variables, then I need to use the cloning method or a custom method to copy the data of the reference variable.

JS variable scope

Copy code The code is as follows:

var defines a variable in a scope. Before a is output for the first time, JS has assigned a to change in the pre-compilation analysis, so the first Change is output for the first time. When the fun() function is called, JS creates a new scope. Before outputting a, it initializes the values ​​​​of all var variables to undefined, so the first output in fun() is undefined. The secondary output has been assigned a value, so a new value is output; the two a's are two different variables inside and outside the function, such as:

Copy code The code is as follows:

Variable b has been defined outside the function. A value is assigned to b in the function, but the output is undefined.