Object.freeze()

El método Object.freeze() congela un objeto: es decir, previene que nuevas propiedades sean agregadas; privene que las propiedades existentes sean eliminadas; y previene que las propiedades existentes, o su capacidad de enumeración, configuración, o escritura. de ser cambiadas. En escencia el objeto es hecho efectivamente inmutable. El método regresa el objeto congelado.

Sintáxis

Object.freeze(obj)

Parametros

obj

El objeto a congelar.

Descripción

Nada puede ser agregado o removido de las propiedades establecidas de un objeto congelado. Cualuier intento de hacerlo fallará, ya sea de manera silenciosa o arrojando una excepción TypeError (más comunmente, pero no exclusivamente, en strict mode).

Los valores no pueden ser cambiado por propiedades de datos. Propiedades de acceso (getters y setters) funcionan igual (y aún dan la ilusión de que estas cambiando el valor). Note que los valores que son objetos aún pueden ser modificados, a menos que esten congelados tambien.

Ejemplos

var obj = {
  prop: function() {},
  foo: 'bar'
};

// Nuevas propiedades pueden ser agregadas,
// propiedades existentes pueden cambiar o removerse
obj.foo = 'baz';
obj.lumpy = 'woof';
delete obj.prop;

// Ambos, el objeto pasado como argumento tanto como el que se regresa
// serán congelados
// Es innecesario salvar el objeto que es regresado en orden de congelar
// el original.
var o = Object.freeze(obj);

assert(Object.isFrozen(obj) === true);

// Ahora cualquier cambio fallará
obj.foo = 'quux'; // No hace nada de manera silenciosa
obj.quaxxor = 'the friendly duck'; // No agrega una nueva propiedad, de manera silenciosa

// ...y en modo estrico tal intento arrojará TypeErrors
function fail(){
  'use strict';
  obj.foo = 'sparky'; // arroja un TypeError
  delete obj.quaxxor; // arroja un TypeError
  obj.sparky = 'arf'; // arroja un TypeError
}

fail();

// Los intentos utilizando Object.defineProperty tambien arrojarán una excepción...
Object.defineProperty(obj, 'ohai', { value: 17 }); // arroja un TypeError
Object.defineProperty(obj, 'foo', { value: 'eit' }); // arroja un TypeError

El siguiente ejemplo muestra que los valores de objetos en un objeto congelado pueden ser mutados (la congelación es superficial).

obj1 = {
  internal: {}
};

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

obj1.internal.a // 'aValue'

// Para hacer obj completamente inmutable, congelamos cada objeto en obj.
// Para hacerlo, usamos esta función.
function deepFreeze(obj) {

  // Recuperamos el nombre de las propiedades en obj
  var propNames = Object.getOwnPropertyNames(obj);

  // Congelamos las propiedades antes de congelar a obj
  propNames.forEach(function(name) {
    var prop = obj[name];

    // Si la propiedad es un objeto, llamaremos a deepFreezze para que congele las propiedades de ese objeto
    if (typeof prop == 'object' && prop !== null && !Object.isFrozen(prop))
      deepFreeze(prop);
  });

  // congelamos a obj 
  return Object.freeze(obj);
}

obj2 = {
  internal: {}
};

deepFreeze(obj2);
obj2.internal.a = 'anotherValue';
obj2.internal.a; // undefined

Notas

En ES5, si el argumento pasado a este método no es un objeto (un primitivo), entonces causará un TypeError. En ES6, un argumento no-objeto será tratado como si fuera un objeto congelado cualquiera, simplemente lo regresa.

> Object.freeze(1)
TypeError: 1 is not an object // Código ES5

> Object.freeze(1)
1                             // Código ES6

Especificaciones

Compatibilidad de navegadores

Mira también

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