Résumé des connaissances de base de JavaScript (8) Processus d'exécution de pré-compilation

Cette fois, je vais vous apporter un résumé des connaissances de base en JavaScript Il y a un total de onze points de connaissances Résumé des connaissances de base en JavaScript (8) Voici un cas pratique. jetez un oeil.

JS Running Trilogy

Première étape : Analyse syntaxique

Deuxième partie : Précompilation

Troisième partie : Interprétation et exécution

Pré- compilation

L'analyse syntaxique est également appelée analyse sémantique. L'analyse syntaxique est un processus qui est exécuté tout au long de l'article. Par exemple, j'ai écrit de nombreuses lignes de code. Lorsque ces codes sont exécutés, ils sont interprétés et exécutés ligne par ligne. Mais avant l'exécution, la première étape de l'exécution du système sera de l'analyser pour voir s'il y a des erreurs de grammaire de bas niveau, telles que des crochets manquants, l'ajout de caractères chinois, etc. le texte entier, mais il n'est pas exécuté. Ce processus d'analyse du texte entier est appelé analyse syntaxique. Après l'analyse du texte entier, il sera pré-compilé, puis exécuté ligne par ligne après interprétation, c'est-à-dire interprétation et exécution.

Prélude de pré-compilation

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

Toutes les variables globales déclarées sont les attributs de window

  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)//报错
    //也是预编译的效果
    
    //如果想偷懒记住两句话
    //函数声明整体提升
    //变量 声明提升

Expliquez le sujet d'amélioration de la déclaration de fonction : Si vous écrivez une déclaration de fonction, peu importe où vous l'écrivez, le système le fera toujours. Il amènera cette fonction au premier plan de la logique, donc peu importe où vous l'appelez, qu'elle soit appelée au-dessus ou en dessous, c'est essentiellement appelée sous la fonction, et elle promouvra toujours la déclaration de fonction au niveau logique pour vous. La déclaration de variable avant

est promue, par exemple,

var a = 123;//In. en fait, il s'agit de deux parties de var a;//Déclarez d'abord la variable
a = 123;//Dans Affectation de variable

Ainsi, la variable promue par le système n'est pas promue avec le valeur, donc dans l'exemple a imprime undefined ;

Notez que ces deux phrases ne sont pas omnipotentes

Par exemple

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

Cela ne peut pas être résolu par ces deux-là. phrases

Avant d'expliquer ce qui précède, nous devons d'abord comprendre ce qu'est impiy global

imply globa : implique des variables globales : c'est-à-dire n'importe quelle variable Si la variable reçoit une valeur sans être déclarée, la variable indépendante sera dans l'objet global.

ex: a = 123;

ex: var a = b = 123;

a = 10;console.log (a);//Imprimez 10 puis ayez awindow.a//10var b = 20;//Vous avez déclaré window et l'avez également bwindow est le domaine global

Pré-compilé et formalisé

Créez un objet AO

Recherchez les paramètres formels et les déclarations de variables, et utilisez les noms de variables et de paramètres formels comme noms d'attributs AO La valeur n'est pas définie

Unifiez la valeur réelle du paramètre. et le paramètre formel

Recherchez la déclaration de fonction dans le corps de la fonction et attribuez la valeur au corps de la fonction

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

Cet exemple, les paramètres, les variables, les noms de fonctions sont tous appelés a.Tout d'abord, il est certain qu'un phénomène d'écrasement va certainement se produire. C'est très contradictoire. Comme mentionné précédemment, la pré-compilation de la fonction est exécutée juste avant l'exécution de la fonction. prend ces La contradiction a été réconciliée.

Première pré-compilation

La première étape : Créer un objet AO, le nom complet est Objet d'activation, qui est la portée, également appelée contexte d'exécution

AO{    
}

Étape 2 : Recherchez les paramètres formels et les déclarations de variables, utilisez les noms de variables et de paramètres formels comme noms d'attributs AO, et la valeur n'est pas définie

AO{    a : undefined
    b : undefined
}

Étape 3 : Unifiez le paramètre réel valeurs et paramètres formels

AO{    a : 1;    b : undefined
}

Étape 4 : Recherchez la déclaration de fonction dans le corps de la fonction et attribuez la valeur au corps de la fonction

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

À ce stade, le pré -le processus de compilation se termine, l'exécution du code commence et la fonction

Ensuite, nous regardons l'exemple ci-dessus

//预编译结果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);

Nous regardons un exemple

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

La précompilation n'est pas seulement dans le corps de la fonction, elle se produira également dans le global

La première étape du global consiste à générer l'objet global GO, les autres sont les mêmes

GO === fenêtre

alors La question est de savoir s'il faut exécuter GO en premier ou AO en premier

La réponse est d'exécuter GO en premier

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le site Web chinois de php !

Lecture connexe :

Résumé des connaissances de base de JavaScript (6) Fonctions, portée initiale (Partie 1)

Bases Résumé des connaissances JavaScript (6) Fonctions, portée initiale (Partie 2)

Résumé des connaissances de base en JavaScript (7) Récursion

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!