Jakie są przypadki użycia, kiedy `delete` jest bardzo użyteczny w JavaScript?

Question

Mamy tutaj kilka pytań, które omawiają usuwanie w bardziej abstrakcyjny sposób, ale szukam praktycznych przykładów, kiedy można użyć funkcji delete, zamiast robić coś takiego, jak ustawienie właściwości na wartość null lub niezdefiniowaną.

The delete operator deletes a property of an object.

Co to jest przypadek wyzwaniem gdzieś, że delete było najlepszym rozwiązaniem, w porównaniu do czegoś innego?

Answer 1

Object.defineProperty(Object.prototype, "Incognito", { 
    get: function() { return 42; }, 
    set: function() { }, 
    configurable: true 
}); 

console.log(({}).Incognito); // 42 
({}).Incognito = null; 
console.log(({}).Incognito); // 42 

// I DO NOT WANT INCOGNITO 
delete Object.prototype.Incognito 
console.log(({}).Incognito); // undefined 

Każda właściwość, która ma pusty setter (Bo ktoś myślał że był dobry pomysł) musi zostać usunięty, jeśli chcesz się go pozbyć.

var hash = { 
    "FALSE": undefined, 
    "TRUE": null 
} 

console.log("TRUE" in hash); // true 
console.log("FALSE" in hash); // true 
delete hash.FALSE; 
console.log("FALSE" in hash); // false 

Operator in zwraca true dla każdej nieruchomości, które istnieją bez względu na jego wartość. Jeśli chcesz, aby powrócił on false, musisz mieć tę właściwość pod numerem delete.

W obu tych przypadkach ustawienie go na null lub undefined nic nie robi (bo albo ma setter, że nic nie robi, albo to, jak działa operator in)

Answer 2

Podczas korzystania z obiektu jako hashmap można iteracyjne nad właściwości obiektu przy użyciu:

for (var key in obj) { 
    // ... 
} 

Jeśli niektóre właściwości, że obiekty zostały ustawione na null ich klucze byłyby zawarte tam. Używając delete możesz całkowicie usunąć swoje klucze.

Answer 3

Ustawianie właściwości obiektu, aby null lub undefined będzie nadal opuścić nieruchomość jako przeliczalna - jeśli masz zamiar zrobić for..in nad obiektem na każdym etapie oraz obecność nieruchomości jest znaczna, to jest, kiedy chcesz zamiast tego chcesz delete.

Na przykład, jeśli masz jeden konstruktor, który przyjmuje argumenty jako obiekt, który dziedziczy z innego konstruktora, który robi to samo, a obecność właściwości jest znacząca podczas wywoływania konstruktora nadrzędnego (na przykład w poniższym przykładzie, że ParentWidgets stosować swoje argumenty z for..in do generowania atrybutów HTML -a) byś chciał używać delete usunąć właściwości, które nie są istotne dla rodzica:

function ChildWidget(kwargs) { 
    kwargs = extend({ 
    childSpecific1: null, childSpecific2: 42 
    }, kwargs || {}) 
    this.childSpecific1 = kwargs.childSpecific1 
    this.childSpecific2 = kwargs.childSpecific2 
    delete kwargs.childSpecific1 
    delete kwargs.childSpecific2 
    ParentWidget.call(this, kwargs) 
} 
inherits(ChildWidget, ParentWidget) 

Answer 4

operator delete jest przydatna w resecie lub jasnego sposobu usuwania dane literalne obiektu związane z formularzami:

delete formmap["forms"] 

Jest również przydatny do usuwania obiektów przywiązane do państwa:

/* lights... */ 
if (node["alpha"+i].active) 
    { 
    // camera, action 
    node["beta"+i] = chi; 
    } 
else 
    { 
    /* cut! */ 
    delete node["beta"+i]; 
    node["omega"].state = false; 
    } 

Ponadto, jest to przydatna jako skrót dla inline opcjonalne właściwości obiektu:

var foo = {"bar": [], "drink": [], "tab": [] } 

// happy hour 
this.bar && (foo["bar"]).push(this.bar) || delete foo.bar; 
// open a tab 
this.drink && (foo["drink"]).push(this.drink) || delete foo.drink; 
// cheers 
this.tab && (foo["tab"]).push(this.tab) || delete foo.tab; 

Wreszcie, jest to przydatne jako sposób na rozróżnienie typów przy użyciu uprawnień do zapisu właściwości specyficznych dla typu w charakterze testu lakmusowego:

// Function 
!!foo.prototype === true && delete foo.length === false && delete foo[-1] === true 

// Object, Number, Infinity, or Boolean (probably Object) 
!!foo.prototype === false && delete foo.length === true && delete foo[-1] === true 

// Array 
!!foo.prototype === false && delete foo.length === false && delete foo[-1] === true 

// String 
!!foo.prototype === false && delete foo.length === false && delete foo[-1] === false 

// RegExp 
delete foo.source === false 

Referencje

• Adobe Flash Platform: delete statement

• JScript Reference: Delete Operator