---
title: "La fuga de Meteor: dos closures, un entorno"
url: "https://www.mikefluff.com/es/experiments/js-ch03-shared-closure"
locale: "es"
author: "Mikhail Savchenko (Mike Fluff)"
updated: "2026-11-18"
description: "Fuga de memoria por closures en V8"
book: "https://www.mikefluff.com/es/books/from-closures-to-autonomous-systems"
alternates:
  - locale: "en"
    url: "https://www.mikefluff.com/en/experiments/js-ch03-shared-closure"
    markdown: "https://www.mikefluff.com/en/experiments/js-ch03-shared-closure.md"
  - locale: "ru"
    url: "https://www.mikefluff.com/ru/experiments/js-ch03-shared-closure"
    markdown: "https://www.mikefluff.com/ru/experiments/js-ch03-shared-closure.md"
  - locale: "pt"
    url: "https://www.mikefluff.com/pt/experiments/js-ch03-shared-closure"
    markdown: "https://www.mikefluff.com/pt/experiments/js-ch03-shared-closure.md"
  - locale: "es"
    url: "https://www.mikefluff.com/es/experiments/js-ch03-shared-closure"
    markdown: "https://www.mikefluff.com/es/experiments/js-ch03-shared-closure.md"
---

# La fuga de Meteor: dos closures, un entorno

*Fuga de memoria por closures en V8*

## ¿Cómo puede un closure causar una fuga de memoria en JavaScript?

Un closure mantiene vivas las variables de la función en la que se creó mientras el propio closure sea alcanzable. En V8, las variables que necesita alguna función interna se guardan en un único objeto de contexto por cada llamada a la función externa, y todos los closures creados en esa llamada apuntan al objeto entero, no solo a las variables que usan. Así, un closure de vida larga puede mantener vivo un valor grande al que solo se refería otro closure, de vida corta. Si ese valor a su vez retiene un closure anterior, la cadena crece con cada llamada y el recolector de basura no puede liberar nada de ella.

En 2013 David Glasser, del equipo de Meteor, encontró una fuga de memoria en la parte de Meteor que vuelve a dibujar las plantillas cuando cambian los datos, la corrigió para la versión 0.6.5 y publicó un ejemplo de pocas líneas. Dentro de replaceThing hay dos funciones: unused, que mira el objeto anterior a través de originalThing y nunca se llama, y someMethod, que se guarda en el objeto nuevo y nunca toca originalThing. Leído a ojo, el código no tiene nada que perder.

Pulsa replaceThing() una vez, de diez en diez o hasta doscientas, y bajo el código crece la cadena de objetos que el recolector de basura todavía alcanza: la global theThing retiene someMethod, someMethod retiene el entorno de su llamada, el entorno retiene originalThing, y ese es el theThing anterior con su propio someMethod. Cambia entre las variantes del experimento del libro: orig como en el post de Glasser, shared, donde someMethod usa una variable local, fixed, con originalThing = null al final, y control, donde unused se guarda a propósito. Esto es un modelo, no una medición en vivo, porque una página no puede forzar la recolección de basura.

En el libro, tras 200 llamadas y una recolección forzada, heapUsed quedó en 202,7 MB en Node 20 y 203,7 MB en Node 24 en las variantes orig, shared y control, y en 3,6 y 4,7 MB con el arreglo. Llegar a esas cifras exigió corregir un error. Con el payload original, una cadena de un millón de asteriscos hecha con join, la memoria se quedaba quieta incluso en el control: V8 guarda esa cadena como ConsString, y 200 de ellas ocuparon 11 MB, mientras que tras slice ocupaban 194 MB. El payload pasó a ser un array de números, y el control ahora se escribe primero.

El capítulo pregunta quién responde por este error. La especificación dice qué variables ve una función y calla sobre cómo guardarlas; V8 las guarda en un único objeto compartido por llamada, y doce años después del post de Glasser la fuga sigue ahí. Al entregar la memoria al recolector de basura, el programador tiene que saber del motor más de lo que prometía la especificación.

_La página tiene un experimento interactivo que funciona en el navegador: https://www.mikefluff.com/es/experiments/js-ch03-shared-closure_

## Fuentes

- [MDN, Closures](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures)
- [MDN, Memory management](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_management)

## Del libro

A su lado en el libro:

> Both bugs in this chapter are built the same way and differ in who answers for them. The shared variable in a loop with var was invented by the specification, and the specification fixed it in 2015 by adding let. The shared object of variables was invented by the engine, nobody is obliged to change it, and twelve years later it is still there. By handing memory to the garbage collector, the programmer also got V8’s habits, about which the language specification has not a single line.

- Leer el capítulo: [Chapter 3. Functions as Data](https://www.mikefluff.com/en/read/from-closures-to-autonomous-systems/ch03) (inicio libre, el resto en el libro completo; Markdown: https://www.mikefluff.com/en/read/from-closures-to-autonomous-systems/ch03.md)

- Libro: [JavaScript: From Closures to Autonomous Systems](https://www.mikefluff.com/es/books/from-closures-to-autonomous-systems)
