Home >Web Front-end >JS Tutorial >Detailed explanation of the principle and implementation of JavaScript pre-parsing

Detailed explanation of the principle and implementation of JavaScript pre-parsing

黄舟Original: 2017-03-14 15:32:231383browse

JavaScript is undoubtedly an interpreted language, but is it only parsed sentence by sentence from top to bottom at runtime?

In fact or some phenomenon proves that this is not the case. Through the "JavaScript Definitive Guide" and related online information, we learned that JavaScript has "pre-parsing" behavior. It is important to understand this feature, otherwise you may encounter many problems that cannot be resolved in actual development, and even lead to program bugs. In order to analyze this phenomenon, and as a summary of my own learning, this article will gradually guide you to understand JavaScript "pre-parsing". If my opinion is wrong, please correct me.

(1) If JavaScript is only parsed sentence by sentence from top to bottom during runtime, it is understandable that the following code can run correctly, because we first define the function and then call it it.

function showMsg() 
{ 
alert(&#39;This is message&#39;); 
} 
showMsg(); // This is message

(2) We also know that functions can be defined after calling the code, and the following code can also work normally. It seems that showMsg() is still not defined when showMsg() is called, but it works normally, which indicates that JavaScript is "pre-parsed".

showMsg(); // This is message 
function showMsg() 
{ 
alert(&#39;This is message&#39;); 
}

(3) The above is an example of a function, and here is another example of a common variable. When the following example is run, undefined will pop up, indicating that msg in the first sentence has been defined, but has not been initialized. It is the same as var msg; alert(msg);. If you comment out of the second sentence below, an "msg is not defined" error will be reported. This also indicates that JavaScript is "pre-parsed".

alert(msg); //undefined 
var msg=&#39;This is message&#39;;

(4) Let’s look at another example to deepen our impression of JavaScript “pre-parsing”. In the following code, you will see that the dialog box that pops up twice displays This is message 2. Why is this? In fact, two functions with the same name are defined one after another below. The later showMsg() overwrites the previously defined one (in JavaScript, variables with the same name will also have overwriting problems), which means that the first showMsg() is scrapped. Why does the second call of showMsg() not call the message 1 function defined above? This once again proves that JavaScript has "pre-parsing" behavior.

showMsg(); // This is message 2 
function showMsg() 
{ 
alert(&#39;This is message 1&#39;); 
} 
showMsg(); // This is message 2 
function showMsg() 
{ 
alert(&#39;This is message 2&#39;); 
}

(5) JavaScript "pre-parsing" is to pre-parse variables or functions into the environment where they can be called (variable runtime environment). The following code seems to have seen the definition of msg before alert(msg), but the program still reports the error "msg is not defined". This is because the variables defined in the function are private variables of the function and cannot be called directly from outside. This indicates that JavaScript "Pre-parsing" does not uniformly parse all defined variables into a global

object, such as window.

function showMsg() 
{ 
var msg=&#39;This is message&#39;; 
} 
alert(msg); // msg未定义

(6) JavaScript "pre-parsing" is performed in sections, to be precise, it is performed in 3f1c4e4b6b16bbbd69b2ee476dc4f83a blocks. The following code appears in two script blocks on the same page and defines three functions with the same name. The program running results show that showMsg() of the second script block does not cover the first two showMsg(), while the second showMsg() of the first script block covers the first showMsg().

<body> 
<script type="text/javascript"> 
showMsg(); //This is message 2 
function showMsg() 
{ 
alert(&#39;This is message 1&#39;); 
} 
function showMsg() 
{ 
alert(&#39;This is message 2&#39;); 
} 
</script> 
<script type="text/javascript"> 
function showMsg() 
{ 
alert(&#39;This is message 3&#39;); 
} 
</script> 
</body>

The above is the detailed content of Detailed explanation of the principle and implementation of JavaScript pre-parsing. For more information, please follow other related articles on the PHP Chinese website!

Statement：

The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Previous article：Detailed explanation of how to operate JavaScript filesNext article：Detailed explanation of how to operate JavaScript files

See more

Detailed explanation of the principle and implementation of JavaScript pre-parsing

Related articles