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

Variables globales et variables locales

Variables globales et variables locales. Dans cette leçon du cours JavaScript, vous apprendrez à : distinguer les portées globale, de fonction et de bloc ; prévoir quelle variable est visible à un end...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Variables globales et variables locales. Dans cette leçon du cours JavaScript, vous apprendrez à : distinguer les portées globale, de fonction et de bloc ; prévoir quelle variable est visible à un endroit donné ; comprendre le masquage et la chaîne des portées ; limiter les variables globales et écrire des fonctions « pures ».

Chapitre 10 — Les fonctions en JavaScript · Variables globales et variables locales

🎯 Objectifs de la leçon
• distinguer les portées globale, de fonction et de bloc ;
• prévoir quelle variable est visible à un endroit donné ;
• comprendre le masquage et la chaîne des portées ;
• limiter les variables globales et écrire des fonctions « pures ».

1. Trois niveaux de portée

La portée d'une variable est la partie du code où elle existe. Une variable déclarée en dehors de toute fonction est globale: visible partout. Une variable déclarée dans une fonction (y compris ses paramètres) est locale à cette fonction. Avec let et const, une variable déclarée dans un bloc { … } (if, for…) n'existe que dans ce bloc.

Les portées imbriquées
Figure 1 — Le code voit les variables de sa portée et des portées qui l'entourent, jamais celles des portées intérieures.

2. Exemples

"use strict";
// Portée globale : visible partout dans le fichier
const ecole = "ISTA";
let compteurGlobal = 0;

function inscrire(nom) {
  // Portée de la fonction : visible seulement ici
  const message = `${nom} inscrit à l'${ecole}`;
  compteurGlobal++;                 // modifie une variable globale (effet de bord)
  return message;
}
console.log(inscrire("Amina"), "| compteurGlobal =", compteurGlobal);
try { console.log(message); } catch (e) { console.log("message hors de la fonction →", e.name); }

// Portée de bloc : let et const n'existent que dans leurs accolades
for (let i = 0; i < 2; i++) {
  const carre = i * i;
}
try { console.log(carre); } catch (e) { console.log("carre hors du bloc →", e.name); }

// var ignore les blocs (mais pas les fonctions)
if (true) { var ancien = "visible après le if"; }
console.log("var dans un if :", ancien);

// Masquage : une variable locale du même nom cache la globale
const niveau = "global";
function afficherNiveau() {
  const niveau = "local";
  return niveau;
}
console.log("afficherNiveau() =", afficherNiveau(), "| niveau =", niveau);

// La chaîne des portées : une fonction voit les variables des blocs qui l'entourent
function exterieur() {
  const a = 1;
  function interieur() {
    const b = 2;
    return a + b + compteurGlobal;      // a vient de exterieur, compteurGlobal du global
  }
  return interieur();
}
console.log("exterieur() =", exterieur());

// Mode strict : oublier let/const provoque une erreur au lieu de créer une globale
try { oubli = 5; } catch (e) { console.log("affectation sans déclaration →", e.name); }

// Une fonction « pure » n'utilise que ses paramètres et ne modifie rien autour d'elle
const ajouterTVA = (prixHT, taux = 0.2) => prixHT * (1 + taux);
console.log("ajouterTVA(100) =", ajouterTVA(100), "| toujours le même résultat :", ajouterTVA(100) === ajouterTVA(100));

Résultat dans la console

Amina inscrit à l'ISTA | compteurGlobal = 1
message hors de la fonction → ReferenceError
carre hors du bloc → ReferenceError
var dans un if : visible après le if
afficherNiveau() = local | niveau = global
exterieur() = 4
affectation sans déclaration → ReferenceError
ajouterTVA(100) = 120 | toujours le même résultat : true
  • En dehors de la fonction, message n'existe pas : ReferenceError. Même chose pour carre en dehors de la boucle.
  • var ignore les blocs : la variable déclarée dans le if reste visible après. C'est une source d'erreurs, et une raison de ne plus utiliser var.
  • Masquage: une variable locale qui porte le même nom qu'une globale la cache à l'intérieur de la fonction, sans la modifier.
  • Chaîne des portées: interieur voit ses propres variables, celles de exterieur, puis les globales.
  • Le mode strict ("use strict", actif d'office dans les modules et les classes) transforme une affectation sans déclaration en erreur, au lieu de créer silencieusement une variable globale.

3. Pourquoi éviter les variables globales ?

Une variable globale peut être modifiée par n'importe quelle fonction, ou écrasée par un autre script de la page qui utilise le même nom. Quand un bug apparaît, il faut alors chercher dans tout le programme. Préférez des fonctions qui reçoivent ce dont elles ont besoin en paramètres et renvoient leur résultat : on les appelle des fonctions pures. Elles donnent toujours le même résultat pour les mêmes arguments et sont faciles à tester (c'est le principe du TP 10).

ℹ️ À retenir
• Globale : partout ; locale : dans la fonction ; let/const: dans le bloc.
• On voit vers l'extérieur, jamais vers l'intérieur ; un même nom à l'intérieur masque celui de l'extérieur.
• var ignore les blocs : utilisez let et const, et le mode strict.
• Le moins de globales possible : paramètres en entrée, return en sortie.

🛠 Activité 2 — Le jeu des portées

Mission : Pour chaque petit programme que vous écrirez, prédisez le résultat avant de l'exécuter, puis vérifiez.

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

  1. Déclarez let total = 0 en global et une fonction ajouter(n) qui fait total += n. Appelez-la trois fois. Réécrivez-la en fonction pure ajouter(total, n) qui renvoie le nouveau total. Quels avantages voyez-vous ?
  2. Dans une fonction, déclarez une variable let total = 100 du même nom que la globale. Que vaut le total global après l'appel ? Comment s'appelle ce phénomène ?
  3. Écrivez une boucle for (var i = 0; i < 3; i++) puis affichez i après la boucle. Recommencez avec let. Expliquez la différence.
  4. Dans une fonction, écrivez resultat = 42 sans let. Affichez resultat en dehors de la fonction. Ajoutez "use strict"; en tête du fichier : que se passe-t-il ?
  5. Imbriquez trois fonctions (niveau1 contient niveau2, qui contient niveau3), chacune avec sa variable. Quelles variables peut afficher niveau3? Et niveau1?
  6. Dans la console d'une page, tapez var name = 5; puis typeof name. Pourquoi le résultat n'est-il pas "number"? (indice : window.name, leçon 11.5)

Je vérifie / je rends :

  • ☐ Vos prédictions comparées aux résultats, avec une phrase d'explication pour chacune.

← Les fonctions en JavaScriptLes arguments et les fonctions anonymes →

Cet article vous a-t-il aidé ?