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

En utilisant un tableau, au lieu d'un objet, je peux montrer que delete utilise moins de mémoire de tas que undefined.

Par exemple, ce code ne se terminera pas :

let y = 1;
let ary = [];
console.log("Fatal Error Coming Soon");
while (y < 4294967295)
{
    ary.push(y);
    ary[y] = undefined;
    y += 1;
}
console(ary.length);

Il produit cette erreur :

FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory.

Donc, comme vous pouvez le voir undefined occupe en fait la mémoire du tas.

Cependant, si vous avez également delete l'élément ary (au lieu de le mettre simplement à la valeur undefined ), le code se terminera lentement :

let x = 1;
let ary = [];
console.log("This will take a while, but it will eventually finish successfully.");
while (x < 4294967295)
{
    ary.push(x);
    ary[x] = undefined;
    delete ary[x];
    x += 1;
}
console.log(`Success, array-length: ${ary.length}.`);

Ce sont des exemples extrêmes, mais ils montrent bien que delete que je n'ai vu personne mentionner nulle part.

Answer 2

Ce REPL de node devrait illustrer la différence.

> a={ x: 'foo' };
{ x: 'foo' }
> for (var i in a) { console.log(i); };
x
undefined
> a.x=undefined;
undefined
> for (var i in a) { console.log(i); };
x
undefined
> delete a.x;
true
> for (var i in a) { console.log(i); };
undefined

Answer 3

Je suis sûr que vous pouvez voir la différence entre var o1 = {p:undefined}; y var o2 = {}; .

Dans les deux cas, o.p sera undefined mais dans le premier cas, c'est parce que c'est le valeur et dans le second cas parce que il n'y a pas de valeur .

delete est l'opérateur qui vous permet de passer de o1 (ou un autre objet dont la valeur est attribuée à son p ) pour o2 de cette façon : delete o1.p; .

L'opération inverse se fait en assignant simplement une valeur ( undefined dans cet exemple mais cela pourrait être autre chose) à la propriété o1.p = undefined; .

Así que pas de ils ne sont pas équivalents.

---

delete o.p; sera

• retirer la propriété p de l'objet s'il en a un

• ne rien faire d'autre

o.p = undefined; sera

• ajouter une propriété p à l'objet s'il n'en a pas encore un et met sa valeur à undefined

• changer simplement la valeur de la propriété si l'objet la possède déjà

---

Du point de vue de la performance, delete est mauvais parce qu'il modifie la structure de l'objet (tout comme l'ajout d'une nouvelle propriété si vous ne l'avez pas initialisée dans le constructeur).

Alors qu'en fixant la valeur à undefined libère également le contenu mais sans obliger à modifier la structure.

Answer 4

L'objet est simplement une représentation arborescente, ce qui signifie qu'en mémoire, la racine pointe vers divers emplacements où sont stockées les clés de cet objet, et que cet emplacement pointe vers un autre emplacement où est stockée la valeur réelle de cette clé, ou vers des emplacements où sont stockées les clés enfants ou des emplacements où sont stockées les valeurs du tableau.

Lorsque vous supprimez une clé d'un objet à l'aide de delete, le lien entre cette clé et son objet parent est supprimé et les emplacements mémoire de la clé et de sa valeur sont libérés pour stocker d'autres informations.

Lorsque vous essayez de supprimer une clé en définissant undefined comme sa valeur, vous ne faites que définir sa valeur, et non supprimer cette clé. Cela signifie que l'emplacement mémoire de la clé est toujours lié à son objet parent et que la valeur de la clé est indéfinie.

Utiliser undefined au lieu d'utiliser le mot clé delete est une mauvaise pratique, car cela ne libère pas l'emplacement mémoire de cette clé.

Même si la clé n'est pas présente, et que vous la définissez comme indéfinie, alors cette clé sera créée avec une valeur. undefined .

par exemple

var a = {};
a.d = undefined;
console.log(a); // this will print { d: undefined }

delete ne peut pas être utilisé avec les propriétés héritées car ces propriétés ne font pas partie de l'objet enfant.