Ejemplo de Object.freeze de Javascript

los Object.freeze() método congela un objeto. Ya no se puede cambiar un objeto congelado; La congelación de un objeto evita que se le agreguen nuevas propiedades, que se eliminen las propiedades existentes, evita cambiar la enumerabilidad, la configurabilidad o la capacidad de escritura de las propiedades existentes y evita que se modifiquen los valores de las propiedades existentes. Además, congelar un objeto también evita que se cambie su prototipo. freeze() devuelve el mismo objeto que se pasó.

Sintaxis

Object.freeze(obj)

Parámetros

obj

El objeto a congelar.

Valor devuelto

El objeto que se pasó a la función.

Descripción

No se puede agregar ni quitar nada del conjunto de propiedades de un objeto inmovilizado. Cualquier intento de hacerlo fracasará, ya sea en silencio o lanzando un TypeError excepción (más comúnmente, pero no exclusivamente, cuando está en modo estricto).

Para las propiedades de datos de un objeto congelado, los valores no se pueden cambiar, los valores se pueden escribir y configurar. attributes están configurados para false. Las propiedades de los accesos (captadores y definidores) funcionan igual (y aún dan la ilusión de que está cambiando el valor). Tenga en cuenta que los valores que son objetos aún se pueden modificar, a menos que también estén congelados. Como objeto, un array se puede congelar; después de hacerlo, sus elementos no se pueden alterar y no se pueden agregar o eliminar elementos de la array.

freeze() devuelve el mismo objeto que se pasó a la función. Eso no crear una copia congelada.

En ES5, si el argumento de este método no es un objeto (una primitiva), provocará una TypeError. En ES2015, un argumento que no sea de objeto se tratará como si fuera un objeto ordinario congelado y se devolverá.

> Object.freeze(1)
TypeError:1 is not an object // ES5 code> Object.freeze(1)1// ES2015 code

Un ArrayBufferView con elementos provocará una TypeError, ya que son vistas sobre la memoria y definitivamente causarán otros posibles problemas:

> Object.freeze(newUint8Array(0))// No elements
Uint8Array []> Object.freeze(newUint8Array(1))// Has elements
TypeError: Cannot freeze array buffer views with elements

> Object.freeze(newDataView(newArrayBuffer(32)))// No elements
DataView > Object.freeze(newFloat64Array(newArrayBuffer(64),63,0))// No elements
Float64Array []> Object.freeze(newFloat64Array(newArrayBuffer(64),32,2))// Has elements
TypeError: Cannot freeze array buffer views with elements

Tenga en cuenta que; como las tres propiedades estándar (buf.byteLength, buf.byteOffset y buf.buffer) son de solo lectura (al igual que los de un ArrayBuffer o SharedArrayBuffer), no hay razón para intentar congelar estas propiedades.

Comparación con Object.seal ()

Objetos sellados con Object.seal() pueden cambiar sus propiedades existentes. Propiedades existentes en objetos congelados con Object.freeze() se hacen inmutables.

Ejemplos de

Congelar objetos

const obj =prop(),
  foo:'bar';// Before freezing: new properties may be added,// and existing properties may be changed or removed
obj.foo ='baz';
obj.lumpy ='woof';delete obj.prop;// Freeze.const o = Object.freeze(obj);// The return value is just the same object we passed in.
o === obj;// true// The object has become frozen.
Object.isFrozen(obj);// === true// Now any changes will fail
obj.foo ='quux';// silently does nothing// silently doesn't add the property
obj.quaxxor ='the friendly duck';// In strict mode such attempts will throw TypeErrorsfunctionfail()'use strict';
  obj.foo ='sparky';// throws a TypeErrordelete obj.foo;// throws a TypeErrordelete obj.quaxxor;// returns true since attribute 'quaxxor' was never added
  obj.sparky ='arf';// throws a TypeErrorfail();// Attempted changes through Object.defineProperty;// both statements below throw a TypeError.
Object.defineProperty(obj,'ohai', value:17);
Object.defineProperty(obj,'foo', value:'eit');// It's also impossible to change the prototype// both statements below will throw a TypeError.
Object.setPrototypeOf(obj, x:20)
obj.__proto__ = x:20

Congelación de matrices

let a =[0];
Object.freeze(a);// The array cannot be modified now.

a[0]=1;// fails silently// In strict mode such attempt will throw a TypeErrorfunctionfail()"use strict"
  a[0]=1;fail();// Attempted to push
a.push(2);// throws a TypeError

El objeto que se congela es inmutable. Sin embargo, no es necesariamente constante. El siguiente ejemplo muestra que un objeto congelado no es constante (la congelación es poco profunda).

const obj1 =
  internal:;

Object.freeze(obj1);
obj1.internal.a ='aValue';

obj1.internal.a // 'aValue'

Para ser un objeto constante, todo el gráfico de referencia (referencias directas e indirectas a otros objetos) debe hacer referencia solo a objetos inmutables congelados. Se dice que el objeto que se congela es inmutable porque todo el objeto estado (valores y referencias a otros objetos) dentro de todo el objeto es fijo. Tenga en cuenta que las cadenas, los números y los valores booleanos son siempre inmutables y que las funciones y las matrices son objetos.

¿Qué es la “congelación superficial”?

El resultado de llamar Object.freeze(object) solo se aplica a las propiedades inmediatas de object sí mismo y evitará futuras operaciones de adición, remoción o reasignación de valor solamente sobre object. Si el valor de esas propiedades son objetos en sí mismos, esos objetos no se congelan y pueden ser el objetivo de operaciones de adición, remoción o reasignación de valor de propiedad.

const employee =
  name:"Mayank",
  designation:"Developer",
  address:
    street:"Rohini",
    city:"Delhi";

Object.freeze(employee);

employee.name ="Dummy";// fails silently in non-strict mode
employee.address.city ="Noida";// attributes of child object can be modified

console.log(employee.address.city)// Output: "Noida"

Para hacer que un objeto sea inmutable, congele de forma recursiva cada propiedad que sea de tipo objeto (congelación profunda). Utilice el patrón caso por caso según su diseño cuando sepa que el objeto no contiene ciclos en el gráfico de referencia; de lo contrario, se activará un bucle sin fin. Una mejora para deepFreeze() sería tener una función interna que reciba un argumento de ruta (por ejemplo, una matriz) para que pueda suprimir la llamada deepFreeze() recursivamente cuando un objeto está en proceso de hacerse inmutable. Aún corre el riesgo de congelar un objeto que no debería congelarse, como [window].

functiondeepFreeze(object)// Retrieve the property names defined on objectconst propNames = Object.getOwnPropertyNames(object);// Freeze properties before freezing selffor(const name of propNames)const value = object[name];if(value &&typeof value ==="object")deepFreeze(value);return Object.freeze(object);const obj2 =
  internal:
    a:null;deepFreeze(obj2);

obj2.internal.a ='anotherValue';// fails silently in non-strict mode
obj2.internal.a;// null

Especificaciones

Compatibilidad del navegador

Ver también

• Object.isFrozen()
• Object.preventExtensions()
• Object.isExtensible()
• Object.seal()
• Object.isSealed()