Review summary: The behavior of function scope and block scope is the same. It can be considered that any variable declared in a certain scope will be attached to this scope.

1. Why is this?

1. Now we ask two questions and give the following two pieces of code. Please think about the output results first, and then practice them. I believe you will have doubts!

//第一段代码
a=2;
var a;
console.log(a);

//第二段代码
console.log(a);
var a=2;

2. I guess the result is like this: you guess the result of the first piece of code is underfined, and then the result when running on the browser is 2; you guess the result of the second piece of code is 2, but on the browser The result of the operation is underfined. brother! Is this the case (even if it is not the case I guess you must be making other forms of wrong guesses).

3. Let’s explain why the result of the first code is 2, and the result of the second code is undefined. First of all, recall what we said before that a code with var a=2 looks like two codes in JS. Code snippet: var a and a=2; the former is executed during compilation and the latter is executed at runtime, so what’s the question? The declarations of variables and functions will be processed before the program is executed, so is the running order of the code still the writing order you see?

4. For the first piece of code, the second line of code var a is processed first during compilation, and the first and third lines are processed at runtime. Then the processing form of the entire code is as follows:

//第一段代码被JS这样的顺序处理了
var a;
a=2;
console.log(a);

Look! You can understand it this way, oh! Declare first, then assign, then print out.

5. For the same reason, the second piece of code is processed as follows:

//第二段代码被JS以这样的形式处理：
var a;
console.log(a);
a=2;

A has been declared during compilation, but during execution, it is executed to the console. a has not been assigned a value before log(a), and of course it is underfined when printed;

6. Therefore, during the process of the code being processed by JS, the positions of the declarations of variables and functions in the code seem to be moved. At the top of the scope, the priority process declared during the compilation process is to promote!

2. Each scope will be promoted.

1. Look at the following code:

foo();

function foo(){
    console.log(a);
    var a=2;
}

The global scope will promote the foo function declaration. When foo is used, A will be promoted in the domain, and the processing form is as follows:

function foo(){
    var a;
    console.log(a);
    a=2;
}
foo();

2. Special attention: Function declarations will be promoted, but function expressions will not be promoted. Named function expression, the name identifier cannot be used in the scope before assignment . What do these two sentences mean? The following two pieces of code tell you:

foo();  TypeError
bar();  ReferenceError
var foo=function bar(){
    //....
}

After this code is improved, it looks like this:

var foo;
foo();  TypeError
bar();  ReferenceError
foo=function (){
    var bar...
    //....
}

So for foo, there is a declaration, but there is no assignment to foo, and foo is undefined. At this time Operating on undefined is of course an error in the type of operation. And bar, not even declared, is declared in the function expression of foo, so it is an undeclared error.

3. For promotion: Functions are promoted first, followed by variables ;

Related recommendations:

In-depth understanding of javascript scope and closure

Detailed explanation of JavaScript scope and closure

The above is the detailed content of Explanation of knowledge about scope and closure in javaScript. For more information, please follow other related articles on the PHP Chinese website!