Object.seal()

Il metodo Object.seal() "sigilla" un oggetto, e ciò rende impossibile l'aggiunta di nuove proprietà e rende tutte le proprietà esistenti non-configurabili. I valori delle proprietà presenti possono comunque essere cambiati, finché sono sovrascrivibili.

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.seal(obj)

obj

L'oggetto da sigillare.

L'oggetto sigillato.

Di default, gli oggetti sono estensibili (possono essergli aggiunte nuove proprietà). Sigillare un oggetto rende impossibile l'aggiunta di nuove proprietà e rende tutte le proprietà esistenti non-configurabili. Questo rende le proprietà dell'oggetto statiche ed immutabili. Rendere tutte le proprietà non-configurabili, inoltre, rende impossibile la conversione da proprietà "data" a proprietà "accessor" e viceversa, ma non rende impossibile la modifica dei valori delle proprietà "data". Qualsiasi tentativo di aggiungere o rimuovere proprietà ad un oggetto sigillato, o convertire una proprietà "data" in una proprietà "accessor" o viceversa, fallirebbe, o in modo silenzioso o  attraverso il ritorno di un TypeError (più frequentemente, ma non necessariamente, quest'ultimo scenario accadrebbe in strict mode).

Le catene di prototipi non vengono sigillate. Invece, la proprietà __proto__ viene sigillata.

Ritorna l'oggetto passato ma sigillato.

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

// Nuove proprietà potrebbero essere aggiunte, proprietà esistenti
// potrebbero essere modificate o rimosse.
obj.foo = 'baz';
obj.lumpy = 'woof';
delete obj.prop;

var o = Object.seal(obj);

o === obj; // true
Object.isSealed(obj); // === true

// Cambiare proprietà su un oggetto sigillato
// è ancora possibile.
obj.foo = 'quux';

// Ma non puoi convertire proprietà "data" in proprietà "accessor"
// o viceversa.
Object.defineProperty(obj, 'foo', {
  get: function() { return 'g'; }
}); // genera un TypeError

// Ora, qualunque cambiamento, eccetto i valori delle proprietà,
// fallirà.
obj.quaxxor = 'the friendly duck';
// silenziosamente non aggiunge la proprietà, per cui non genera errori od eccezioni
delete obj.foo;
// silenziosamente non rimuove la proprietà, per cui non genera errori od eccezioni

// ...ed in strict mode, aggiungere o rimuovere proprietà
// genererà TypeErrors.
function fail() {
  'use strict';
  delete obj.foo; // genera un TypeError
  obj.sparky = 'arf'; // genera un TypeError
}
fail();

// Anche aggiungere proprietà tramite
// Object.defineProperty genererà l'errore.
Object.defineProperty(obj, 'ohai', {
  value: 17
}); // genera un TypeError
Object.defineProperty(obj, 'foo', {
  value: 'eit'
}); // modifica il valore di una proprietà esistente

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à sigillato, e verrà perciò semplicemente ritornato.

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

Object.seal(1);
// 1                             (codice in ES2015)

Le proprietà esistenti in oggetti congelati con Object.freeze() sono rese immutabili. Gli oggetti sigillati con Object.seal() possono ricevere modifiche alle proprietà esistenti.

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