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

Les closures (fermetures)

Les closures (fermetures). Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre ce qu'est une closure (fermeture) ; créer des données privées et des compteurs indépendants ; écrire des...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Les closures (fermetures). Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre ce qu'est une closure (fermeture) ; créer des données privées et des compteurs indépendants ; écrire des fabriques de fonctions ; expliquer le piège des boucles avec var.

Chapitre 10 — Les fonctions en JavaScript · Les closures (fermetures)

🎯 Objectifs de la leçon
• comprendre ce qu'est une closure (fermeture) ;
• créer des données privées et des compteurs indépendants ;
• écrire des fabriques de fonctions ;
• expliquer le piège des boucles avec var.

1. Une fonction qui se souvient

Quand une fonction est créée à l'intérieur d'une autre, elle garde un lien vers les variables de la fonction qui l'entoure, même après que celle-ci a fini de s'exécuter. Cette association d'une fonction et de son environnement s'appelle une closure (fermeture). C'est une conséquence directe de la chaîne des portées (leçon 10.2).

Une closure garde son environnement
Figure 1 — Chaque compteur emporte sa propre variable valeur.

2. Exemples

// 1. Une closure : une fonction qui se souvient des variables de l'endroit où elle a été créée
function creerCompteur() {
  let valeur = 0;                 // variable privée, conservée entre les appels
  return () => ++valeur;
}
const compteurA = creerCompteur();
const compteurB = creerCompteur();
console.log("A :", compteurA(), compteurA(), compteurA(), "| B :", compteurB());

// 2. Une fabrique de fonctions
function multiplicateur(facteur) {
  return (x) => x * facteur;
}
const doubler = multiplicateur(2);
const tripler = multiplicateur(3);
console.log("doubler(5) =", doubler(5), "| tripler(5) =", tripler(5));

// 3. Des données privées : un petit « module »
function creerCompte(soldeInitial) {
  let solde = soldeInitial;
  const historique = [];
  return {
    deposer(montant) { solde += montant; historique.push(`+${montant}`); return solde; },
    retirer(montant) {
      if (montant > solde) return "solde insuffisant";
      solde -= montant; historique.push(`-${montant}`); return solde;
    },
    consulter: () => ({ solde, operations: historique.join(" ") }),
  };
}
const compte = creerCompte(100);
compte.deposer(50);
console.log("retirer(500) →", compte.retirer(500), "| retirer(30) →", compte.retirer(30));
console.log("consulter() =", compte.consulter(), "| compte.solde =", compte.solde);

// 4. Le piège classique des boucles : var contre let
const avecVar = [];
for (var i = 0; i < 3; i++) avecVar.push(() => i);
const avecLet = [];
for (let j = 0; j < 3; j++) avecLet.push(() => j);
console.log("var :", avecVar.map((f) => f()), "| let :", avecLet.map((f) => f()));

// 5. Mémoriser des résultats (mémoïsation)
function memoriser(f) {
  const cache = new Map();
  return (n) => {
    if (!cache.has(n)) cache.set(n, f(n));
    return cache.get(n);
  };
}
let appels = 0;
const lent = (n) => { appels++; return n * n; };
const rapide = memoriser(lent);
rapide(12); rapide(12); rapide(12);
console.log("3 appels de rapide(12) → la fonction lente n'a travaillé que", appels, "fois");

// 6. Une fonction à usage unique
function uneSeuleFois(f) {
  let fait = false;
  return (...args) => { if (!fait) { fait = true; return f(...args); } };
}
const envoyer = uneSeuleFois((x) => `envoyé : ${x}`);
console.log(envoyer("formulaire"), "|", envoyer("formulaire"));

Résultat dans la console

A : 1 2 3 | B : 1
doubler(5) = 10 | tripler(5) = 15
retirer(500) → solde insuffisant | retirer(30) → 120
consulter() = { solde: 120, operations: '+50 -30' } | compte.solde = undefined
var : [ 3, 3, 3 ] | let : [ 0, 1, 2 ]
3 appels de rapide(12) → la fonction lente n'a travaillé que 1 fois
envoyé : formulaire | undefined
  • Compteurs: chaque appel de creerCompteur() crée une nouvelle variable valeur; compteurA et compteurB sont indépendants.
  • Fabrique: multiplicateur(2) renvoie une fonction qui se souvient de facteur = 2.
  • Données privées: solde n'est accessible qu'à travers les méthodes renvoyées ; compte.solde vaut undefined, personne ne peut le modifier directement. Les classes offrent aujourd'hui les champs privés #solde (leçon 16.4).
  • Le piège des boucles: avec var, il n'existe qu'une variable i, partagée par les trois fonctions, qui vaut 3 à la fin. Avec let, chaque tour de boucle a sa propre variable : chaque fonction se souvient de la sienne.
  • Mémoïsation et usage unique: la closure conserve un cache ou un indicateur entre les appels.
ℹ️ À retenir
Vous utilisez des closures sans le savoir : un écouteur d'événement qui utilise une variable déclarée plus haut, un setTimeout qui affiche une valeur calculée avant… La variable conservée est la variable elle-même, pas une copie de sa valeur : si elle change ensuite, la fonction verra la nouvelle valeur.
ℹ️ À retenir
• Une closure = une fonction + les variables de l'endroit où elle a été créée.
• Chaque appel de la fonction extérieure crée un nouvel environnement indépendant.
• Usages : compteurs, données privées, fabriques, mémoïsation, fonctions à usage unique.
• Dans une boucle, let crée une variable par tour ; var une seule pour toute la boucle.

🛠 Activité 8 — Le distributeur de tickets

Mission : Une administration a plusieurs guichets ; chaque guichet distribue des tickets numérotés dans sa propre série (A-001, A-002… et B-001…).

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

  1. Écrivez creerGuichet(lettre) qui renvoie une fonction suivant() renvoyant le prochain ticket. Où est stocké le numéro courant ? Pourquoi deux guichets ne se mélangent-ils pas ?
  2. Faites en sorte que creerGuichet renvoie un objet avec trois méthodes : suivant(), enAttente() (nombre de tickets distribués) et reinitialiser(). Peut-on modifier le compteur depuis l'extérieur ?
  3. Ajoutez une limite : au-delà de 50 tickets, suivant() renvoie « Guichet complet ». Où placez-vous cette limite pour qu'elle soit différente pour chaque guichet ?
  4. Créez trois boutons « Guichet A/B/C » avec une boucle for (var i …) qui attache à chacun un écouteur affichant le numéro du guichet. Que constatez-vous ? Corrigez de deux façons différentes.
  5. Écrivez uneSeuleFois(f) et utilisez-la pour qu'un bouton « Ouvrir la session » ne fonctionne qu'une fois. Quelle variable la closure conserve-t-elle ?
  6. Expliquez avec vos mots, à l'aide de votre code, pourquoi la variable du compteur n'est pas détruite quand creerGuichet a fini de s'exécuter.

Je vérifie / je rends :

  • ☐ Le distributeur fonctionnel et l'explication de la question 6.

← Les callbacks et les fonctions d'ordre supérieurTP 10 : Écrire un script modulaire avec des fonctions →

Cet article vous a-t-il aidé ?