JavaScript Academy · Leçon

Variables privées avec des fermetures

Masquez l’état derrière la portée d’une fonction.

Variables privées avec des fermetures est une leçon JavaScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage JavaScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours JavaScript Academy comprend 4 leçons au total.

La confidentialité grâce aux fermetures

JavaScript a longtemps été dépourvu d’un moyen intégré de rendre privés les champs d’un objet. Les fermetures en fournissent un : les variables à l’intérieur d’une fonction sont invisibles depuis l’extérieur, tout en restant accessibles aux fonctions qui y sont définies.

function secretBox() {
  let secret = "hidden";
  return {
    reveal: () => secret
  };
}
const box = secretBox();
console.log(box.reveal()); // "hidden"
console.log(box.secret);   // undefined

Un compteur à état privé

L’exemple classique : un compteur dont la valeur ne peut pas être modifiée directement. Seules les méthodes renvoyées peuvent la changer.

function makeCounter() {
  let count = 0;
  return {
    increment: () => ++count,
    value: () => count
  };
}
const c = makeCounter();
c.increment();
c.increment();
console.log(c.value()); // 2

L’état est inaccessible

Il n’existe aucun moyen d’atteindre count depuis l’extérieur. Les tentatives de lecture renvoient undefined ; vous devez passer par les méthodes.

function makeCounter() {
  let count = 0;
  return { inc: () => ++count, get: () => count };
}
const c = makeCounter();
c.count = 100;        // creates an unrelated property
console.log(c.get()); // 0 - real count untouched

Faire respecter les règles

Comme l’accès passe par des méthodes, vous pouvez imposer des invariants, par exemple empêcher balance de devenir négatif.

function account(start) {
  let balance = start;
  return {
    withdraw: (n) => {
      if (n > balance) return "insufficient";
      balance -= n;
      return balance;
    },
    balance: () => balance
  };
}
const a = account(100);
console.log(a.withdraw(150)); // "insufficient"
console.log(a.withdraw(40));  // 60

Plusieurs champs privés

Une fermeture peut protéger plusieurs variables à la fois. Elles sont toutes masquées et partagées uniquement entre les méthodes renvoyées.

function user(name) {
  let logins = 0;
  let lastSeen = null;
  return {
    login: () => { logins++; lastSeen = "now"; },
    stats: () => ({ name, logins, lastSeen })
  };
}
const u = user("Ada");
u.login();
console.log(u.stats()); // { name: "Ada", logins: 1, lastSeen: "now" }

Fonctions auxiliaires privées

Vous pouvez masquer non seulement les données, mais aussi les fonctions internes. Seules les méthodes que vous exposez sont publiques.

function temperature() {
  let celsius = 0;
  const toF = (c) => c * 9 / 5 + 32; // private
  return {
    set: (c) => { celsius = c; },
    fahrenheit: () => toF(celsius)
  };
}
const t = temperature();
t.set(100);
console.log(t.fahrenheit()); // 212

Instances indépendantes

Chaque appel à la fabrique crée un état privé distinct ; les instances ne se gênent donc jamais entre elles.

function makeCounter() {
  let n = 0;
  return { inc: () => ++n };
}
const a = makeCounter();
const b = makeCounter();
console.log(a.inc(), a.inc()); // 1 2
console.log(b.inc());          // 1

Exposition en lecture seule

Exposez un accesseur de lecture sans accesseur d’écriture pour rendre une valeur accessible en lecture seule depuis l’extérieur tout en la gardant modifiable en interne.

function timer() {
  let ticks = 0;
  setupInternally();
  function setupInternally() { ticks = 3; }
  return { ticks: () => ticks };
}
const t = timer();
console.log(t.ticks()); // 3 - no way to set it outside

Comparaison : champs de classe

JavaScript moderne prend également en charge les champs de classe privés #private. Les fermetures restent utiles pour les fonctions de fabrique et lorsque vous souhaitez préserver la confidentialité sans utiliser de classes.

class Counter {
  #count = 0;
  inc() { return ++this.#count; }
}
const c = new Counter();
console.log(c.inc()); // 1

Pourquoi cela fonctionne

Les méthodes renvoyées sont des fermetures sur les variables externes. La fonction externe a renvoyé son résultat, mais sa portée continue d’exister, car ces fermetures y font toujours référence.

Un cache de mémoïsation

L’état privé est idéal pour les caches. L’objet cache reste masqué et persiste entre les appels.

function memoSquare() {
  const cache = {};
  return (n) => {
    if (cache[n] === undefined) cache[n] = n * n;
    return cache[n];
  };
}
const sq = memoSquare();
console.log(sq(4)); // 16
console.log(sq(4)); // 16 (cached)

Vérification rapide

Les variables privées avec les fermetures.

Récapitulatif

Les fermetures créent de la confidentialité : les variables à l’intérieur d’une fabrique sont inaccessibles depuis l’extérieur, mais partagées entre les méthodes renvoyées. Cela permet de créer des compteurs infalsifiables, des balances avec des invariants, des fonctions auxiliaires masquées et des caches. Chaque appel de la fabrique produit un état indépendant. Les champs de classe modernes #private constituent une autre solution, mais les fermetures sont particulièrement adaptées au code fondé sur les fabriques.

Questions Fréquemment Posées

La leçon « Variables privées avec des fermetures » est-elle gratuite ?

Oui — le texte complet de « Variables privées avec des fermetures » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours JavaScript Academy, passe à CoddyKit PRO. Le cours JavaScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Variables privées avec des fermetures » ?

Masquez l’état derrière la portée d’une fonction. Tu pratiques JavaScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer JavaScript Academy ?

Aucune expérience préalable n'est requise. JavaScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Variables privées avec des fermetures » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon JavaScript Academy ?

Oui. Chaque leçon JavaScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à JavaScript Academy