Quali sono alcuni casi d'uso di quando `delete` è stato molto utile in JavaScript?

Question

Abbiamo alcune domande qui che discutono dell'eliminazione in un modo più astratto, ma sto cercando esempi pratici di quando l'uso di delete potrebbe essere usato, rispetto a fare qualcosa come l'impostazione della proprietà a null o indefinito.

The delete operator deletes a property of an object.

che cosa è un caso di una sfida di fronte da qualche parte, che delete fosse la soluzione migliore, rispetto a qualcosa d'altro?

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 

Qualsiasi proprietà che ha un setter vuota (Perché qualcuno ha pensato che fosse una buona idea) deve essere cancellato se si vuole sbarazzarsi di esso.

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 

L'operatore in restituisce true per qualsiasi proprietà che esiste non importa il suo valore. Se si desidera restituire false è necessario delete la proprietà.

In entrambi i casi, impostandolo a null o undefined non fa nulla (perché esso sia ha un setter che non fa nulla, o che come funziona l'operatore in)

Answer 2

Quando si utilizza un oggetto come HashMap, è possibile iterare sopra le proprietà dell'oggetto utilizzando:

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

Se alcune proprietà che gli oggetti sono stati fissati per null, le chiavi sarebbero inclusi lì. Utilizzando delete è possibile rimuovere completamente le chiavi.

Answer 3

impostazione proprietà di un oggetto per null o undefined sarà ancora lasciare la proprietà come enumerabile - se si sta andando a fare un for..in sopra l'oggetto in qualsiasi momento e la presenza di una proprietà è significativo, questo è quando si aveva desidera invece delete.

Ad esempio, se si dispone di un costruttore che accetta argomenti come oggetto, che eredita da un altro costruttore che fa lo stesso e la presenza di una proprietà è significativa quando chiama il costruttore genitore (ad esempio, nell'esempio seguente, ParentWidgets usato i suoi argomenti con un for..in per generare gli attributi HTML) che si desidera utilizzare delete per rimuovere le proprietà che non sono rilevanti al genitore:

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

l'operatore delete è utile in un reset o metodo chiaro per la rimozione dati letterali dell'oggetto legati ai moduli:

delete formmap["forms"] 

Esso è anche utile per eliminare oggetti legati allo stato:

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

Inoltre, è utile come abbreviazione di inlining proprietà dell'oggetto opzionali:

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; 

Infine, è utile come modo per distinguere tra tipi utilizzando le autorizzazioni scrivibili delle proprietà dell'istanza di tipo specifico come prova del tornasole:

// 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 

Riferimenti

• Adobe Flash Platform: delete statement

• JScript Reference: Delete Operator