NetEase JS interview questions and Javascript lexical scope description_javascript skills

The calling object is at the front of the scope chain. Local variables (variables declared with var inside the function), function parameters, and Arguments objects are all scoped within the function - which means that they hide anything higher up the scope chain. Property with the same name.

On September 14, 2010, I went to the NetEase web engineer job fair and applied for the JS engineer position. I was lucky enough to take the written test, and then I was lucky enough to fail in the written test, haha. Stop talking nonsense, pick out a question that has a profound impact and study it again.

The question is probably: Write the output of the following code and analyze it

Copy the code Code As follows:

var tt = 'aa';
function test(){
alert(tt);
var tt = 'dd';
alert(tt ; injury. My answer is - aa and dd, analysis: the first time the result of the global variable is output, then the local variable tt overwrites the value referenced by the global variable, so the second time the output result is dd.

Anyone who sees me answering like this will think that I am trying to educate myself - the idea is extremely naive (I think so too)!

NetEase, how could you be satisfied with this answer!

The correct answer should be: undefined and dd

Why is the result of the first alert undefined? To explain clearly, you need to use Javascript's lexical scope.

Functions in Javascript "run in the scope in which they are defined, not in the scope in which they are executed." This is an abstract and incisive summary in the authoritative guide.

Javascript logic is executed in a global scope by default. For example, "var tt='aa';" in the above program segment defines a global variable in the global scope (if the above code segment is not excerpted from a certain function chain). The internal logic of the test() function must add the scope (locality) of the test function itself to the original scope (global scope) chain - these ideas are defined in this way in almost every language. However, The special thing about Javascript scope chain is that the definition of function can be nested inside the function (this is the basis of closure. Note: function is the only form of code scope in JS)

Nested internal function Variables that can call external functions (nested functions) and other nested functions (a function is a kind of data). If a nested function is called within an external function, the calling object remains unchanged. After the external function is executed, all data (including external functions and nested internal functions) will be collected by the garbage collection mechanism - this cannot be reflected yet. The essence of 'closure'. There is a situation where Javascript allows external calls to nested internal functions, even if the nested function has been 'garbage collected' - the most common is to define certain elements with its nested internal functions in a 'function' In response to the event, when the page is loaded, the nested function ('a certain function') has been executed (was garbage collected), but when the event is triggered, there will still be a response action, and the response function may also be called. The final value of the variable defined in the nested function ('a function') (isn't it garbage collected?).

There is a lot of information available about closure knowledge and examples, I don’t want to describe it.

The focus of this article is the following very important details:

The calling object is at the front end of the scope chain. Local variables (variables declared with var inside the function), function parameters and Arguments objects are all In scope within a function - this means that they hide any properties with the same name further up the scope chain.

That is, in the above program fragment, "var tt='dd'" inside the test function will cause "var tt='aa'" to be completely hidden when the test function is called. Moreover, tt is defined after the first alert statement, so when the first alert is called, tt has not yet been assigned a value. It may be clearer to say this, that is, when defining the test function, when defining the first alert(tt), it will be recorded that tt is a variable in the scope chain but its (tt) value will not be recorded. The function After the definition is completed, tt is added to the scope, so the first alert statement can find the tt in the scope (that is, it is equivalent to finding a tt that has been declared inside the function but has not been assigned a value).

The execution result of the above program fragment is the same as the result of the following fragment:





Copy code

The code is as follows : var tt = 'aa'; function test(){ var tt;

alert(tt);

tt = 'dd';
alert(tt);
}
test();


The scope of Javascript cannot be simply understood using the thinking of languages ​​such as C! C must declare or define a function before calling it, but Javascript does not. In Javascript, you can call a function first and then define it (without making any declaration before calling). Because when calling a function, Javascript asks the scope chain for the definition of the function (functions run in the scope where they are defined, not the scope where they are executed)

For example, the above code is written:

Copy code The code is as follows:

var tt = 'aa';
test() ; //Call first and then define
function test(){
alert(tt); //undefined
var tt = 'dd';
alert(tt); //dd
}

Although the above code snippet can get the same result, it is best not to write it like that. It is a bad habit and the code is not easy to maintain.