Zusammenfassung der grundlegenden JavaScript-Kenntnisse (8) Ausführungsprozess vor der Kompilierung

Dieses Mal bringe ich Ihnen eine Zusammenfassung der grundlegenden JavaScript-Kenntnisse. (8) Hier ist ein praktischer Fall Schauen Sie mal rein.

JS Running Trilogy

Schritt Eins: Syntaxanalyse

Teil Zwei: Vorkompilierung

Teil Drei: Interpretation und Ausführung

Vor- Kompilierung

Syntaxanalyse wird auch als semantische Analyse bezeichnet. Der Prozess wird im gesamten Artikel ausgeführt. Wenn diese Codes beispielsweise ausgeführt werden, werden sie zeilenweise interpretiert und ausgeführt Aber vor der Ausführung besteht der erste Schritt der Systemausführung darin, sie zu scannen, um zu sehen, ob es irgendwelche Grammatikfehler auf niedriger Ebene gibt, wie z. B. fehlende Klammern, das Hinzufügen chinesischer Zeichen usw. Es wird gescannt Der gesamte Text wird jedoch nicht ausgeführt. Nach dem Scannen des gesamten Textes wird er vorkompiliert und dann zeilenweise interpretiert

Auftakt zur Vorkompilierung

imply global 暗示全局变量: 即任何变量,如果变量未经声明就赋值,自变量就位全局对象所有
eg : a = 123;
eg : var a = b = 123;

Alle deklarierten globalen Variablen sind die Attribute des Fensters

  eg:var a = 123;===> window.a = 123;
//例子:
   function test (){        console.log("a");
   }  
   test();//成功打印出a,
   box();//写在方法之前也成功打印出a,为什么能执行就是有预编译的过程
   function box (){        console.log("a");
   }    
   var a =123;    console.log(a);//输出123
   console.log(a);//输出undefined,不报错;
    var a = 123;    
    //但是如果直接打印会报错;
    console.log(b)//报错
    //也是预编译的效果
    
    //如果想偷懒记住两句话
    //函数声明整体提升
    //变量 声明提升

Erläutern Sie das Thema Verbesserung der Funktionsdeklaration : Wenn Sie eine Funktionsdeklaration schreiben, unabhängig davon, wo Sie sie schreiben, wird das System dies immer tun Es bringt diese Funktion an den Anfang der Logik, sodass sie im Wesentlichen unabhängig davon ist, wo Sie sie aufrufen, ob sie oben oder unten aufgerufen wird Wird unterhalb der Funktion aufgerufen und die Funktionsdeklaration wird für Sie immer auf die Logikebene heraufgestuft. Die vordere

-Variablendeklaration wird beispielsweise heraufgestuft:

var a = 123;//In Tatsächlich besteht es aus zwei Teilen von var a;//Deklarieren Sie zuerst die Variable
a = 123;//In Variablenzuweisung

Die vom System geförderte Variable wird also nicht zusammen mit der gefördert Wert, also gibt a im Beispiel undefiniert aus;

Beachten Sie, dass diese beiden Sätze nicht allmächtig sind

Zum Beispiel

function a(a){    var a = 123;    var a = function(){        
    }
    a();
}var a = 123;

Dies kann durch diese beiden nicht gelöst werden Sätze

Bevor wir das Obige erklären, müssen wir zunächst verstehen, was impiy global ist

globa implizieren: impliziert globale Variablen: Das heißt, jede Variable, der ein Wert zugewiesen wird, ohne deklariert zu werden, Die unabhängige Variable befindet sich im globalen Objekt.

z. B. a = 123;

z. B.: var a = b = 123;

a = 10;console.log (a);//Drucken Sie 10 und haben Sie dann awindow.a//10var b = 20;//Sie haben window deklariert und auch bwindow ist die globale Domäne

Vorkompiliert und formalisiert

AO-Objekt erstellen

Suchen Sie nach formalen Parametern und Variablendeklarationen und verwenden Sie die Variablen- und formalen Parameternamen als AO-Attributnamen. Der Wert ist undefiniert.

Vereinheitlichen Sie den tatsächlichen Parameterwert und der formale Parameter

Suchen Sie nach der Funktionsdeklaration im Funktionskörper und weisen Sie den Wert dem Funktionskörper zu

function fn (a){    console.log(a);    
    var a = 123;    console.log(a);    
    function a (){};    console.log(a);    
    var b = function (){        
    }    console.log(b);        
}
fn(1);

In diesem Beispiel werden alle Parameter, Variablen und Funktionsnamen aufgerufen a. Erstens ist es sicher, dass ein Überschreibphänomen auftritt. Wie bereits erwähnt, wird die Vorkompilierung ausgeführt Nimmt diese Der Widerspruch wurde ausgeglichen.

Erste Vorkompilierung

Der erste Schritt: Erstellen Sie ein AO-Objekt. Der vollständige Name lautet Aktivierungsobjekt. Dies ist der Bereich, der auch als Ausführungskontext bezeichnet wird

AO{    
}

Schritt 2: Formale Parameter und Variablendeklarationen finden, Variablen- und formale Parameternamen als AO-Attributnamen verwenden, und der Wert ist undefiniert

AO{    a : undefined
    b : undefined
}

Schritt 3: Tatsächliche Parameter vereinheitlichen Werte und formale Parameter

AO{    a : 1;    b : undefined
}

Schritt 4: Suchen Sie die Funktionsdeklaration im Funktionskörper und weisen Sie den Wert dem Funktionskörper zu

AO{    a : 1,    b : undefined,    //b是是函数表达式,不是函数声明,所以不变
    //然后有a了 有b了,然后将这个函数声明的名作为AO对象挂起来
    d : 
}//然后值赋予函数体,也就是把a和b的属性值,变成函数体//覆盖掉a 和b的的属性值//也就变成下面的//因为第四步的优先级最高AO{    a : function a () {}
    b : undefined,    //b是是函数表达式,不是函数声明,所以不变
    d : function d () {}
}

An diesem Punkt wird der Vor - Der Kompilierungsprozess endet, die Codeausführung beginnt und die Funktion

Dann schauen wir uns das obige Beispiel an

//预编译结果AO{    a : function a () {}
    b : undefined,    d : function d () {}
}//开始执行代码function fn (a){    //第一步开始打印a
    //根据上面预编译的结果,
    //所以打印结果是function a () {}
    console.log(a);    
    //第二步执行 var a = 123;
    //因为在预编译的第二步里面,变量已经提升了
    //所以第二步只执行的赋值
    //a = 123;去AO对象里面去找a
    //也就变成
    //AO{
        //a : 123   这个才是a的存储值
        //b : undefined,
        //d : function d () {}
    //}
    var a = 123;    //所以打印出123
    console.log(a);    //因为这句在话在预编译的时候系统已经看了
    //所以不在看这句话
    function a (){};    //所以下面的console.log(a)
    //还是打印123;
    console.log(a);    //一样下面的var b这句话在预编译的时候已经看了,所以不在看
    //AO{
        //a : 123   
        //所以b的值变成function(){}
        //b : function(){}
        //d : function d () {}
    //}
    var b = function (){
        
    }    //所以打印出function(){}
    console.log(b);
        
}

fn(1);

Wir Ich schaue mir ein Beispiel an

function test(a , b){    console.log(a);
    c = 0;    var c;
    a = 3;
    b = 2;    console.log(b);    function b () {}    console.log(b);
}//这下我们就很快的得出打印的东西//a-->1//b-->2//b-->2

Vorkompilierung findet nicht nur im Funktionskörper statt, sondern auch im globalen

Der erste Schritt im globalen Bereich besteht darin, zuerst das GO Global Object zu generieren , die anderen sind gleich

GO === Fenster

dann Die Frage ist, ob zuerst GO oder zuerst AO ausgeführt werden soll

Die Antwort ist, zuerst GO auszuführen

Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website!

Verwandte Lektüre:

Zusammenfassung der grundlegenden JavaScript-Kenntnisse (6) Funktionen, anfänglicher Umfang (Teil 1)

Zusammenfassung der Grundlagen der JavaScript-Kenntnisse (6) Funktionen, anfänglicher Umfang (Teil 2)

Zusammenfassung der grundlegenden JavaScript-Kenntnisse (7) Rekursion

Das obige ist der detaillierte Inhalt vonZusammenfassung der grundlegenden JavaScript-Kenntnisse (8) Ausführungsprozess vor der Kompilierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!