Różnica między zamrożeniem a uszczelnieniem

Właśnie usłyszałem o metodach JavaScript freezei seal, które można wykorzystać do uczynienia dowolnego obiektu niezmiennym.

Oto krótki przykład, jak go używać:

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

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

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

Jaka jest różnica między freezei seal? Czy mogą zwiększyć wydajność?

Object.seal

• Zapobiega dodawaniu i / lub usuwaniu właściwości z zapieczętowanego obiektu; użycie deletezwróci fałsz
• Sprawia, że żadna istniejąca właściwość nie jest konfigurowalna : nie można ich konwertować z `` deskryptorów danych '' na `` deskryptory akcesorów '' (i odwrotnie), a żaden atrybut deskryptorów akcesorów nie może być w ogóle modyfikowany (podczas gdy deskryptory danych mogą zmieniać swój writableatrybut, oraz ich valueatrybut, jeśli writeablejest prawdziwy).
• Może rzucić a TypeErrorpodczas próby zmodyfikowania wartości samego zapieczętowanego obiektu (najczęściej w trybie ścisłym )

Object.freeze

• Dokładnie to Object.seal, co robi, a ponadto:
• Zapobiega modyfikacji żadnych istniejących obiektów

Żaden z nich nie wpływa na obiekty „głębokie” / wnuki. Np. Jeśli objjest zamrożone, obj.elnie można go ponownie przypisać, ale wartość obj.elmożna zmodyfikować, np. obj.el.idMożna ją zmienić.

Występ:

Zapieczętowanie lub zamrożenie obiektu może wpłynąć na szybkość jego wyliczania w zależności od przeglądarki:

• Firefox: nie ma to wpływu na wydajność wyliczania
• IE: wpływ na wydajność wyliczenia jest znikomy
• Chrome: wydajność wyliczania jest szybsza w przypadku obiektów zamkniętych lub zamrożonych
• Safari: zamknięte lub zamrożone obiekty wyliczają 92% wolniej (od 2014 r.)

Testy: Sealed obiekty , zamrożone obiekty .

Napisałem projekt testowy, który porównuje te 3 metody:

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

Moje testy jednostkowe obejmują przypadki CRUD:

• [C] dodaj nową właściwość
• [R] odczyt istniała własność
• [U] zmodyfikuj istniejącą właściwość
• [D] usuń istniejącą właściwość

Wynik:

Zawsze możesz je sprawdzić w MDN. W skrócie:

• Freeze : sprawia, że ​​obiekt jest niezmienny, co oznacza, że ​​żadna zmiana zdefiniowanej właściwości nie jest dozwolona, ​​chyba że są to obiekty.
• Pieczęć : zapobiega dodawaniu właściwości, jednak zdefiniowane właściwości nadal można zmienić.

Object.freeze()tworzy zamrożony obiekt, co oznacza, że ​​pobiera istniejący obiekt i zasadniczo go wywołuje Object.seal(), ale także oznacza wszystkie właściwości „ elementu dostępu do danych” jako writable:false, aby nie można było zmienić ich wartości. - Kyle Simpson, You Don't Know JS - This & Object Prototypes

Patrzyłem na różnice między Freeze i Seal w ECMAScript 5 i stworzyłem skrypt, aby wyjaśnić różnice. Frozen tworzy niezmienny obiekt, w tym dane i strukturę. Pieczęć zapobiega zmianom w nazwanych interfejsach - nie dodaje, nie usuwa - ale możesz zmutować obiekt i przedefiniować znaczenie jego interfejsu.

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());
}

Wiem, że mogę się trochę spóźnić, ale

• Podobieństwo: oba są używane do tworzenia obiektów nierozszerzalnych .
• Różnica: W konfigurowalnych Freeze , wyliczalne i zapisywalne atrybuty obiektu są ustawione na false. gdzie jak w Sealed writable atrybut jest ustawiony na, truea pozostałe atrybuty są false.

Możesz teraz wymusić zamrożenie pojedynczej właściwości obiektu zamiast zamrażania całego obiektu. Można to osiągnąć z Object.definePropertyze writable: falsejako parametr.

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

W tym przykładzie obj.firstjego wartość jest teraz zablokowana na 99.

Stworzyłem prostą tabelę, aby porównać poniższe funkcje i wyjaśnić różnicę między tymi funkcjami.

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