Revisiting JavaScript Scope_Basic Knowledge

Golden Rule 1:

JS does not have block-level scope (you can implement it with your own closure or other methods). It only has function-level scope. Variables outside the function can be found inside the function, but variables inside the function cannot be found outside the function.

first try：

Why is this? ?

var a = 10;
function aaa(){//step-4
	alert(a);//step-5->执行alert，此时只能找到外面的a=10故弹框10
}
function bbb(){//step-2
	var a = 20;
	aaa();//step-3
}
//定义了函数没啥用，调用才是真格的所以这里是step-1
bbb();//step-1

In fact, everyone knows the principle. It should be just that it is easy to make mistakes.

second try：

Why is this? Because when assigning b to a, b has not been defined, so a is undefined and b is 10.

Golden Rule 2:

The search for variables is based on the principle of proximity. Look for the variable defined by var. When the variable is not found nearby, search for the outer layer.

look:

Why is this? There are two reasons for this, one is pre-analysis, and the other is nearby search.

var a=10;
function aaa(){
	alert(a);//undefined，查找a的时候会现在函数内查找，由于预解析的作用，此时的a是undefined,因此永远不会去查找外面的10了
	var a = 20;

	/*预解析
	var a
	alert(a);
	var a = 20;*/

}
aaa();

attention:

Well, this verifies the second point. Although it is the principle of proximity, the variables declared by var are found nearby. This is because variables declared without var are global, and here only the value of a is modified. So the above is because the a of var was not found in the function, so I went outside to look for it. I found it as soon as I looked for it, so a was alerted to 10; but it is true that after a=20, a is indeed 20. It’s just that the alert has not been executed yet~~

Let’s see~

The following example further verifies the function scope of js:

This is because at the time of alert(a), a in the bbb function is indeed 20, but it is local to the sentence alert(a) at this time, and alert(a) cannot be found at all. a in the bbb function, so it couldn't find a in the aaa function, so it went to look outside and found 10.

Golden Rule 3:

When a parameter has the same name as a local variable, the priority is the same.

Example:

Also: when passing parameters, basic types pass by value, and reference types pass by reference. (But this will not be the case after reassignment)

var a = 5;
var b = a;
b +=3;
alert(a);//5

var a = [1,2,3];
var b=a;
b.push(4);
alert(a);//[1,2,3,4];

There is no problem with the above code, but the following is different.

Because b has been reassigned and no longer points to a.

In addition, the scope of parameters and variables are similar:

Compare these two:

The above parameter is a basic type, and only the value is passed in. The following is a reference type: (also includes reassignment)