Object.isFrozen()

Il metodo Object.isFrozen() determina se un oggetto è congelato.

Il codice sorgente per questo esempio interattivo si trova in una repository di GitHub. Se vuoi contribuire al progetto degli esempi interattivi, puoi clonare https://github.com/mdn/interactive-examples ed inviarci una pull request.

Object.isFrozen(obj)

obj

L'oggetto da controllare.

Un Boolean che indica se l'oggetto è congelato oppure no.

Un oggetto è congelato solo e soltanto se non è estensibile (en-US), tutte le sue proprietà sono non-configurabili, e tutte le sue proprietà "data" (che non sono proprietà "accessor", quindi non hanno componenti getter o setters) non sono sovrascrivibili.

// Un nuovo oggetto è estensibile, quindi non è congelato.
Object.isFrozen({}); // === false

// Un oggetto vuoto che non è estensibile
// è vacuamente congelato.
var vacuouslyFrozen = Object.preventExtensions({});
Object.isFrozen(vacuouslyFrozen); // === true

// Un nuovo oggetto con una sola proprietà è estensibile,
// quindi non è congelato.
var oneProp = { p: 42 };
Object.isFrozen(oneProp); // === false

// Prevenire le estensioni dell'oggetto, comunque non
// lo rende congelato, perché la proprietà è comunque
// configurabile(e sovrascrivibile).
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp); // === false

// ...ma poi cancellare quella proprietà, rende l'oggetto
// vacuamente congelato.
delete oneProp.p;
Object.isFrozen(oneProp); // === true

// Un oggetto non-estensibile con una proprietà non-sovrascrivibile,
// ma comunque configurabile, non è congelato.
var nonWritable = { e: 'plep' };
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, 'e', {
  writable: false
}); // rende non-sovrascrivibile
Object.isFrozen(nonWritable); // === false

// Cambiare quella proprietà in non-configurabile
// rende l'oggetto congelato.
Object.defineProperty(nonWritable, 'e', {
  configurable: false
}); // rende non-configurabile
Object.isFrozen(nonWritable); // === true

// Un oggetto non-estensibile con una proprietà non-configurabile
// ma comunque sovrascribile, non è congelato.
var nonConfigurable = { release: 'the kraken!' };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, 'release', {
  configurable: false
});
Object.isFrozen(nonConfigurable); // === false

// Cambiare quella proprietà in non-sovrascribile,
// allora rende l'oggetto congelato.
Object.defineProperty(nonConfigurable, 'release', {
  writable: false
});
Object.isFrozen(nonConfigurable); // === true

// Un oggetto non-estensibile con una configurabile
// proprietà "accessor", non è congelato.
var accessor = { get food() { return 'yum'; } };
Object.preventExtensions(accessor);
Object.isFrozen(accessor); // === false

// ...ma poi rendere quella proprietà non-configurabile
// congela l'oggetto.
Object.defineProperty(accessor, 'food', {
  configurable: false
});
Object.isFrozen(accessor); // === true

// Ma il metodo più veloce per congelare un oggetto,
// è utilizzare il metodo Object.freeze su di esso.
var frozen = { 1: 81 };
Object.isFrozen(frozen); // === false
Object.freeze(frozen);
Object.isFrozen(frozen); // === true

// Per definizione, un oggetto congelato non è estensibile.
Object.isExtensible(frozen); // === false

// E sempre per definizione, un oggetto congelato è anche sigillato.
Object.isSealed(frozen); // === true

In ES5, se l'argomento di questo metodo non è un'oggetto, allora verrà generato un TypeError. In ES2015, un argomento che non è un oggetto verrà trattato come se fosse un normale oggetto già congelato, e perciò verrà semplicemente ritornato true.

Object.isFrozen(1);
// TypeError: 1 non è un oggetto (codice in ES5)

Object.isFrozen(1);
// true                          (codice in ES2015)

• Object.freeze()
• Object.preventExtensions() (en-US)
• Object.isExtensible() (en-US)
• Object.seal()
• Object.isSealed()