Que signifie la promotion des variables javascript ?

En JavaScript, la promotion de variable signifie que dans la portée d'une variable, quel que soit l'endroit où la variable est déclarée, elle sera promue en haut de la portée, mais l'ordre d'initialisation de la variable reste inchangé. L'implémentation réelle du levage de variables est que les déclarations de variables et de fonctions JavaScript sont placées en mémoire pendant la phase de compilation.

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

Qu'est-ce que le boosting variable ?

Le levage variable (Hoisting) est la compréhension que les gens ont du fonctionnement du contexte d'exécution JavaScript, et ce n'est pas un changement officiel.

Au sens littéral, la promotion des variables signifie que la déclaration des variables et des fonctions sera déplacée au premier plan de la portée dans la couche physique. Bien que cette compréhension ne soit pas exacte, l'effet est le même.

En termes simples, la promotion d'une variable signifie que dans la portée d'une variable, quel que soit l'endroit où la variable est déclarée, elle sera promue en haut de la portée, mais l'ordre d'initialisation de la variable reste inchangé.

L'implémentation réelle de la promotion des variables est que la déclaration des variables et fonctions JavaScript sera placée en mémoire pendant la phase de compilation. Cela signifie que les utilisateurs peuvent utiliser une fonction ou une variable avant qu'elle ne soit formellement déclarée.

Pour comprendre la mise en œuvre de la promotion des variables, il faut d'abord clarifier les deux points suivants :

• le code javascript n'est pas exécuté ligne par ligne

• l'exécution de javascript est divisée en 2 étapes :

  • Compilation (. Interprétation lexicale/pré-interprétation)

  • Exécution

La promotion variable aide à comprendre

console.log(a);
var a = 'ghostwu';

Pour l'exemple de code ci-dessus, la première ligne de code, vous pouvez penser qu'une erreur est signalée, car avant a est affiché, la variable a n'est pas définie, mais le résultat correct n'est pas défini. Selon l'explication ci-dessus du code d'exécution de js, combinée avec le code réel, lorsque nous rencontrons var a = "ghostwu" pour définir une variable, js considère en fait cette phrase comme deux étapes, var a se produit dans l'étape de compilation, a = 'ghostwu' apparaît dans la phase d'exécution. Ensuite, var a sera promu au premier plan de la portée actuelle, a = 'ghostwu' reste en place en attendant la phase d'exécution, alors regardez le cas suivant :

 a = 'ghostwu';
 var a;
 console.log( a );
 
 //上面这段代码经过编译之后，变成下面这样

 var a;  //被提升到当前作用域的最前面
 a = 'ghostwu'; //留在原地，等待执行
 console.log( a ); //输出ghostwu
 
 
 
  console.log( a ); 
   var a = 'ghostwu';

   //上面这段代码,经过编译之后，变成下面这样
   
   var a;
  console.log( a );//输出undefined,而不会报错
   a = 'ghostwu';

Fonction. déclaration Promotion

Avant d'expliquer la promotion de la déclaration de fonction, comprenons d'abord les deux manières courantes de définir les fonctions

         //函数声明, 形如:
         function show(){
             console.log( '函数声明方式' );
         }
 
         //函数表达式, 形如:
         var show = function(){
             console.log( '表达式方式' );
         }

Parce que les expressions de fonction et les déclarations de fonction produiront des effets d'interprétation différents pendant la phase de compilation, donc les fonctions L'instruction sera promue. Pour un exemple, voir le code suivant :

         show();
         function show(){
             console.log( a );
             var a = 'ghostwu';
         }


//函数声明会被提升，所以上面的代码经过编译之后，就变成下面这样

    function show(){    //函数声明被提升到 当前作用域的最前面
    var a;    
     //var声明被提升到当前作用域的最前面, 注意，他不会提升到函数的外面, 因为当前的作用域是在函数中
    console.log( a );
    a = 'ghostwu';
   }
   show();//输出undefined

Mais l'expression de fonction ne sera pas promue. Voir l'exemple suivant :

show(); //报错,show is not a function
var show = function(){
 console.log( 'ghostwu' );
}
//对于上面这段表达式代码，经过编译之后:
var show;
show();  //执行之后就是 undefined(), 所以在表达式定义之前，调用函数报错了
show = function(){
  console.log( 'ghostwu' );  
}

Mais voir le cas suivant :

show(); //你好
var show;
function show(){
console.log( '你好' );
}
show = function(){
   console.log( 'hello' );
}

Pourquoi le code ci-dessus génère-t-il "Bonjour" », car lorsqu'une déclaration de fonction ou une déclaration de variable portant le même nom apparaît, la déclaration de fonction sera promue en premier et la déclaration de variable sera ignorée. Ainsi après compilation, cela devient :

function show(){
   console.log( '你好' );
}
show(); //你好
show = function(){
  console.log( 'hello' );
}
show();//如果这里在调用一次，就是hello, 因为show函数体在执行阶段被重新赋值了

Mais s'il existe une déclaration de fonction du même nom, cette dernière écrasera la précédente, comme indiqué dans le code suivant :

show(); //how are you
var show;
function show(){
console.log( 'hello' );
}    
show = function(){
console.log( '你好' );
}
function show(){
console.log( 'how are you!' );
}  

//上面的代码经过编译之后，变成如下形式:
function show(){
   console.log( 'how are you!' );
}
show(); //how are you
show = function(){
 console.log( '你好' );
}
show(); //如果在这里再执行一次，结果：你好

Note :

• La promotion de variable améliore uniquement la déclaration de la variable. Elle n'augmentera pas la valeur d'affectation.

• Parce qu'il existe une promotion de variable, afin d'éviter les effets néfastes causés par la promotion de variable, nous ferions mieux d'utiliser let au lieu de var lors de la définition des variables.

【Recommandations associées : Tutoriel d'apprentissage Javascript】

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!