Gestión de memoria en TypeScript: cómo funciona el recolector de basura

Memoria y recolector de basura en TypeScript: ¿qué se esconde detrás de escena?

Imagina que estás construyendo una casa. Compras ladrillos, cemento, acero — pero si no limpias los escombros de construcción, pronto el sitio de construcción se convertirá en un vertedero. Lo mismo sucede en tu código TypeScript. Creas objetos, arrays, closures — y si no liberas memoria a tiempo, la aplicación comienza a ralentizarse y luego se cae por completo con el error Out of Memory.

En este artículo, analizaremos cómo funciona la gestión de memoria en TypeScript y su herramienta principal — el recolector de basura. Aprenderás qué mecanismos están detrás de la liberación de memoria, cómo evitar fugas y por qué tu código puede «consumir» megabytes incluso después de que hayas dejado de usarlo.

¡Allá vamos!

¿Cómo gestiona TypeScript la memoria? Conceptos básicos

Empecemos con algo importante: TypeScript no es un lenguaje independiente, sino una extensión de JavaScript. Esto significa que la memoria y el recolector de basura en TypeScript funcionan exactamente igual que en JavaScript. TypeScript no añade nuevos mecanismos de gestión de memoria, pero nos proporciona herramientas (tipos, interfaces) para escribir código más seguro.

En JavaScript, la memoria se divide en dos áreas principales:

\n
• Pila (Stack) — almacena primitivos (números, cadenas, valores booleanos) y referencias a objetos. Se libera automáticamente al salir de una función.
\n
• Montón (Heap) — almacena objetos, arrays, funciones. Aquí es donde trabaja el recolector de basura.
\n

Cuando escribes:

const user = { name: 'Alice', age: 30 };

La variable user se almacena en la pila y contiene una referencia al objeto en el montón. Mientras exista la referencia, el objeto está vivo. Tan pronto como la referencia desaparece, el objeto se convierte en «basura».

Recolector de basura en TypeScript: ¿cómo funciona?

El recolector de basura (Garbage Collector, GC) es un proceso automático que encuentra objetos a los que ya no se hace referencia y libera la memoria que ocupan. Los motores modernos (V8 en Chrome, SpiderMonkey en Firefox) utilizan algoritmos complejos, pero la base es el algoritmo de marcado y barrido (Mark-and-Sweep).

Cómo funciona:

\n
1. El GC comienza desde las «raíces» — objetos globales, variables locales en funciones que se están ejecutando.
\n
2. Recorre todas las referencias desde las raíces y marca cada objeto alcanzable.
\n
3. Todos los objetos no marcados se consideran basura y se eliminan.
\n

Suena simple, pero en la práctica hay matices. Por ejemplo, las referencias cíclicas:

function createCycle() {\n    const obj1: any = {};\n    const obj2: any = {};\n    obj1.ref = obj2;\n    obj2.ref = obj1;\n    return 'done';\n}

Antes, estas estructuras provocaban fugas, pero los recolectores de basura modernos manejan muy bien los ciclos — siempre que ambos objetos sean inalcanzables desde las raíces.

Fugas de memoria típicas en aplicaciones TypeScript

Incluso con un recolector de basura inteligente, se puede «pisar el rastrillo». Estos son los escenarios más comunes que provocan fugas de memoria en TypeScript:

1. Temporizadores y manejadores de eventos olvidados

Una de las causas más comunes. Te suscribiste a un evento y olvidaste cancelar la suscripción:

class TimerComponent {\n    private intervalId: number;\n\n    start() {\n        this.intervalId = window.setInterval(() => {\n            console.log('Tick');\n        }, 1000);\n    }\n\n    // ¡Olvidaste llamar a stop() — el temporizador vivirá para siempre!\n}

Solución: siempre limpia los temporizadores y cancela las suscripciones a eventos en el método dispose o ngOnDestroy (para Angular).

2. Closures que mantienen referencias

Los closures son una herramienta poderosa, pero pueden retener accidentalmente objetos enormes:

function createHeavyClosure() {\n    const hugeData = new Array(1000