Object.isFrozen()

El mètode Object.isFrozen() determina si un objecte està congelat.

Object.isFrozen(obj)

obj

L'objecte que es comprovarà si està congelat o no.

Un objecte està congelat si i només si no és extensible, cap de les seves propietats és configurable, i cap de les seves propietats de dades (és a dir, propietats que no són accessor amb components getter o setter) that is, properties which are not accessor properties with getter or setter components) es poden escriure (modificar el seu valor).

// Els objectes nous són extensibles, així que no estan congelats.
Object.isFrozen({}); // === false

// Un objecte buit que no és extensible està congelat ja que no te propietats que trenquin les restriccions.
var vacuouslyFrozen = Object.preventExtensions({});
Object.isFrozen(vacuouslyFrozen); // === true

// Un objecte nou amb una propietat és extensible, i per tant no està congelat.
var oneProp = { p: 42 };
Object.isFrozen(oneProp); // === false

// Fer-lo no extensible no el fa congelat,
// perquè la propietat encara és configurable (i permet l'escriptura).
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp); // === false

// ...però, un altre cop, si eliminem la propietat ens trobem amb un objecte buit congelat.
delete oneProp.p;
Object.isFrozen(oneProp); // === true

// Un objecte no extensible amb una propietat que no permeti l'escriptura però sí que es configurable no està congelat.
var nonWritable = { e: 'plep' };
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, 'e', { writable: false }); // fer que la propietat no permeti l'escriptura
Object.isFrozen(nonWritable); // === false

// Fer aquesta propietat no configurable fa que l'objecte estigui congelat
Object.defineProperty(nonWritable, 'e', { configurable: false }); // fer la propietat no configurable
Object.isFrozen(nonWritable); // === true

// Un objecte no extensible amb una propietat no configurable però que si permeti l'escriptura tampoc està congelat.
var nonConfigurable = { release: 'the kraken!' };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, 'release', { configurable: false });
Object.isFrozen(nonConfigurable); // === false

// Canviar aquesta propietat per a que no permeti l'escriptura fa que l'objecte estigui congelat.
Object.defineProperty(nonConfigurable, 'release', { writable: false });
Object.isFrozen(nonConfigurable); // === true

// Un objecte amb una propietat accessor no extensible no està congelat.
var accessor = { get food() { return 'yum'; } };
Object.preventExtensions(accessor);
Object.isFrozen(accessor); // === false

// ...però si la propietat es fa no configurable l'objecte esdevé congelat.
Object.defineProperty(accessor, 'food', { configurable: false });
Object.isFrozen(accessor); // === true

// La forma més fàcil, però, d'aconseguir congelar un objecte és cridant el mètode Object.freeze al mateix objecte.
var frozen = { 1: 81 };
Object.isFrozen(frozen); // === false
Object.freeze(frozen);
Object.isFrozen(frozen); // === true

// Per definició, un objecte congelat no és extensible.
Object.isExtensible(frozen); // === false

// També per definició, un objecte congelat està segellat.
Object.isSealed(frozen); // === true

A l'EcmaScript 5, si l'argument passat a aquest mètode no és un objecte (un valor primitiu), llençarà un TypeError. A l'EcmaScript 6, un argument que no sigui un objecte serà tractat com si fós un objecte congelat ordinari, i simplement el retornarà.

Object.isFrozen(1);
// TypeError: 1 no és un objecte (codi EcmaScript 5)

Object.isFrozen(1);
// true                          (codi EcmaScript 6)

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