Was ist JavaScript-Vorinterpretation? JavaScript-Parsing vor der Interpretation (mit Code)

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:

1. Was ist Vorinterpretation?

Vorinterpretation:Bevor JavaScript-Code ausgeführt wird, deklariert oder definiert der Browser standardmäßig alles im Voraus mit var und function

1. Deklarationen und Definitionen verstehen

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.

2. Für diejenigen mit var- und function-Schlüsselwörtern sind die Operationen während der Vorinterpretation unterschiedlich.

var => wird nur im Voraus während der Vorinterpretation

function = deklariert > Während der Vorinterpretation werden alle frühen Deklarationen und Definitionen vervollständigt

3. Die Vorinterpretation findet nur im aktuellen Umfang statt.

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

2

1 .Wie unterscheidet man zwischen privaten Variablen und globalen Variablen?

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);//3

Ein 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.

2. Funktionsparameterübergabe

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 私有的也修改不了外面的

3 Klassifizierung des Speichers in JS

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.

3. Der Unterschied zwischen var und ohne var im globalen Bereich

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);//0

In 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

if（!("num" in  window)){
var num=12；//这句话会被提到大括号之外的全局作用域：var num;->window.num； 
}
console.log(num);//undefined

2.预解释的时候只预解释”=”左边的，右边的值，不参与预解释

请看下面这道例题：

fn()；//报错
var fn=function (){  //window下的预解释：var fn;
console.log("ok");
}；

3.自执行函数：定义和执行一起完成了。

自执行函数定义的那个function在全局作用域下不进行预解释，当代码执行到这个位置的时候定义和执行一起完成了。常见有以下几种形式：

(function(num){})(10);
~function(num){}(10);
+function(num){}(10);
-function(num){}(10);
！function(num){}(10);

4.函数体中return下面的代码虽然不再执行了，但是需要进行预解释；return后面跟着的都是我们返回的值，所以不进行预解释；

function fn(){
//预解释：var num;
console.log(num);//->undefined
return function(){};
var num=100;
}

5.函数声明和变量声明都会被提升。但是一个值得注意的细节（这个细节可以出现在有多个“重复”声明的代码中）是函数会首先被提升，然后才是变量。在预解释的时候，如果名字已经声明过了，不需要从新的声明，但是需要重新的赋值；

我们先来看下两个简单的例子：

//例题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!