Object.seal()

O método Object.seal() sela um Objeto, evitando que novas propriedades sejam adicionadas à ele e marcando todas as propriedades existentes como não configuráveis. Valores das propriedades atuais ainda podem ser alterados desde que essas propriedades sejam graváveis (writable).

Object.seal(obj)

obj

O Objeto que deve ser selado.

O Objeto sendo selado.

Por padrão, objetos são extensible (novas propriedades podem ser adicionadas à eles). Selar um objeto evita que novas propriedades sejam adicionadas e marca todas as propriedades existentes como não configuráveis. Isto tem o efeito de tornar as propriedades no objeto fixas e imutáveis. Tornando todas as propriedades não configuráveis também evita que as mesmas sejam convertidas de propriedades de dados para propriedades de acesso e vice-versa, mas não evita que os valores das propriedades de dados sejam alterados. A tentativa de deletar ou adicionar propriedades à um objeto selado, ou converter uma propriedade de dado para uma propriedade de acesso ou vice-versa, irá falhar, seja silenciosamente como jogando o erro TypeError (mais comumente, mas não exclusivamente, quando em modo rigoroso strict mode de código).

A cadeia de prototipação permanece intocada. Entretanto, a propriedade __proto__ é selada também.

Retorna a referência ao Objeto passado.

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

// Novas propriedades podem ser adicionadas, propriedades existentes podem ser alteradas ou removidas.
obj.foo = 'baz';
obj.lumpy = 'woof';
delete obj.prop;

var o = Object.seal(obj);

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

// Alterar o valor das propriedades em um objeto selado ainda funciona.
obj.foo = 'quux';

// Mas você não pode converter propriedades de dados em propriedades de acesso, e vice-versa.
Object.defineProperty(obj, 'foo', { get: function() { return 'g'; } }); // throws a TypeError

// Agora quaisquer mudanças, que não sejam aos valores da das propriedades, irão falhar.
obj.quaxxor = 'the friendly duck'; // silently doesn't add the property
delete obj.foo; // silently doesn't delete the property

// e em modo rigoroso (strict mode) tais tentativas irão jogar erros do tipo TypeErrors.
function fail() {
  'use strict';
  delete obj.foo; // throws a TypeError
  obj.sparky = 'arf'; // throws a TypeError
}
fail();

// Tentativas através do Object.defineProperty também irão falhar.
Object.defineProperty(obj, 'ohai', { value: 17 }); // lança um erro do tipo TypeError
Object.defineProperty(obj, 'foo', { value: 'eit' }); // altera o valor da propriedade existente

No ES5, se o argumento passado à este método não é um objeto (primitivo) , irá causar um erro TypeError. No ES6, qualquer argumento que não seja um objeto será tratado como se fosse um objeto ordinário selado e simplesmente irá retorná-lo

Object.seal(1);
// TypeError: 1 não é um Objeto (código ES5)

Object.seal(1);
// 1                             (código ES6)

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