Aller au contenu
YouTurkey Tech
Tous les sujets JavaScript

Garbage Collection

Avancé

Comment JavaScript décide quels objets libérer, et comment une closure ou un écouteur d'événement oublié garde la mémoire occupée.S'appuie sur Primitive vs Reference Types, Closures, Higher-Order Functions

Pile d'appels

Vide

Portées

Vide

Tas

Vide

Console

Vide

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

Explication

Lecture : 3 min

Sur cette page

Qu'est-ce que le garbage collection en JavaScript ?

JavaScript gère la mémoire pour vous. Quand vous créez un objet, le moteur lui réserve de la mémoire ; quand l'objet n'est plus atteignable, le garbage collector (ramasse-miettes) libère cette mémoire. Il n'existe pas de delete/free pour les objets : on libère la mémoire en lâchant les références vers elle.

Comment le garbage collector décide-t-il quoi libérer ?

Les moteurs modernes utilisent le (marquer puis balayer), fondé sur l'atteignabilité :

  1. Partir des racines : les variables globales, les variables de chaque fonction sur la pile d'appels, et ce que le navigateur garde (window, le DOM, les écouteurs d'événements, les minuteurs actifs).
  2. Marquer tout ce que ces racines référencent, puis tout ce que ces objets référencent, et ainsi de suite.
  3. Balayer : libérer chaque objet non marqué.

Deux conséquences reviennent en entretien :

  • Une closure est atteignable via la fonction qui la porte. Tant que la fonction est atteignable, chaque variable qu'elle utilise reste aussi en mémoire.
  • La collecte a lieu quand le moteur le décide, pas au moment où l'on lâche une référence. Les moteurs découpent aussi le tas en générations et examinent plus souvent les objets jeunes, car la plupart des objets meurent jeunes.

Quelles erreurs fait-on souvent avec la mémoire ?

Mini-exemple

function watchResize(onResize) {  const controller = new AbortController();  window.addEventListener('resize', onResize, { signal: controller.signal });  return () => controller.abort(); // removes the listener} const stop = watchResize(() => console.log(window.innerWidth));// Later, when the component goes away:stop(); // the listener and everything it closes over can now be freed

Test rapide

Après let user = { name: "Ali" }; const admin = user; user = null;, l’objet peut-il être collecté ?

Pour aller plus loin

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

    Le garbage collector part des racines : la portée globale, la pile d'appels et les objets du navigateur comme window. Tout ce qu'il peut atteindre depuis elles reste.

  2. Étape 2:

    Phase de création : user, admin et report sont réservées, et makeReport est enregistrée comme fonction.

    Lignes 1–12

  3. Étape 3:

    Un objet est créé dans le tas. Il est atteignable, car la variable globale user pointe vers lui.

    Ligne 1

  4. Étape 4:

    Un second objet est créé, et sa propriété boss contient une référence vers le premier.

    Ligne 2

  5. Étape 5:

    user.team = admin fait pointer le premier objet vers le second. Les deux objets forment maintenant un cycle.

    Ligne 3

  6. Étape 6:

    user = null lâche une référence, mais Object @1 reste atteignable : global → admin → boss. Il reste donc.

    Ligne 4

  7. Étape 7:

    Plus aucune racine ne mène à l'un ou l'autre objet. Ils pointent encore l'un vers l'autre, mais le collecteur part des racines et les libère tous deux : les cycles ne fuient pas.

    Ligne 5

  8. Étape 8:

    makeReport() est appelée, et rows est réservée dans sa portée.

    Ligne 12

  9. Étape 9:

    Un grand tableau de 100 000 éléments est créé dans le tas.

    Ligne 8

  10. Étape 10:

    makeReport renvoie la fonction fléchée dans report. Sa portée reste en vie car la closure utilise rows, et le tableau aussi.

    Lignes 9–12

  11. Étape 11:

    report() s'exécute et atteint rows grâce à sa closure.

    Ligne 13

  12. Étape 12:

    Elle renvoie la longueur, et 100000 s'affiche.

    Ligne 13

  13. Étape 13:

    report = null lâche la seule référence à la closure. La fonction, puis sa portée, puis le tableau deviennent inatteignables et sont libérés.

    Ligne 14

  14. Étape 14:

    makeReport() s'exécute de nouveau : une nouvelle portée, et un nouveau grand tableau.

    Ligne 16

  15. Étape 15:

    La fonction renvoyée part directement dans addEventListener, qui la range sur window. Votre code n'en garde aucune référence.

    Ligne 16

  16. Étape 16:

    Le tableau reste atteignable : window → écouteur → sa portée → rows. window vit aussi longtemps que la page : cette mémoire n'est jamais libérée.

    Ligne 16

  17. Étape 17:

    C'est une fuite mémoire : de la mémoire dont on n'a plus besoin, encore atteignable depuis une racine. Gardez une référence et appelez removeEventListener, ou passez un signal et annulez-le.