Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
JavaScript

var, let et const : portée des variables et mode strict

var, let et const : portée des variables et mode strict. Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre la notion de portée (globale, de fonction, de bloc) ; connaître les différ...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

var, let et const : portée des variables et mode strict. Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre la notion de portée (globale, de fonction, de bloc) ; connaître les différences entre var, let et const ; éviter les pièges de var (fuite hors du bloc, redéclaration, boucles) ; activer et comprendre le mode strict.

Chapitre 3 — Les variables, les types et les opérateurs · var, let et const : portée des variables et mode strict

🎯 Objectifs de la leçon
• comprendre la notion de portée (globale, de fonction, de bloc) ;
• connaître les différences entre var, let et const;
• éviter les pièges de var (fuite hors du bloc, redéclaration, boucles) ;
• activer et comprendre le mode strict.

1. La portée d'une variable

La portée (scope) d'une variable est la zone du code où elle est visible. Une variable déclarée avec let ou const n'existe que dans le bloc { … } où elle est déclarée, et dans les blocs qu'il contient. Une variable déclarée hors de tout bloc et de toute fonction est globale: visible partout, donc risquée.

Portées imbriquées
Figure 1 — Les portées s'emboîtent : on voit les variables des portées englobantes, jamais celles des portées intérieures.

Pour afficher plusieurs cas d'un coup, cet exemple utilise une boucle for (chapitre 7) : concentrez-vous sur les résultats affichés.

// 1. let et const : portée de BLOC
let niveau = "global";
if (true) {
  let niveau = "bloc";             // une AUTRE variable, qui masque la première
  const secret = 42;
  console.log("dans le bloc :", niveau, secret);
}
console.log("hors du bloc :", niveau);
try { console.log(secret); } catch (e) { console.log("secret hors du bloc →", e.name); }

// 2. var : portée de FONCTION, le bloc ne l'arrête pas
if (true) {
  var fuite = "je sors du bloc";
}
console.log("var fuite :", fuite);

function f() {
  var locale = "dans f";
}
f();
try { console.log(locale); } catch (e) { console.log("var locale hors de f →", e.name); }

// 3. var accepte la redéclaration, let non
var compteur = 1;
var compteur = 2;                  // aucune erreur : risque d'écraser une variable
console.log("var redéclarée :", compteur);
try { eval("let total = 1; let total = 2;"); } catch (e) { console.log("let redéclarée →", e.name); }

// 4. Le piège classique de var dans une boucle
const avecVar = [], avecLet = [];
for (var i = 0; i < 3; i++) avecVar.push(() => i);
for (let j = 0; j < 3; j++) avecLet.push(() => j);
console.log("var :", avecVar.map((fn) => fn()), "| let :", avecLet.map((fn) => fn()));

Résultat dans la console

dans le bloc : bloc 42
hors du bloc : global
secret hors du bloc → ReferenceError
var fuite : je sors du bloc
var locale hors de f → ReferenceError
var redéclarée : 2
let redéclarée → SyntaxError
var : [ 3, 3, 3 ] | let : [ 0, 1, 2 ]

2. var, let et const

varletconst
Portéefonction (ignore les blocs)blocbloc
Réaffectationouiouinon (TypeError)
Redéclaration dans la même portéeoui, en silencenon (SyntaxError)non
Utilisation avant la déclarationundefinedReferenceErrorReferenceError
Usage aujourd'huicode ancien uniquementvaleur qui changepar défaut

var date des débuts du langage. Sa portée de fonction laisse « fuir » une variable hors d'un if ou d'une boucle, et dans l'exemple de la boucle, les trois fonctions partagent le même i, qui vaut 3 à la fin. Avec let, chaque tour de boucle a son propre j. Vous rencontrerez var dans du code ancien ou des tutoriels ; n'en écrivez plus.

3. Le mode strict

Sans précaution, une faute de frappe dans un nom de variable crée une variable globale au lieu de provoquer une erreur :

// Sans "use strict" : la faute de frappe crée une variable globale en silence
let total = 0;
totl = 10;                           // aucune erreur !
console.log("total =", total, "| totl =", totl, "| globalThis.totl =", globalThis.totl);

Résultat dans la console

total = 0 | totl = 10 | globalThis.totl = 10

La directive "use strict";, placée en première ligne d'un fichier (ou d'une fonction), active le mode strict: plusieurs erreurs silencieuses deviennent de vraies erreurs.

"use strict";   // première instruction du fichier : tout le fichier passe en mode strict

// 1. Affecter une variable jamais déclarée
try {
  totl = 10;                       // faute de frappe : total → totl
} catch (e) {
  console.log("totl = 10 →", e.name + " : " + e.message);
}

// 2. Supprimer une variable
try {
  eval("let x = 1; delete x;");
} catch (e) {
  console.log("delete x →", e.name);
}

// 3. Paramètres en double dans une fonction
try {
  eval("function moyenne(a, a) { return a; }");
} catch (e) {
  console.log("function moyenne(a, a) →", e.name);
}

// 4. Mots réservés pour l'avenir
try {
  eval("let interface = 1;");
} catch (e) {
  console.log("let interface →", e.name);
}

console.log("Le reste du programme continue normalement.");

Résultat dans la console

totl = 10 → ReferenceError : totl is not defined
delete x → SyntaxError
function moyenne(a, a) → SyntaxError
let interface → SyntaxError
Le reste du programme continue normalement.
ℹ️ Bon à savoir
Les modules (<script type="module">, fichiers import/export) et les classes sont toujours en mode strict : la directive y est inutile. Dans un script classique, ajoutez-la systématiquement.
✅ Correction par rapport à l'ancienne version
Nouvelle leçon : schéma des portées imbriquées, tableau comparatif var/let/const, exemples exécutés (fuite de var, redéclaration, piège de la boucle), démonstration du mode strict avec et sans la directive ; deux activités.
ℹ️ À retenir
• let et const: portée de bloc ; var: portée de fonction, à éviter.
• Une variable est visible dans son bloc et les blocs intérieurs, pas à l'extérieur.
• var accepte la redéclaration et fuit hors des blocs.
• "use strict"; en première ligne transforme les fautes silencieuses en erreurs.

🛠 Activité 5 — Qui voit quoi ?

Mission : Prédisez, puis vérifiez dans la console.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Écrivez let message = "global"; puis un bloc { let message = "bloc"; console.log(message); } suivi de console.log(message);. Prévoyez les deux affichages avant d'exécuter. Combien de variables message existent ?
  2. Dans un bloc, déclarez const reduction = 10;. Essayez de l'afficher après le bloc. Quel message obtenez-vous ? Remplacez const par var: que se passe-t-il ? Lequel des deux comportements est le plus sûr ?
  3. Écrivez deux fois var total = 0; puis deux fois let total = 0;. Quelle version signale le problème ?
  4. À l'aide du tableau, expliquez à un camarade pourquoi on n'utilise plus var, en trois phrases.

Je vérifie / je rends :

  • ☐ Vos prédictions, les résultats réels, et l'explication de la question 4.

🛠 Activité 6 — Le mode strict à l'épreuve

Mission : Comparez un même programme avec et sans mode strict.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Écrivez let compteur = 0; puis compteur = compteur + 1; et, volontairement, compteurr = 5;. Affichez compteur. Une erreur est-elle signalée ?
  2. Ajoutez "use strict"; en première ligne et relancez. Quel message obtenez-vous ? Que se passe-t-il si vous placez la directive en troisième ligne ?
  3. Pourquoi un programme de 500 lignes est-il plus facile à corriger en mode strict ?
  4. Votre page utilise <script type="module" src="app.js">. Faut-il écrire "use strict"; dans app.js? Pourquoi ?

Je vérifie / je rends :

  • ☐ Les deux exécutions (avec et sans directive) et les réponses.

← Les variables en JavaScriptLe hoisting (remontée des déclarations) →

Cet article vous a-t-il aidé ?