Table of Contents
No vamos a engañarnos, aunque JavaScript es el lenguaje de programación más popular y utilizado en la actualidad, también arrastra un fuerte sentimiento de hate —aunque el rey sigue siendo PHP, creo—. Y, seamos sinceros, algo de este hate está justificado: los gemelos ==, el manejo de las variables globales y el scope, los falsy values, la gestión del this… Nada que no se haya comentado ya mil y una veces. Aunque, siendo justos, poco hate hay hacia cómo está diseñado el DOM con el que JS tiene que lidiar.
Volviendo a donde quería llegar, es cierto que muchas de estas problemáticas se han ido solucionando desde la actualización de ES6, allá por el lejano 2015. Pero también lo es que JS cuenta con algunas características que están bastante bien ejecutadas y que es interesante destacar. Entre ellas, destacan algunas que han permitido un resurgimiento de JS hacia la programación funcional (Functional Programming), como son las Arrow Functions, las closures y el currying. Estas no solo permiten escribir un código más estructurado y funcional, sino que también facilitan el uso de características que antes no funcionaban tan bien, como el contexto del this, la privacidad (encapsulación) y la reutilización de código.
En este artículo, vamos a profundizar en estos conceptos, explicando qué son, cómo usarlos y por qué pueden ayudarte.
JavaScript con Closures, Currying y Arrow Functions
JavaScript con Closures ¿Qué es?
Una closure en JavaScript es una función que conserva el acceso a las variables de su contexto de creación, incluso cuando se ejecuta fuera de ese contexto. Es decir, una función tiene acceso a su propio ámbito local, al ámbito externo donde fue definida y al entorno global.
Este concepto permite que las funciones “recuerden” el estado con el que fueron creadas, lo que resulta especialmente útil cuando se necesita mantener ciertos valores encapsulados y fuera del alcance de otras partes del programa.
Imagina que estás desarrollando una aplicación y necesitas que algunas funciones accedan a determinadas variables, pero sin exponerlas al resto del código. Las closures permiten encapsular ese estado de forma segura. Este patrón es habitual en escenarios como la gestión de sesiones de usuario, la implementación de permisos basados en roles o el control de lógica temporal, como temporizadores.
Ya que hablamos de un temporizador, vamos a ver la aplicación de una closure aplicada a un temporizador que tendrá su lógica encapsulada.
function createTimer() {
let seconds = 0;
return {
start: () => setInterval(() => seconds++, 1000),
reset: () => seconds = 0,
getTime: () => seconds
};
}
const timer = createTimer();
const timerInterval = timer.start();
setTimeout(() => {
console.log(timer.getTime()); // Output: 5 (después de 5 segundos)
timer.reset();
console.log(timer.getTime()); // Output: 0
clearInterval(timerInterval);
}, 5000);
En el ejemplo de arriba, la función createTimer crea un ámbito cerrado (closure) con la variable seconds. Las funciones start, reset y getTime acceden y modifican esa variable, incluso después de que createTimer haya terminado su ejecución.
Desde fuera, no se puede acceder directamente a seconds, quedando así protegido su estado interno. Este tipo de patrón es muy útil cuando quieres evitar exponer variables globales o evitar que otras partes del código manipulen un estado sensible.
¿Y el Currying?
El currying es una técnica de la programación funcional que consiste en transformar una función que acepta múltiples argumentos en una secuencia de funciones que reciben uno solo a la vez. Es cierto que leyéndolo suena algo abstracto (la programación funcional en general lo es), pero vamos a ver sus beneficios y un ejemplo que nos ayude a entenderlo mejor.
Beneficios
- Reutilización de lógica: Permite crear funciones más específicas a partir de una función general, lo que reduce la duplicación de código.
- Composición más simple: Favorece la creación de funciones pequeñas que se pueden encadenar y combinar fácilmente.
Relación con las closures
Y, ¿qué tiene que ver con las closures? Básicamente, que el currying funciona precisamente gracias a las closures: cada vez que se aplica uno de los argumentos, se crea un nuevo contexto que “recuerda” los valores previamente proporcionados. Así se construyen funciones parciales que pueden completarse más adelante.
function multiply(a) {
return function(b) {
return a * b;
};
}
const multiplyBy2 = multiply(2);
console.log(multiplyBy2(5)); // Output: 10
En este ejemplo, la función multiply no devuelve directamente el resultado, sino una nueva función que “recuerda” el valor de a. Esa nueva función, al ser ejecutada más adelante, todavía tiene acceso al valor original gracias a una closure. Es decir, multiplyBy2 es una función específica construida a partir de una más general, con el primer argumento ya “guardado”.
Dejo también su versión como arrow function ya que vamos a hablar de ellas:
const multiply = a => b => a * b;
const multiplyBy2 = multiply(2);
console.log(multiplyBy2(5)); // Output: 10
La relevancia de las closures en JavaScript actual
Con la llegada de ES6, JavaScript vivió una de las transformaciones más importantes de su historia. Se introdujeron nuevas formas de declarar variables (let, const), nuevas estructuras como clases, y sobre todo, las arrow functions (funciones flecha), que han redefinido la forma en cómo escribimos funciones desde hace unos años.
Estas herramientas no solo hicieron el lenguaje más expresivo y conciso, sino que también facilitaron el uso de closures en la práctica diaria. Gracias a un diseño más limpio y modular, trabajar con closures hoy es bastante más intuitivo.
Arrow Functions y closures
Las arrow functions no crean su propio contexto de this, lo que las hace especialmente útiles en ciertos escenarios donde se desea preservar el contexto exterior. Si es la primera vez que ves este tipo de sintaxis (aunque ya está bastante adaptada hoy día por varios lenguajes), puede ser difícil de entender, pero pasada esa barrera inicial hay que reconocer que tener un código más compacto favorece la creación de funciones que capturan y reutilizan valores, una de las fortalezas clave de las closures.
const createAdder = (a) => (b) => a + b;
const add10 = createAdder(10);
console.log(add10(5)); // Output: 15
En este caso, createAdder genera una nueva función que recuerda el valor de a incluso después de haber sido ejecutada. Esa “memoria” no es mágica: es una closure funcionando detrás de escena. La sintaxis en forma de flecha no solo reduce el código, sino que lo hace más legible y expresivo.
Aún así, como todo en esta vida, hay que saber cuándo usarlas y cuándo nos pueden causar algún que otro dolor de cabeza. Algunos de estos dolores pueden venir por:
- Acumulación innecesaria de memoria: Si no se gestionan bien, las closures pueden mantener vivas variables en memoria más tiempo del necesario.
- Confusión con el scope de
this: Especialmente cuando se mezclan funciones tradicionales con arrow functions. Recuerda que las arrow functions no tienen su propiothis. - Closures dentro de bucles mal estructurados: Si creas closures dentro de bucles sin cuidado (por ejemplo, con
var), puedes acabar capturando referencias inesperadas.
En resumen, las closures son una de las características más elegantes y potentes de JavaScript. Entenderlas a fondo no solo te va a ayudar a escribir mejor código, sino también a dominar patrones avanzados que se usan en librerías modernas, frameworks y desarrollo funcional.
Conclusión
JavaScript tiene sus luces y sombras, pero si hay algo que hace bien es ofrecernos herramientas potentes —aunque a veces no del todo evidentes— para escribir mejor código. Las closures, el currying y las arrow functions no son solo florituras académicas de la programación funcional: son recursos reales que pueden ayudarte a escribir código más limpio, más modular y, en muchos casos, más fácil de mantener.
Entender estos conceptos no es solo cuestión de “saber más JavaScript”, sino de aprender a pensar mejor en JavaScript. Porque, al final del día, no se trata de memorizar técnicas, sino de saber cuándo usarlas para resolver problemas reales y lograr que nuestro código sea más expresivo y fácil de entender por los demás.
Y aunque hemos hablado constantemente de programación funcional —no sé si lo he escrito suficientes veces…—, ten en cuenta que también vas a poder aplicarlos en tu código orientado a objetos. De hecho, esta mezcla es algo a lo que últimamente le estoy sacando bastante jugo… pero eso, probablemente, daría para otro artículo entero.
Recursos
Para no dejarte así… como con ganas de más, aquí te dejo unos cuantos recursos para que profundices si te apetece en estos conceptos que hemos visto:
- MDN Web Docs – Closures: La documentación oficial de MDN sobre closures y cómo funcionan en JavaScript.
- JavaScript.info – Closures: Un artículo muy completo y accesible sobre closures, ideal para principiantes.
- Eloquent JavaScript – Functional Programming: Un libro gratuito que profundiza en la programación funcional en JavaScript, con ejemplos prácticos de currying y closures.
- FreeCodeCamp – Arrow Functions: Un artículo de FreeCodeCamp sobre las funciones flecha y cómo usarlas en JavaScript.
- YouTube – JavaScript Closures Explained: Un video que explica de manera visual cómo funcionan las closures en JavaScript.
