Saltar al contenido
Cómo se ejecuta JS por dentro

Memoria y recolector de basura

Lección 7 de 712 min4 ejercicios

En JavaScript no reservas ni liberas memoria a mano: el motor lo hace por ti con un recolector de basura. Pero "automático" no significa "mágico". Si tu programa sigue apuntando a datos que ya no necesita, el recolector no puede liberarlos, y la memoria crece sin parar.

Qué mirar en el pizarrón

Fíjate en la nota del objeto: cuántas referencias le quedan. Un objeto sigue vivo mientras quede algún camino hasta él. Mira cuándo pasa a ser inalcanzable y qué hace el recolector entonces.

En el pizarrón

let usuario = { nombre: "Ana" };let admin = usuario; usuario = null;console.log(admin.nombre); admin = null;

Variables

  1. usuario→ objeto #1
  2. objeto #1{ nombre: 'Ana' } · 1 referencia
Consola(vacía)

El objeto se crea en el heap, la zona de memoria para objetos. usuario guarda una referencia a él.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: El objeto se crea en el heap, la zona de memoria para objetos. usuario guarda una referencia a él. Variables: usuario → objeto #1, objeto #1 { nombre: 'Ana' } · 1 referencia.
  2. Paso 2: Ahora dos variables apuntan al mismo objeto. Variables: usuario → objeto #1, admin → objeto #1, objeto #1 { nombre: 'Ana' } · 2 referencias.
  3. Paso 3: usuario = null suelta una de las flechas. El objeto sigue siendo alcanzable a través de admin, así que sigue vivo. Variables: usuario null, admin → objeto #1, objeto #1 { nombre: 'Ana' } · 1 referencia.
  4. Paso 4: Por eso admin.nombre sigue funcionando. Variables: usuario null, admin → objeto #1, objeto #1 { nombre: 'Ana' } · 1 referencia.
  5. Paso 5: Con admin = null ya no queda ningún camino desde el programa hasta el objeto. Es basura: ocupa memoria y nadie puede volver a usarlo. Variables: usuario null, admin null, objeto #1 { nombre: 'Ana' } · inalcanzable.
  6. Paso 6: En algún momento, el recolector de basura recorre todo lo alcanzable desde el programa, encuentra el objeto huérfano y libera su memoria. No decides cuándo: lo decide el motor. Variables: usuario null, admin null.

Pila y heap

El motor usa dos zonas de memoria:

  • La pila (stack): los marcos de las llamadas a funciones, con sus valores simples. Es pequeña y rapidísima, y se libera sola cuando cada función termina.
  • El heap (montículo): los objetos, arrays y funciones. Es grande, y es lo que administra el recolector.

Cuando haces const usuario = { nombre: "Ana" }, el objeto vive en el heap y la variable guarda una referencia a él, como viste en Valores primitivos y objetos.

Alcanzabilidad

El recolector no cuenta referencias una a una: se pregunta si un objeto es alcanzable. Parte de unas raíces (las variables globales y las de las funciones que se están ejecutando) y sigue todas las referencias, marcando lo que encuentra. Lo que no marcó es inalcanzable: basura que puede liberar. A este método se le llama marcar y barrer (mark-and-sweep).

Una consecuencia importante: dos objetos que se apuntan entre sí, pero a los que nadie más llega, sí se liberan. Lo que importa es si se puede llegar a ellos desde las raíces.

Fugas de memoria comunes

Una fuga es memoria que tu programa ya no usa pero que sigue alcanzable, así que nunca se libera:

  • Cachés que solo crecen: un Map o un array donde guardas resultados y nunca borras nada.
  • Temporizadores olvidados: un setInterval que nunca se detiene sigue manteniendo vivo todo lo que usa su función.
  • Listeners sin quitar: un addEventListener sobre un elemento que ya sacaste de la página.
  • Closures que recuerdan de más: una función guardada que recuerda un objeto enorme, aunque solo use un dato.
  • Variables globales que acumulan datos durante toda la vida de la página.

Para encontrarlas, las DevTools tienen la pestaña Memory, que toma “fotos” del heap y te deja compararlas.

WeakMap y WeakSet

Una WeakMap es como un Map cuyas claves no retienen a los objetos: si nadie más apunta al objeto clave, el recolector puede liberarlo y la entrada desaparece sola. Es perfecta para asociar datos extra a objetos que no controlas:

const vistas = new WeakMap();

let articulo = { titulo: "Closures" };
vistas.set(articulo, 1);
console.log(vistas.get(articulo));  // 1

articulo = null;  // el objeto ya no es alcanzable…
// …y su entrada en la WeakMap puede liberarse junto con él

A cambio tiene límites: las claves solo pueden ser objetos (o símbolos no registrados, desde ES2023), y no se puede recorrer ni preguntar su tamaño, porque sus entradas pueden desaparecer en cualquier momento. WeakSet es lo mismo para conjuntos.

WeakRef y FinalizationRegistry (ES2021)

ES2021 sumó dos herramientas de bajo nivel:

  • WeakRef: una referencia que no mantiene vivo al objeto. Con ref.deref() obtienes el objeto, o undefined si ya fue liberado.
  • FinalizationRegistry: te deja registrar una función que se ejecutará en algún momento después de que un objeto sea liberado.
let grande = { datos: "muchos datos" };
const ref = new WeakRef(grande);

console.log(ref.deref()?.datos);  // muchos datos (mientras siga vivo)

Resumen

  • Los objetos viven en el heap; las variables guardan referencias a ellos.
  • El recolector libera lo que no es alcanzable desde las raíces (mark-and-sweep). No controlas cuándo.
  • Las fugas vienen de referencias que olvidaste soltar: cachés, temporizadores, listeners, globales.
  • WeakMap y WeakSet no retienen sus claves: ideales para datos extra sobre objetos.
  • WeakRef y FinalizationRegistry (ES2021) existen, pero son para casos avanzados.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Qué se libera y cuándo

Elige una respuesta en cada pregunta.

  1. ¿Cuándo puede el recolector liberar un objeto?

  2. ¿Qué diferencia a una WeakMap de un Map?

  3. ¿Cuál de estos es una fuga de memoria típica?

  4. ¿Puedes forzar al recolector a ejecutarse desde tu código?

Ordena la salida: Una WeakMap por dentro

Ordena lo que aparecería en la consola. Ojo con la última línea: ¿es el mismo objeto?

const extra = new WeakMap();const usuario = { id: 1 }; extra.set(usuario, "visto hoy"); console.log(extra.has(usuario));console.log(extra.get(usuario));console.log("size" in extra);console.log(extra.get({ id: 1 }));

Consola, de arriba abajo

  1. undefined
  2. visto hoy
  3. false
  4. true

Detective: Una clave que no puede ser débil

Alguien quiso contar visitas por nombre con una WeakMap. Encuentra la línea que falla y elige la estructura correcta.

Consola

Registrando...
visitas.js:3
visitas.set("ana", 3);
        ^

TypeError: Invalid value used as weak map key

Paso 1: toca la línea de código que causa el error.

Laboratorio: Una caché que no retiene

Escribe medir(obj) con una caché en una WeakMap: la segunda vez que se mide el mismo objeto no se debe recalcular, y la caché no debe retener los objetos.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime 200, 200 y 1: el segundo medir no recalcula (pendiente)
  • Usa una WeakMap como caché (pendiente)
  • Funciona con otros objetos: medir({ k: 1 }) da 100 (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.