Aller au contenu
YouTurkey Tech
Tous les sujets JavaScript

Closures

Intermédiaire

Comment une fonction continue d'utiliser les variables qui l'entourent après le retour de la fonction externe, et pourquoi une boucle var affiche 3, 3, 3.S'appuie sur Scope Chain

Pile d'appels

Vide

Portées

Vide

Tas

Vide

Console

Vide

0/21Appuyez sur Lecture, ou avancez pas à pas avec les flèches, pour commencer.
Étape 0 sur 21

Explication

Lecture : 2 min

Sur cette page

Qu'est-ce qu'une closure en JavaScript ?

Une est une fonction accompagnée de l'environnement où elle a été créée. En JavaScript, chaque fonction garde un lien vers la portée où elle a été écrite : elle peut donc lire et modifier ces variables plus tard, même après le retour de la fonction externe.

C'est grâce aux closures que JavaScript offre l'état privé, les fabriques comme makeCounter, les utilitaires once et debounce, et les callbacks qui se souviennent d'où ils viennent.

Comment une closure garde-t-elle ses variables ?

  • Normalement, un appel de fonction jette son environnement quand il se termine.
  • Si une fonction créée pendant cet appel reste accessible (renvoyée, rangée quelque part ou confiée à un minuteur), l'environnement est gardé en vie, car cette fonction pointe toujours vers lui.
  • La closure garde la variable, pas une photo de sa valeur. Si la variable change, la closure voit la nouvelle valeur.
  • Chaque appel crée un nouvel environnement. Deux appels à makeCounter() donnent deux variables count indépendantes.

Quelles erreurs fait-on souvent avec les closures ?

Mini-exemple

function createWallet(start) {  let balance = start;  return {    deposit(amount) {      balance += amount;    },    getBalance() {      return balance;    },  };} const wallet = createWallet(100);wallet.deposit(50);console.log(wallet.getBalance()); // 150console.log(wallet.balance); // undefined: only the closures can reach it

Test rapide

Que affiche for (var i = 0; i < 3; i++) { setTimeout(() => console.log(i), 0); } ?

Pour aller plus loin

Toutes les étapes en texte
  1. Étape 1:

    Le contexte global démarre en phase de création et prépare chaque déclaration avant d'exécuter la moindre ligne.

  2. Étape 2:

    makeCounter est enregistrée comme fonction, counter est réservée sans être initialisée, et var i vaut undefined.

    Lignes 1–13

  3. Étape 3:

    makeCounter() est appelée. Son environnement est relié au global, et count y est réservée.

    Ligne 9

  4. Étape 4:

    count est initialisée à 0.

    Ligne 2

  5. Étape 5:

    La fonction fléchée est créée dans makeCounter : elle garde un lien vers l'environnement de makeCounter.

    Lignes 3–6

  6. Étape 6:

    makeCounter se termine et quitte la pile, mais son environnement reste : la fonction fléchée a encore besoin de count. C'est une closure.

    Ligne 9

  7. Étape 7:

    counter() exécute la fonction fléchée. Son environnement est relié à celui de makeCounter, où elle a été créée.

    Ligne 10

  8. Étape 8:

    count++ cherche count : absente de son propre environnement, la recherche remonte d'un cran. La vraie variable passe à 1.

    Ligne 4

  9. Étape 9:

    Elle renvoie 1, et console.log l'affiche.

    Lignes 5–10

  10. Étape 10:

    Le deuxième appel retrouve la même count, qui vaut encore 1 depuis la dernière fois, et la passe à 2.

    Lignes 4–11

  11. Étape 11:

    2 s'affiche. count est privée : seule la fonction fléchée peut y accéder.

    Lignes 5–11

  12. Étape 12:

    Place à la boucle classique des entretiens. var i est une seule variable de l'environnement global, partagée par toutes les itérations.

    Ligne 13

  13. Étape 13:

    setTimeout garde le callback pour plus tard ; il ne s'exécute pas maintenant. Le callback retient la variable i, pas sa valeur actuelle 0.

    Ligne 14

  14. Étape 14:

    i passe à 1 et un deuxième callback est gardé. Il est relié au même environnement global.

    Lignes 13–14

  15. Étape 15:

    i passe à 2 et un troisième callback est gardé.

    Lignes 13–14

  16. Étape 16:

    i++ fait passer i à 3 : i < 3 est faux et la boucle s'arrête. Aucun callback ne s'est encore exécuté.

    Ligne 13

  17. Étape 17:

    Le script est terminé et son contexte quitte la pile. L'environnement global reste, et les minuteurs vont se déclencher.

  18. Étape 18:

    Le premier callback s'exécute. i n'est pas dans son environnement : la recherche remonte au global et trouve 3.

    Ligne 14

  19. Étape 19:

    Il affiche 3, et non 0.

    Ligne 14

  20. Étape 20:

    Les deux autres callbacks suivent le même chemin vers la même i : chacun affiche 3 lui aussi.

    Ligne 14

  21. Étape 21:

    Sortie : 1, 2, 3, 3, 3. Une closure garde la variable, pas sa valeur ; avec let i, chaque itération a sa propre i et la boucle affiche 0, 1, 2.