Diferença entre congelar e vedar

Acabei de ouvir falar dos métodos JavaScript freezee seal, que podem ser usados ​​para tornar qualquer objeto imutável.

Aqui está um pequeno exemplo de como usá-lo:

var o1 = {}, o2 = {};
Object.freeze(o2);

o1["a"] = "worked";
o2["a"] = "worked";

alert(o1["a"]);   //prints "worked"
alert(o2["a"]);   //prints "undefined"

Qual é a diferença entre freezee seal? Eles podem aumentar o desempenho?

Object.seal

• Evita adicionar e / ou remover propriedades do objeto selado; usando deleteretornará falso
• Torna todas as propriedades existentes não configuráveis : elas não podem ser convertidas de 'descritores de dados' em 'descritores de acessadores' (e vice-versa), e nenhum atributo dos descritores de acessores pode ser modificado (enquanto os descritores de dados podem alterar seu writableatributo e seusvalue atributo se writeablefor verdadeiro).
• Pode lançar um TypeErrorao tentar modificar o valor do próprio objeto selado (geralmente no modo estrito )

Object.freeze

• O que exatamente Object.seal faz, mais:
• Impede modificar quaisquer propriedades existentes

Nenhum deles afeta objetos "profundos" / netos. Por exemplo, se objestá congelado, obj.elnão pode ser reatribuído, mas o valor de obj.elpode ser modificado, por exemplo, obj.el.idpode ser alterado.

Atuação:

Selar ou congelar um objeto pode afetar sua velocidade de enumeração, dependendo do navegador:

• Firefox: o desempenho da enumeração não é afetado
• IE: o impacto no desempenho da enumeração é insignificante
• Chrome: o desempenho da enumeração é mais rápido com objetos fechados ou congelados
• Safari: objetos selados ou congelados enumeram 92% mais lento (a partir de 2014)

Testes: Objetos selados , Objetos congelados .

Eu escrevi um projeto de teste que compara esses 3 métodos:

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

Meus testes de unidade abrangem casos CRUD:

• [C] adicione nova propriedade
• [R] propriedade existente de leitura
• [U] modificar propriedade existente
• [D] remover propriedade existente

Resultado:

Você sempre pode procurá-los no MDN. Em resumo:

• Congelar : torna o objeto imutável, o que significa que nenhuma alteração na propriedade definida é permitida, a menos que sejam objetos.
• Selo : evita a adição de propriedades, no entanto, as propriedades definidas ainda podem ser alteradas.

Object.freeze()cria um objeto congelado, o que significa que ele pega um objeto existente e essencialmente o chama Object.seal(), mas também marca todas as propriedades de "acessador de dados" como writable:false, para que seus valores não possam ser alterados. - Kyle Simpson, você não conhece JS - Este e protótipos de objetos

Eu estava olhando para as diferenças entre Freeze e Seal no ECMAScript 5 e criei um script para esclarecer as diferenças. Frozen cria um objeto imutável, incluindo dados e estrutura. O selo evita alterações nas interfaces nomeadas - sem acréscimos, exclusões - mas você pode alterar o objeto e redefinir o significado de sua interface.

function run()
{
    var myObject = function() 
    { 
        this.test = "testing"; 
    }

    //***************************SETUP****************************

    var frozenObj = new myObject();
    var sealedObj = new myObject();

    var allFrozen = Object.freeze(frozenObj);
    var allSealed = Object.seal(sealedObj);
    alert("frozenObj of myObject type now frozen - Property test= " + frozenObj.test);
    alert("sealedObj of myObject type now frozen - Property test= " + sealedObj.test);

    //***************************FROZEN****************************

    frozenObj.addedProperty = "added Property"; //ignores add
    alert("Frozen addedProperty= " + frozenObj.addedProperty);
    delete frozenObj.test; //ignores delete
    alert("Frozen so deleted property still exists= " + frozenObj.test);
    frozenObj.test = "Howdy"; //ignores update
    alert("Frozen ignores update to value= " + frozenObj.test);
    frozenObj.test = function() { return "function"; } //ignores
    alert("Frozen so ignores redefinition of value= " + frozenObj.test);

    alert("Is frozen " + Object.isFrozen(frozenObj));
    alert("Is sealed " + Object.isSealed(frozenObj));
    alert("Is extensible " + Object.isExtensible(frozenObj));

    alert("Cannot unfreeze");
    alert("result of freeze same as the original object: " + (frozenObj === allFrozen).toString());

    alert("Date.now = " + Date.now());

    //***************************SEALED****************************

    sealedObj.addedProperty = "added Property"; //ignores add
    alert("Sealed addedProperty= " + sealedObj.addedProperty);
    sealedObj.test = "Howdy"; //allows update
    alert("Sealed allows update to value unlike frozen= " + sealedObj.test);
    sealedObj.test = function() { return "function"; } //allows
    alert("Sealed allows redefinition of value unlike frozen= " + sealedObj.test);
    delete sealedObj.test; //ignores delete
    alert("Sealed so deleted property still exists= " + sealedObj.test);
    alert("Is frozen " + Object.isFrozen(sealedObj));
    alert("Is sealed " + Object.isSealed(sealedObj));
    alert("Is extensible " + Object.isExtensible(sealedObj));

    alert("Cannot unseal");
    alert("result of seal same as the original object: " + (sealedObj === allSealed).toString());

    alert("Date.now = " + Date.now());
}

Eu sei que posso me atrasar um pouco, mas

• Semelhança: os dois são usados ​​para criar objetos não extensíveis .
• Diferença: No Freeze configurável, atributos enumeráveis ​​e graváveis do objeto são definidos como false. onde, como no atributo gravável selado, é definido como truee o restante dos atributos é falso.

Agora você pode forçar uma propriedade de um único objeto a ser congelada em vez de congelar o objeto inteiro. Você pode conseguir isso com Object.definePropertywith writable: falsecomo um parâmetro.

var obj = {
    "first": 1,
    "second": 2,
    "third": 3
};
Object.defineProperty(obj, "first", {
    writable: false,
    value: 99
});

Neste exemplo, obj.firstagora seu valor está bloqueado para 99.

Criei uma tabela simples para comparar as funções abaixo e explicar a diferença entre essas funções.

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