Evitando el estado global mutable
29-10-2026
El código sostenible se construye a partir de pequeñas decisiones que tomamos cada día durante el desarrollo. En este caso, veremos los riesgos de utilizar variables globales.
Las variables globales son aquellas a las que se puede acceder desde diferentes partes de una aplicación sin necesidad de pasarlas explícitamente como argumentos. A primera vista, pueden parecer una solución cómoda: permiten compartir información fácilmente y evitan repetir código. Sin embargo, esa comodidad tiene un coste. A medida que una aplicación crece, las variables globales pueden dificultar la comprensión del código, generar dependencias ocultas y provocar errores difíciles de detectar. Además, cualquier parte del programa puede modificarlas, lo que hace más complicado saber quién es responsable de un determinado estado. Podemos ver el siguiente ejemplo de código:
// global-account.ts export let balance = 1000; export function resetBalance(): void { balance = 1000; } export function depositMoney(amount: number): void { balance += amount; } export function withdrawMoney(amount: number): boolean { if (amount > balance) { return false; } balance -= amount; return true; } export function getBalance(): number { return balance; }
En este caso, el estado está compartido por todas las funciones del módulo. Si añadimos nuevas operaciones, tendrán acceso directo a balance, lo que aumenta el riesgo de modificarlo de forma incorrecta. Veamos los tests unitarios:
// global-account.test.ts import { beforeEach, describe, expect, it } from "vitest"; import { balance, resetBalance, depositMoney, withdrawMoney, getBalance, } from "./global-account"; describe("Global account", () => { beforeEach(() => { resetBalance(); }); it("should deposit money", () => { depositMoney(500); expect(getBalance()).toBe(1500); }); it("should withdraw money", () => { const result = withdrawMoney(200); expect(result).toBe(true); expect(getBalance()).toBe(800); }); it("should not allow withdrawing more than the balance", () => { const result = withdrawMoney(1500); expect(result).toBe(false); expect(getBalance()).toBe(1000); }); });
Podemos ver los siguientes problemas:
- Dependencias ocultas: las funciones dependen de la variable
balance, aunque esta no aparece en sus parámetros. Esto dificulta conocer qué datos necesita cada función. - Modificaciones desde cualquier lugar: al estar compartido por las funciones del módulo,
balancepuede modificarse sin pasar por una única interfaz que centralice las reglas del negocio. - Dificultad para realizar pruebas: el resultado de una función depende de un estado externo que puede haber sido modificado por otra prueba. Por eso necesitamos llamar a resetBalance() antes de cada test. El problema no es que los tests necesiten preparación, sino que deben conocer y modificar un estado compartido para poder ejecutarse de forma independiente. Si olvidamos hacerlo, una prueba puede depender del estado dejado por otra, lo que dificulta el aislamiento y puede generar tests frágiles.
- Problemas de mantenimiento: cuando el programa crece, resulta difícil localizar qué partes del código leen o modifican la variable.
- Riesgo de conflictos: distintos módulos pueden utilizar nombres globales similares o modificar accidentalmente el mismo estado.
El debate sobre los riesgos de las variables globales no es nuevo. En el artículo Global Variables Considered Harmful [1] se recogen algunos de los problemas asociados a este tipo de estado compartido.
Una alternativa es mantener el estado dentro de una clase y controlar el acceso mediante métodos. De esta forma, el saldo no está disponible directamente para todo el programa, como podemos apreciar en el siguiente ejemplo de código:
// account.ts export class Account { private balance: number; constructor(initialBalance: number) { if (initialBalance < 0) { throw new Error("The initial balance cannot be negative"); } this.balance = initialBalance; } depositMoney(amount: number): void { if (amount <= 0) { throw new Error("The amount must be positive"); } this.balance += amount; } withdrawMoney(amount: number): boolean { if (amount <= 0 || amount > this.balance) { return false; } this.balance -= amount; return true; } getBalance(): number { return this.balance; } }
En este caso, cada instancia de Account mantiene su propio estado. Dos cuentas pueden existir al mismo tiempo sin compartir el saldo accidentalmente. Además, los tests no necesitan conocer ni modificar el estado interno de otras instancias. Veamos los tests unitarios:
// account.test.ts import { describe, expect, it } from "vitest"; import { Account } from "./account"; describe("Account", () => { it("should reject a non-positive deposit", () => { const account = new Account(1000); expect(() => account.depositMoney(0)).toThrow( "The amount must be positive" ); }); it("should reject a negative initial balance", () => { expect(() => new Account(-100)).toThrow( "The initial balance cannot be negative" ); }); it("should deposit money", () => { const account = new Account(1000); account.depositMoney(500); expect(account.getBalance()).toBe(1500); }); it("should withdraw money", () => { const account = new Account(1000); const result = account.withdrawMoney(200); expect(result).toBe(true); expect(account.getBalance()).toBe(800); }); it("should not allow withdrawing more than the balance", () => { const account = new Account(1000); const result = account.withdrawMoney(1500); expect(result).toBe(false); expect(account.getBalance()).toBe(1000); }); it("should keep accounts isolated from each other", () => { const firstAccount = new Account(1000); const secondAccount = new Account(500); firstAccount.depositMoney(200); expect(firstAccount.getBalance()).toBe(1200); expect(secondAccount.getBalance()).toBe(500); }); });
Las variables globales no son siempre incorrectas.
En aplicaciones pequeñas o en casos muy concretos pueden resultar útiles. Por ejemplo, una constante cuyo valor no cambia y que representa una configuración general puede ser perfectamente válida, como se muestra en el siguiente ejemplo de código:
// config.ts export const APP_VERSION = "1.0.0";
El problema aparece cuando utilizamos variables globales mutables para compartir estado entre muchas partes del programa. Cuanto más código dependa de ellas, mayor será el riesgo de introducir efectos secundarios y errores.
Como regla general, es preferible:
- Mantener las variables lo más cerca posible del lugar donde se utilizan.
- Pasar los datos mediante parámetros.
- Devolver resultados en lugar de modificar estados externos.
- Encapsular el estado mutable en clases u otros módulos bien definidos.
- Utilizar
constsiempre que una variable no necesite cambiar. - Evitar que cualquier parte de la aplicación pueda modificar directamente datos compartidos.
Conclusión Las variables globales pueden parecer una solución sencilla para compartir información, pero su uso excesivo introduce dependencias ocultas, dificulta las pruebas y hace que el código sea más difícil de mantener. La clave no es eliminar todas las variables globales, sino evitar el estado global mutable cuando no sea necesario. Mantener el estado encapsulado y controlar quién puede modificarlo hace que el código sea más fácil de entender, probar y mantener.
Referencias:
