JavaScript
Compara preventExtensions, Object.seal y Object.freeze, sus efectos sobre descriptores y los límites de estas restricciones superficiales.
JavaScript permite restringir cambios estructurales sobre un objeto mediante tres niveles:
Object.preventExtensions(object);
Object.seal(object);
Object.freeze(object);De menor a mayor restricción:
preventExtensions → seal → freezeUn objeto normal permite agregar propiedades.
const settings = {
theme: "dark",
};
settings.pageSize = 20;Object.isExtensible(settings); // trueObject.preventExtensions(settings);Después:
settings.theme = "light"; // Puede funcionar.
delete settings.theme; // Puede funcionar.
settings.language = "es"; // No puede agregarse.En modo estricto, agregar una propiedad produce un TypeError. Fuera de modo estricto puede fallar silenciosamente.
Object.isExtensible(settings); // falseconst settings = {
theme: "dark",
};
Object.seal(settings);Un objeto sellado:
settings.theme = "light"; // Permitido.
settings.language = "es"; // No permitido.
delete settings.theme; // No permitido.Object.isSealed(settings); // true
Object.isExtensible(settings); // falseconst settings = {
theme: "dark",
};
Object.freeze(settings);Un objeto congelado:
settings.theme = "light"; // No permitido.
settings.language = "es"; // No permitido.
delete settings.theme; // No permitido.Object.isFrozen(settings); // true
Object.isSealed(settings); // true
Object.isExtensible(settings); // falseTodo objeto congelado también está sellado y no es extensible.
Antes de congelar:
Object.getOwnPropertyDescriptor(
settings,
"theme",
);Una propiedad normal suele ser:
writable: true
enumerable: true
configurable: trueDespués de Object.freeze:
writable: false
enumerable: true
configurable: falseenumerable no cambia automáticamente.
const settings = Object.freeze({
theme: "dark",
});
settings.theme = "light";Fuera de modo estricto, la asignación puede fallar sin lanzar.
En modo estricto:
"use strict";
settings.theme = "light"; // TypeErrorLos módulos y las clases son estrictos automáticamente.
const configuration = Object.freeze({
database: {
host: "localhost",
},
});No puede reemplazarse database:
configuration.database = {};Pero el objeto interior no está congelado.
configuration.database.host = "production-db";Esto sí puede funcionar.
Object.isFrozen(configuration); // true
Object.isFrozen(configuration.database); // falseconst values = Object.freeze([1, 2, 3]);No puede cambiarse una posición ni la longitud.
values[0] = 10;
values.push(4);
values.pop();Los métodos mutables fallan o lanzan, especialmente en modo estricto.
Los elementos que son objetos continúan siendo mutables si no están congelados.
const products = Object.freeze([
{ name: "Keyboard" },
]);
products[0].name = "Mouse"; // Puede funcionar.let internalValue = 0;
const object = {
get value() {
return internalValue;
},
set value(nextValue) {
internalValue = nextValue;
},
};
Object.freeze(object);
object.value = 10;freeze hace no configurable el accessor, pero no elimina su setter. El setter puede continuar modificando estado externo.
Por eso un objeto congelado no garantiza que todas sus observaciones futuras sean idénticas.
class Counter {
#value = 0;
increment() {
this.#value++;
}
read() {
return this.#value;
}
}
const counter = Object.freeze(
new Counter(),
);
counter.increment();
counter.read(); // 1Los campos privados no son propiedades normales del objeto y no son congelados por Object.freeze.
Congelar la superficie pública no detiene necesariamente el estado interno de una clase.
const map = Object.freeze(
new Map(),
);
map.set("key", "value");Object.freeze restringe propiedades propias normales, pero no congela el contenido almacenado en los slots internos de Map o Set.
Lo mismo ocurre con:
const set = Object.freeze(new Set());
set.add("value");Para exponer una colección de solo lectura necesitas controlar su API, retornar copias o utilizar una abstracción que no permita mutación.
Puede crearse una función que recorra valores anidados.
function deepFreeze(value, visited = new WeakSet()) {
if (
value === null ||
(typeof value !== "object" &&
typeof value !== "function")
) {
return value;
}
if (visited.has(value)) {
return value;
}
visited.add(value);
for (const key of Reflect.ownKeys(value)) {
deepFreeze(value[key], visited);
}
return Object.freeze(value);
}WeakSet evita ciclos infinitos.
Sin embargo, esta función tampoco convierte automáticamente en inmutables:
Map y Set.“Deep freeze” debe definirse según los tipos reales del dominio.
Las funciones también son objetos.
function calculate() {}
Object.freeze(calculate);Esto restringe sus propiedades propias, pero no cambia el código de su cuerpo ni congela automáticamente los objetos que utiliza mediante closures.
const state = Object.seal({
status: "pending",
error: null,
});El conjunto de propiedades permanece estable, pero sus valores pueden actualizarse.
Puede ser útil cuando la estructura está definida y el estado necesita evolucionar.
Aun así, un schema o TypeScript comunican mejor la forma durante desarrollo. seal es una restricción en tiempo de ejecución.
const configuration = Object.freeze({
retryCount: 3,
timeout: 5000,
});Puede proteger una configuración plana contra mutaciones accidentales.
Para datos anidados:
const configuration = deepFreeze({
api: {
timeout: 5000,
},
});Solo úsalo cuando el costo y los tipos involucrados sean comprendidos.
freeze no:
Es una herramienta de integridad estructural, principalmente contra cambios accidentales.
Object.freeze(state);Restringe un objeto existente.
const nextState = {
...state,
status: "completed",
};Representa una transición mediante otro valor.
Puedes combinar ambas ideas, pero resuelven problemas distintos.
Congelar cada estado de una aplicación puede añadir costo. En muchos casos basta con no mutar referencias compartidas y utilizar herramientas de desarrollo que detecten errores.
| Operación | Agregar | Eliminar | Cambiar valor writable | Reconfigurar |
|---|---|---|---|---|
| Objeto normal | Sí | Sí | Sí | Sí |
| `preventExtensions` | No | Sí | Sí | Dentro de límites |
| `seal` | No | No | Sí | No |
| `freeze` | No | No | No | No |
function createPublicConfiguration(input) {
const configuration = {
environment: input.environment,
apiUrl: input.apiUrl,
features: {
reports: Boolean(
input.features?.reports,
),
},
};
return deepFreeze(configuration);
}La función construye una estructura conocida y evita que sus ramas normales cambien accidentalmente después.
freeze crea una copia.Map y Set dejan de aceptar entradas.seal con valores completamente inmutables.freeze como medida de seguridad.preventExtensions impide agregar propiedades.seal también impide eliminar o reconfigurar.freeze además vuelve no writable las propiedades de datos.Object.isExtensible, isSealed e isFrozen comprueban cada nivel.¿Qué cambio sigue siendo posible?
const configuration = Object.freeze({
api: {
timeout: 5000,
},
});Puede cambiarse configuration.api.timeout porque api es otro objeto y no fue congelado. No puede reemplazarse configuration.api en el objeto exterior congelado.
Factory functions muestra otra estrategia para crear objetos, validar datos, inyectar dependencias y encapsular estado mediante closures.