ES2015 (ES6) a ajouté deux mots-clés JavaScript importants :letetconst。

Les variables déclarées avec let ne sont valides que dans le bloc de code où se trouve l'instruction let.

const déclare une constante en lecture seule. Une fois déclarée, la valeur de la constante ne peut pas être modifiée.


commande let

Utilisation de base :

{ let a = 0; a // 0 } a //Error: ReferenceError: a is not defined

Valide dans le bloc de code

let est valide dans un bloc de code, tandis que var est valide dans la portée globale :

{ let a = 0; var b = 1; } a // ReferenceError: a n'est pas défini b // 1

Ne peut pas être redéclaré

let ne peut être déclaré qu'une seule fois, var peut être déclaré plusieurs fois :

let a = 1; let a = 2; var b = 3; var b = 4; a // L'identifiant 'a' a déjà été déclaré b // 4

les compteurs de boucle for sont bien adaptés à let

for (var i = 0; i < 10; i++) { setTimeout(function(){ console.log(i); }) } //Affiche dix fois 10 for (let j = 0; j < 10; j++) { setTimeout(function(){ console.log(j); }) } //Affiche 0123456789

La variable i est déclarée avec var, elle est donc valide dans la portée globale. Ainsi, il n'y a qu'une seule variable i dans la portée globale. À chaque fois que la boucle s'exécute, le i à l'intérieur du minuteur setTimeout fait référence à la variable globale i, et les dix appels à setTimeout dans la boucle ne sont exécutés qu'après la fin de la boucle, donc à ce moment-là, i vaut 10 dans chacun d'eux.

La variable j est déclarée avec let, donc le j courant n'est valide que dans l'itération actuelle de la boucle. À chaque itération, j est en fait une nouvelle variable, donc le j à l'intérieur du minuteur setTimeout est en fait une variable différente, par conséquent la sortie finale est 12345. (Si la variable j est redéclarée à chaque itération, comment connaît-elle la valeur de l'itération précédente ? C'est parce que le moteur JavaScript se souvient en interne de la valeur de l'itération précédente.)

Pas de hoisting de variable

let ne bénéficie pas du hissage des variables, contrairement à var :

console.log(a); //ReferenceError: a is not defined let a = "apple"; console.log(b); //undefined var b = "banane";

La variable b est déclarée avec var et bénéficie du hissage des variables, donc lorsque le script commence à s'exécuter, b existe déjà mais aucune valeur ne lui a été attribuée, c'est pourquoi elle affiche undefined.

La variable a est déclarée avec let et ne bénéficie pas du hissage des variables. Avant la déclaration de la variable a, a n'existe pas, donc une erreur est levée.


commande const

const déclare une variable en lecture seule. Après la déclaration, elle ne peut pas être modifiée. Cela signifie qu'une fois déclarée, elle doit être initialisée, sinon une erreur sera signalée.

Utilisation de base :

const PI = "3.1415926";
PI  // 3.1415926

const MY_AGE;  // SyntaxError: Missing initializer in const declaration

Zone morte temporelle :

var PI = "a";
if(true){
  console.log(PI);  // Impossible d'accéder à 'PI' avant son initialisation
  const PI = "3.1415926";
}

ES6 stipule clairement que si let ou const existe dans un bloc de code, ce bloc de code formera une portée fermée pour les variables déclarées par ces commandes depuis le début du bloc. À l'intérieur du bloc de code, utiliser la variable PI avant sa déclaration provoquera une erreur.

Points à noter

Comment const empêche-t-il qu'une variable soit modifiée après sa déclaration et son initialisation ? En fait, ce que const garantit n'est pas que la valeur de la variable reste inchangée, mais que les données stockées à l'adresse mémoire vers laquelle pointe la variable ne peuvent pas être modifiées. À ce stade, vous avez peut-être pensé que les types simples et les types composites stockent les valeurs de manières différentes. Oui, pour les types simples (number, string, boolean), la valeur est stockée directement à l'adresse mémoire vers laquelle pointe la variable ; une variable de type simple déclarée avec const équivaut donc à une constante. Pour les types complexes (object, array, function), l'adresse mémoire vers laquelle pointe la variable stocke en réalité un pointeur vers les données réelles. Par conséquent, const peut seulement garantir que le pointeur est fixe, mais que la structure de données vers laquelle pointe le pointeur change ou non échappe à tout contrôle. Par conséquent, vous devez être prudent lorsque vous utilisez const pour déclarer des objets de type complexe.


Articles de référence