supprimer a.x vs a.x = indéfini

Question

Y a-t-il une différence substantielle à faire l'un ou l'autre ?

delete a.x;

vs

a.x = undefined;

où

a = {
    x: 'boo'
};

peut-on dire qu'ils sont équivalents ?

(Je ne prends pas en compte des choses comme "V8 aime ne pas utiliser delete mieux" )

Answer 1

Ils ne sont pas équivalents. La principale différence est que le réglage

a.x = undefined

signifie que a.hasOwnProperty("x") retournera toujours vrai, et par conséquent, il apparaîtra toujours dans un fichier for in et dans Object.keys()

delete a.x

signifie que a.hasOwnProperty("x") retournera false

La façon dont ils sont identiques est que vous ne pouvez pas dire si une propriété existe en testant

if (a.x === undefined)

Ce que vous ne devriez pas faire si vous essayez de déterminer si une propriété existe, vous devriez toujours utiliser

// If you want inherited properties
if ('x' in a)

// If you don't want inherited properties
if (a.hasOwnProperty('x'))

Suivre la chaîne des prototypes (mentionné par zzzzBov ) Appel delete lui permettra de remonter la chaîne des prototypes, tandis que la valeur indéfinie ne permettra pas de rechercher la propriété dans les prototypes enchaînés. http://jsfiddle.net/NEEw4/1/

var obj = {x: "fromPrototype"};
var extended = Object.create(obj);
extended.x = "overriding";
console.log(extended.x); // overriding
extended.x  = undefined;
console.log(extended.x); // undefined
delete extended.x;
console.log(extended.x); // fromPrototype

Suppression des propriétés héritées Si la propriété que vous essayez de supprimer est héritée, delete ne l'affectera pas. C'est-à-dire, delete ne supprime que les propriétés de l'objet lui-même, pas les propriétés héritées.

var obj = {x: "fromPrototype"};
var extended = Object.create(obj);
delete extended.x;
console.log(extended.x); // Still fromPrototype

Par conséquent, si vous devez vous assurer que la valeur d'un objet sera indéfinie, delete ne fonctionnera pas lorsque la propriété est héritée, vous devrez la définir (remplacer) par undefined dans ce cas. À moins que l'endroit qui le vérifie utilise hasOwnProperty mais il n'est pas sûr de supposer que tous ceux qui le vérifient utiliseront la fonction hasOwnProperty

Answer 2

Pour paraphraser la question :

Sont delete a.x y a.x = undefined équivalent ?

Non.

La première supprime la clé de la variable, la seconde fixe la clé avec la valeur de undefined . Cela fait une différence lors de l'itération sur les propriétés des objets, et lorsque hasOwnProperty est utilisé.

a = {
    x: true
};
a.x = undefined;
a.hasOwnProperty('x'); //true
delete a.x;
a.hasOwnProperty('x'); //false

En outre, cela fera une différence significative lorsque la chaîne de prototypes est impliquée.

function Foo() {
    this.x = 'instance';
}
Foo.prototype = {
    x: 'prototype'
};
a = new Foo();
console.log(a.x); //'instance'

a.x = undefined;
console.log(a.x); //undefined

delete a.x;
console.log(a.x); //'prototype'

Answer 3

Si a.x est une fonction setter, a.x = undefined appellera la fonction alors que delete a.x ne fera pas appel à la fonction.

Answer 4

Les noms sont un peu confus. a.x = undefined met simplement la propriété à undefined mais la propriété est toujours là :

> var a = {x: 3};
> a.x = undefined;
> a.constructor.keys(a)
["x"]

delete le supprime effectivement :

> var a = {x: 3};
> delete a.x;
> a.constructor.keys(a)
[]

Answer 5

Oui, il y a une différence. Si vous utilisez delete a.x le x n'est plus une propriété de a, mais si vous utilisez a.x=undefined il s'agit d'une propriété mais sa valeur est indéfinie.