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(odocument) 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
removeEventListenernon è la stessa reference usata inaddEventListener(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:
- riprodurre un flusso utente (navigazioni, aperture modali, mount/unmount ripetuti);
- osservare la memoria nel tempo;
- correlare la crescita a una causa specifica;
- 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
removeEventListenerdeve 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.