À propos de ce cours
Chapitre 10 — Les fonctions en JavaScript · Les closures (fermetures)
• 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).

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 variablevaleur;compteurAetcompteurBsont indépendants. - Fabrique:
multiplicateur(2)renvoie une fonction qui se souvient defacteur = 2. - Données privées:
solden'est accessible qu'à travers les méthodes renvoyées ;compte.soldevautundefined, 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 variablei, partagée par les trois fonctions, qui vaut 3 à la fin. Aveclet, 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.
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.• 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) :
- Écrivez
creerGuichet(lettre)qui renvoie une fonctionsuivant()renvoyant le prochain ticket. Où est stocké le numéro courant ? Pourquoi deux guichets ne se mélangent-ils pas ? - Faites en sorte que
creerGuichetrenvoie un objet avec trois méthodes :suivant(),enAttente()(nombre de tickets distribués) etreinitialiser(). Peut-on modifier le compteur depuis l'extérieur ? - 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 ? - 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. - É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 ? - Expliquez avec vos mots, à l'aide de votre code, pourquoi la variable du compteur n'est pas détruite quand
creerGuicheta 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é ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !