La différence entre let et const c'est qu'une fois que vous liez une valeur/un objet à une variable à l'aide de const, vous ne pouvez pas réattribuer à cette variable. Exemple:

const something = {};
something = 10; // Error.

let somethingElse = {};
somethingElse = 1000; // This is fine.

Notez que const ne rend pas quelque chose immuable.

const myArr = [];
myArr.push(10); // Works fine.

probablement la meilleure façon de rendre un objet (faiblement) immuable en ce moment est d'utiliser Object.freeze().

let

• utiliser la portée de bloc dans la programmation.
• pour chaque bloc laissez créer sa propre portée à laquelle vous ne pouvez pas accéder en dehors de ce bloc.
• valeur peut être modifiée autant de fois que vous le souhaitez.

• laissez est extrêmement utile d'avoir pour la grande majorité de code. Il peut grandement améliorer la lisibilité de votre code et diminuer les chances d'une programmation erreur.

  let abc = 0;
  
  if(true)
   abc = 5 //fine
  
  if(true){
    let def = 5
  }
  console.log(def)
  

const

• Il vous permet d'être immuable avec des variables.

• const est une bonne pratique pour à la fois la lisibilité et la maintenabilité et évite d'utiliser de la magie littéraux par exemple,

  // Low readability
  if (x > 10) {
  }
  
  //Better!
  const maxRows = 10;
  if (x > maxRows) {
   }
  

• les déclarations const doivent être initialisées

   const foo; // ERROR: const declarations must be initialized
  

• const est de bloquer l'étendue comme nous l'avons vu avec let:+

const foo = 123;
if (true) {
    const foo = 456; // Allowed as its a new variable limited to this `if` block
}

laisser et const

Variables déclarées avec let et const éliminer les problèmes spécifiques de levage parce qu'ils sont scopés au bloc, pas à la fonction.

si une variable est déclarée en utilisant let ou const à l'intérieur d'un bloc de code (indiqué par des accolades curly { }), alors la variable est coincée dans ce qu'on appelle la zone temporale morte jusqu'à ce que la déclaration de la variable soit traitée. Ce comportement empêche les variables de accès seulement jusqu'à ce qu'ils soient déclarés.

Règles pour l'utilisation du let et de const

let et const ont aussi d'autres propriétés intéressantes.

• Variables déclarées avec let peut être réaffectés, mais ne peut pas être redéclarée dans le même champ d'application.
• Variables déclarées avec const doit recevoir une valeur initiale, mais ne peut pas être redéclarée dans la même portée, et ne peut pas être réaffecter.

cas D'utilisation

la grande question Est de savoir quand utiliser let et const? La règle générale est la suivante:

• utiliser let lorsque vous prévoyez de réattribuer de nouvelles valeurs à une variable, et
• utiliser const quand vous n'avez pas l'intention de réassigner de nouvelles valeurs à un variable.

Depuis const est la façon la plus stricte de déclarer une variable, il est suggéré que vous toujours déclarer les variables avec const parce que cela rendra votre code plus facile à raisonner puisque vous savez que les identificateurs ne changeront pas tout au long de la vie de votre programme. Si vous trouvez que vous avez besoin de mettre à jour une variable ou la modifier, puis revenir en arrière et passer de constlet.

voici quelques notes que j'ai prises qui m'ont aidé sur ce sujet. Également de comparer les const et letvar.

Ici var:

// Var
// 1. var is hoisted to the top of the function, regardless of block
// 2. var can be defined as last line and will be hoisted to top of code block
// 3. for undefined var //output error is 'undefined' and code continues executing
// 4. trying to execute function with undefined variable
// Example: // log(myName); // output: ReferenceError: myName is not defined and code stops executing 

Ici let et const:

// Let and Const
// 1. use `const` to declare variables which won't change
// 2. `const` is used to initialize-once, read-only thereafter
// 3. use `let` to declare variables which will change
// 4. `let` or `const` are scoped to the "block", not the function
// 5. trying to change value of const and then console.logging result will give error
// const ANSWER = 42;
// ANSWER = 3.14159;
// console.log(ANSWER);
// Error statement will be "TypeError: Assignment to constant variable." and code will stop executing
// 6. `let` won't allow reference before definition
// function letTest2 () {
//   log(b);
//   let b = 3;}
// Error statement will be "ReferenceError: b is not defined." and code will stop executing

Résumé:

les Deux let et portée variables. Il y a cependant une grande différence:

• Variables déclarées avec let peut être réaffectés.
• Variables déclarées avec const doit être initialisé lorsqu'il est déclaré et ne peut pas être réaffecté.

si vous essayez de réassigner des variables avec les const mot clé, vous obtiendrez la suite erreur (chrome devtools):

Pourquoi utiliser ceci?

si nous savons que nous voulons attribuer une variable une fois et que nous ne voulons pas réattribuer la variable, en utilisant le

• nous communiquons dans notre code que nous ne voulons pas réattribuer la variable. De cette façon, si d'autres programmeurs regardent votre code (ou même vous à votre propre code vous avez écrit un vous savez que les variables qui sont déclarées avec const ne devrait pas être réaffecté. De cette façon, notre code devient plus déclaratif et plus facile à utiliser.
• nous imposons le principe de ne pas pouvoir réattribuer une variable (erreur de jet du moteur JS). De cette façon, si vous essayez accidentellement de réassigner une variable qui n'est pas destinée à être réassignée, vous pouvez le détecter à un stade plus précoce (parce qu'il est connecté à la console.)

Avertissement:

Bien qu'une variable déclarée avec const ne peut pas être réaffecté cela ne veut pas dire qu'un objet assigné n'est pas mutable. Par exemple:

const obj = {prop1: 1}

// we can still mutate the object assigned to the 
// variable declared with the const keyword
obj.prop1 = 10;
obj.prop2 = 2;

console.log(obj);

si vous voulez aussi que votre objet ne soit pas mutable, vous pouvez utiliser Object.freeze() afin d'atteindre cet objectif.