19 novembre 2026

Scovare event listener “orfani” e memory leak: dal classico useEffect dimenticato al debug automatizzato

Un listener non rimosso può tenere in vita interi componenti. Oggi si può individuare il problema più in fretta facendo analizzare interazioni e crescita di memoria a strumenti e agenti integrati con DevTools.

Gli event listener registrati su window/document o su target globali sono una delle cause più comuni di memory leak nelle SPA: basta dimenticare una cleanup function in un useEffect e la closure può trattenere riferimenti al vecchio componente, impedendo al garbage collector di liberarlo. Vediamo perché succede, come riconoscerlo e come velocizzare l’individuazione di listener orfani automatizzando test di interazione e analisi della memoria con DevTools per agenti.

Il leak più comune nelle SPA: listener globali senza cleanup

In una SPA (React in testa), è normale agganciare event listener a target globali come window, document o a singleton condivisi (event bus, store, WebSocket, ecc.). Il problema nasce quando quel listener non viene rimosso al momento giusto, tipicamente allo smontaggio del componente.

Il caso da manuale è questo:

useEffect(() => {
  const onResize = () => {
    // usa state/props del componente
  };

  window.addEventListener('resize', onResize);
  // cleanup dimenticata ❌
}, []);

Sembra innocuo. In realtà è una delle forme più “silenziose” di memory leak.

Perché un listener non rimosso fa perdere memoria

Un event listener è una funzione. Quella funzione spesso è una closure: cattura variabili del contesto in cui è stata creata (state, props, riferimenti a DOM node, istanze di classi, cache, ecc.).

Se la funzione resta registrata su un oggetto globale, succede questo:

  • window (o document) mantiene un riferimento al listener;
  • il listener mantiene riferimenti al contesto del componente;
  • il contesto del componente non diventa mai “raggiungibile solo dal garbage collector”;
  • il garbage collector non può liberarlo.

Risultato: anche se l’interfaccia sembra funzionare, la memoria cresce a ogni mount/unmount e, col tempo, l’app degrada (scroll che scatta, tab che diventa lenta, crash su dispositivi con poca RAM).

Questo pattern non riguarda solo il frontend: un errore analogo esiste anche in ambienti Node.js quando si aggiungono listener (per esempio su process, su EventEmitter condivisi, o su connessioni che vivono più a lungo delle richieste) e non si rimuovono.

“Orphaned event listeners”: il sintomo pratico

Un listener diventa “orfano” quando:

  • è stato aggiunto durante un’azione o il ciclo di vita di un componente;
  • il componente non esiste più (o la logica che lo ha creato non è più valida);
  • il listener resta registrato e continua a vivere, spesso senza che nessuno lo noti.

In React può accadere anche quando:

  • l’effetto non ha cleanup;
  • l’effetto viene rieseguito e aggiunge listener multipli;
  • la funzione passata a removeEventListener non è la stessa reference usata in addEventListener (quindi la rimozione fallisce);
  • si usano target globali indiretti (es. librerie che registrano listener sotto al cofano) senza gestire teardown.

Il collo di bottiglia: trovarli a mano è costoso

Rintracciare questi leak manualmente è frustrante perché richiede di:

  1. riprodurre un flusso utente (navigazioni, aperture modali, mount/unmount ripetuti);
  2. osservare la memoria nel tempo;
  3. correlare la crescita a una causa specifica;
  4. risalire al punto esatto nel codice dove manca la cleanup.

È proprio il tipo di problema che tende a sfuggire ai code review: l’app “funziona”, i test passano, e la regressione emerge solo dopo sessioni lunghe.

Debug automatizzato: simulare interazioni e misurare crescita di memoria

Un approccio moderno è demandare parte dell’indagine a strumenti che:

  • simulano interazioni (click, navigazioni interne, apertura/chiusura componenti);
  • monitorano l’andamento della memoria (crescita progressiva dopo cicli ripetuti);
  • individuano listener rimasti appesi a target globali;
  • segnalano i punti in cui manca il teardown e dove inserire il cleanup.

L’idea chiave è semplice: invece di affidarsi solo all’intuizione (“forse questo effect perde”), si eseguono scenari ripetibili e si cerca una correlazione tra azioni e incrementi stabili di memoria.

La correzione: cleanup sempre, e con la stessa reference

La forma corretta dell’effetto include la funzione di cleanup:

useEffect(() => {
  const onResize = () => {
    // ...
  };

  window.addEventListener('resize', onResize);
  return () => {
    window.removeEventListener('resize', onResize);
  };
}, []);

Punti da ricordare:

  • La callback passata a removeEventListener deve essere la stessa identica reference.
  • Se l’effetto dipende da valori dinamici, evitare di aggiungere listener a ogni render senza rimuovere quelli precedenti.
  • Quando possibile, preferire pattern che riducono la necessità di listener globali (o incapsularli in hook ben testati).

Sintesi: trasformare un problema “invisibile” in un check ripetibile

Gli event listener non rimossi sono una causa classica di leak perché creano riferimenti duraturi tramite closure e impediscono la garbage collection di componenti ormai dismessi. Il salto di qualità sta nel rendere il debugging ripetibile e automatizzabile: eseguire interazioni standardizzate, osservare la crescita di memoria e arrivare rapidamente ai listener orfani.

La conseguenza pratica è immediata: meno sessioni di caccia al bug, meno regressioni “lente” in produzione e un’abitudine più disciplinata—cleanup sistematico—che alza la qualità complessiva dell’app.