¿Cuáles son algunos casos de uso de cuando `delete` ha sido muy útil en JavaScript?

Question

Tenemos algunas preguntas aquí que discuten borrar de una manera más abstracta, pero estoy buscando ejemplos prácticos de cuándo podría usarse el uso de delete, en lugar de hacer algo como establecer la propiedad como nula o indefinida.

The delete operator deletes a property of an object.

¿Qué es un caso de un desafío enfrentado en alguna parte, que delete era la mejor solución, frente a algo más?

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 

Cualquier propiedad que tiene un colocador vacío (porque alguien pensó que era una buena idea) necesita ser eliminada si quiere deshacerse de él.

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 

El operador devuelve intrue para cualquier propiedad que existe independientemente de su valor. Si desea que devuelva false, necesita delete la propiedad.

En ambos casos, estableciéndolo en null o undefined no hace nada (Debido a que o bien tiene un colocador que no hace nada, o así es como funciona el operador in)

Answer 2

Cuando se utiliza un objeto como un mapa hash, se puede repetir sobre las propiedades del objeto usando:

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

Si algunas propiedades de los objetos que se establecieron para null, sus claves serían incluidos allí. Al usar delete puede eliminar sus llaves por completo.

Answer 3

Configuración de la propiedad de un objeto a null o undefined se siguen dejando la propiedad como enumerable - si vas a hacer un for..in sobre el objeto en cualquier etapa y la presencia de una propiedad es significativa, esto es cuando se había quiere delete en su lugar.

Por ejemplo, si tiene un constructor que toma argumentos como un objeto, que hereda de otro constructor que hace lo mismo y la presencia de una propiedad es significativa cuando llama al constructor padre (por ejemplo, en el ejemplo siguiente, ParentWidgets utilizan sus argumentos con una for..in para generar atributos HTML) que se desea utilizar para eliminar delete propiedades que no son relevantes para los padres:

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

el operador delete es útil en un reinicio o un método claro para la eliminación datos literales del objeto atados a las formas:

delete formmap["forms"] 

También es útil para eliminar objetos vinculados a estado:

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

Además, es útil como una abreviatura para inlining propiedades de objetos opcionales:

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; 

Por último, es útil como una forma de distinguir entre tipos utilizando los permisos de escritura de las propiedades de instancia específicas del tipo como una prueba de fuego:

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

Referencias

• Adobe Flash Platform: delete statement

• JScript Reference: Delete Operator