À propos de ce cours
Chapitre 3 — Les variables, les types et les opérateurs · var, let et const : portée des variables et mode strict
• 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.

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
| var | let | const | |
|---|---|---|---|
| Portée | fonction (ignore les blocs) | bloc | bloc |
| Réaffectation | oui | oui | non (TypeError) |
| Redéclaration dans la même portée | oui, en silence | non (SyntaxError) | non |
| Utilisation avant la déclaration | undefined | ReferenceError | ReferenceError |
| Usage aujourd'hui | code ancien uniquement | valeur qui change | par 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.
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.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.•
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) :
- Écrivez
let message = "global";puis un bloc{ let message = "bloc"; console.log(message); }suivi deconsole.log(message);. Prévoyez les deux affichages avant d'exécuter. Combien de variablesmessageexistent ? - Dans un bloc, déclarez
const reduction = 10;. Essayez de l'afficher après le bloc. Quel message obtenez-vous ? Remplacezconstparvar: que se passe-t-il ? Lequel des deux comportements est le plus sûr ? - Écrivez deux fois
var total = 0;puis deux foislet total = 0;. Quelle version signale le problème ? - À 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) :
- Écrivez
let compteur = 0;puiscompteur = compteur + 1;et, volontairement,compteurr = 5;. Affichezcompteur. Une erreur est-elle signalée ? - 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 ? - Pourquoi un programme de 500 lignes est-il plus facile à corriger en mode strict ?
- Votre page utilise
<script type="module" src="app.js">. Faut-il écrire"use strict";dansapp.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é ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !