Der Inhalt dieses Artikels befasst sich mit der Frage, was JavaScript-Vorinterpretation ist. Die Analyse der JavaScript-Vorinterpretation (mit Code) hat einen gewissen Referenzwert. Ich hoffe, dass sie für Sie hilfreich ist.
JavaScript ist eine interpretierte Sprache, die zwei Phasen erfordert
Kompilierungsphase: Die Kompilierungsphase wird oft als JavaScript-Vorinterpretationsphase (Vorverarbeitung) bezeichnet. In dieser Phase schließt der JavaScript-Interpreter die Konvertierung des JavaScript-Skriptcodes in Bytecode ab.
Ausführungsphase: Während der Kompilierungsphase wandelt der JavaScript-Interpreter mithilfe der Ausführung den Bytecode in Bytecode um Umgebung Generieren Sie mechanischen Code und führen Sie ihn nacheinander von oben nach unten aus
Dieser Artikel konzentriert sich auf die Vorinterpretation:
Vorinterpretation:Bevor JavaScript-Code ausgeführt wird, deklariert oder definiert der Browser standardmäßig alles im Voraus mit var und function
Deklarieren: var num;=> teilt dem Browser beispielsweise mit, dass es eine num-Variable im globalen Bereich gibt deklariert, aber es gibt keine Zuweisung und der Standardwert ist undefiniert
Definition (definiert): Beispielsweise weist num=12;=> unserer Variablen einen Wert zu.
var => wird nur im Voraus während der Vorinterpretation
function = deklariert > Während der Vorinterpretation werden alle frühen Deklarationen und Definitionen vervollständigt
Zum Beispiel: Zunächst werden nur die Inhalte unter dem Fenster vorinterpretiert, und die Funktionen in der Funktion werden erst vorinterpretiert, wenn die Funktion ausgeführt wird
1) Im globalen Bereich deklarierte Variablen (sofern vorinterpretiert) sind globale Variablen
2) Nur die Funktionsausführung hat private Auswirkungen. Domänen, z for(){}, if(){} und switch(){} generieren keinen privaten Bereich
3) Variablen, die im „privaten Bereich“ (var-Deklaration)“ deklariert sind und „Funktionsparameter“ sind beide private Variablen . Wenn der Code im privaten Bereich ausgeführt wird und auf eine Variable stößt, müssen wir zunächst feststellen, ob es sich um eine private Variable handelt, wenn sie nicht privat ist geht zu Durchsuchen Sie den Bereich der oberen Ebene des aktuellen Bereichs. Wenn kein Bereich der oberen Ebene vorhanden ist, wird die Suche fortgesetzt, bis das Fenster gefunden wird.
Nehmen wir ein Beispiel, um zwischen privaten Variablen und globalen Variablen zu unterscheiden:
//=>变量提升：var a;var b;var c;test=AAAFFF111；
var a=10,b=11,c=12;
function test(a){
//=>私有作用域：a=10 var b；
a=1；//=>私有变量a=1
var b=2；//=>私有变量b=2
c=3；//=>全局变量c=3
}
test(10);
console.log(a);//10
console.log(b);//11
console.log(c);//3Ein Kriterium zur Beurteilung, ob es sich um eine private Variable handelt, ist, ob es sich um eine in var in a deklarierte Variable handelt Funktion und ein formaler Parameter der Funktion. Sie sind alle private Variablen . In dieser Frage ist a in der Testfunktion ein formaler Parameter und die durch var b definierte Variable b ist eine private Variable.
Dies liegt daran, dass bei der Ausführung der Funktion zunächst ein neuer privater Bereich erstellt und dann gemäß den folgenden Schritten ausgeführt wird:
1) Wenn formale Parameter vorhanden sind, weisen Sie zuerst den formalen Parametern Werte zu
2) Führen Sie eine Vorinterpretation im privaten Bereich durch
3) Code im privaten Bereich wird von oben nach unten ausgeführt
Sehen wir uns eine Beispielfrage an
var total=0；
function fn(num1,num2){
console.log(total);//->undefined 外面修改不了私有的
var total=num1 +num2；
console.log(total);//->300
}
fn(100,200);
console.log(total);//->0 私有的也修改不了外面的Stack-Speicher: wird verwendet, um eine Umgebung für die Ausführung von JS-Code bereitzustellen, d. h. den Bereich (globaler Bereich/privater Bereich)
Heap-Speicher: wird zum Speichern von Werten von Referenzdatentypen verwendet. Objekte speichern Attributnamen und Attributwerte und Funktionen speichern Codezeichenfolgen.
Sehen wir uns zunächst die folgenden zwei Beispiele an:
//例题1 console.log(num);//->undefined var num=12;
Wenn Sie var num=12 sehen , könnte man meinen, es sei nur eine Aussage. Aber JavaScript behandelt es tatsächlich als zwei Deklarationsanweisungen: var num; und num=12; Die erste Definitionsanweisung wird in der Vorinterpretationsphase gemacht. Die zweite Zuweisungsanweisung bleibt an Ort und Stelle und wartet auf die Ausführungsphase . num2=12 entspricht dem Hinzufügen eines Attributnamens namens num2 zum Fenster, und der Attributwert ist 12; und var num=12 entspricht dem Hinzufügen einer globalen Variablen num zum globalen Bereich zum Fenster. Der Attributname ist num2 und der Attributwert ist 12. Der größte Unterschied zwischen den beiden: Der mit var kann vorinterpretiert werden, sodass bei der Ausführung vor der Zuweisung kein Fehler gemeldet wird. Der ohne var kann nicht vorinterpretiert werden und bei der Ausführung wird ein Fehler gemeldet vorher;
Als nächstes geben wir ein Beispiel:
//例题2 console.log(num2);//->Uncaught ReferenceError:num2 is not defined num2=12;//不能预解释
//例题1
var total=0;
function fn(){
console.log(total);//undefined
var total=100;
}
fn();
console.log(total);//0In Beispiel 1 kann die Variable var im privaten Bereich vorinterpretiert werden, also der von der ersten Konsole gedruckte Wert ist undefiniert. Wenn eine Variable, die im privaten Bereich erscheint, nicht privat ist, suchen Sie im oberen Bereich. Wenn es keinen oberen Bereich gibt, suchen Sie weiter, bis Sie das Fenster in Beispiel 2 finden , die Variable ohne var ist nicht privat, also gehen Sie zu Ihren Vorgesetzten
4. Erklären Sie im Voraus die fünf wichtigsten unethischen Verhaltensweisen 1. Bei der Vorerklärung spielt es keine Rolle, ob Ihre Bedingungen erfüllt sind oder nicht, Sie müssen die Variable im Voraus deklarieren. Bitte schauen Sie sich die folgende Beispielfrage an:if（!("num" in window)){
var num=12；//这句话会被提到大括号之外的全局作用域：var num;->window.num；
}
console.log(num);//undefined请看下面这道例题：
fn()；//报错
var fn=function (){ //window下的预解释：var fn;
console.log("ok");
}；自执行函数定义的那个function在全局作用域下不进行预解释，当代码执行到这个位置的时候定义和执行一起完成了。常见有以下几种形式：
(function(num){})(10);
~function(num){}(10);
+function(num){}(10);
-function(num){}(10);
！function(num){}(10);function fn(){
//预解释：var num;
console.log(num);//->undefined
return function(){};
var num=100;
}我们先来看下两个简单的例子：
//例题1
function a() {}
var a
console.log(typeof a)//'function'//例题2
var c = 1
function c(c) {
console.log(c)
var c = 3
}
c(2)//Uncaught TypeError: c is not a function当遇到存在函数声明和变量声明都会被提升的情况，函数声明优先级比较高，最后变量声明会被函数声明所覆盖，但是可以重新赋值,所以上个例子可以等价为
function c(c) {
console.log(c)
var c = 3
}
c = 1
c(2)接下来我们看下两道比较复杂的题目:
//例题3
fn();
function fn(){console.log(1);};
fn();
var fn=10;
fn();
function fn(){console.log(2);};
fn();1.一开始预解释，函数声明和赋值一起来，fn 就是function fn(){console.log(1);}；遇到var fn=10;不会重新再声明，但是遇到function fn(){console.log(2);}就会从重新赋值，所以一开始fn()的值就是2
2.再执行fn();值不变还是2
3.fn重新赋值为10，所以运行fn()时报错，接下去的语句就没再执行。
//例题4
alert(a);
a();
var a=3;
function a(){
alert(10)
}
alert(a);
a=6;
a()1.函数声明优先于变量声明，预解释时候，函数声明和赋值一起来，a就是function a(){alert(10)} ，后面遇到var a=3，也无需再重复声明，所以先弹出function a(){alert(10)}
2.a()，执行函数，然后弹出10
3.接着执行了var a=3; 所以alert(a)就是显示3
4.由于a不是一个函数了，所以往下在执行到a()的时候， 报错。
Das obige ist der detaillierte Inhalt vonWas ist JavaScript-Vorinterpretation? JavaScript-Parsing vor der Interpretation (mit Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
