L'opérateur delete

L'opérateur delete permet de retirer une propriété d'un objet.

Syntaxe

delete expression

où l'expression doit être évaluée en une référence vers une propriété, par exemple :

delete objet.propriété
delete objet['propriété']

Paramètres

objet
Le nom d'un objet, ou une expression étant évaluée en un objet.
propriété
La propriété qu'on souhaite supprimer.

Valeur de retour

En mode strict, une exception sera levée si la propriété est non-configurable (la valeur de retour sera false en mode non-strict). Dans tous les autres cas, l'opération renverra true.

Description

Contrairement à ce qu'on pourrait croire, l'opérateur delete n'a strictement rien à voir avec de la libération de mémoire directe (il ne libère la mémoire qu'indirectement, en supprimant des références). Voir la page sur la gestion de la mémoire en JavaScript pour plus d'informations sur ce sujet.

Si l'opération de delete est bien effectuée, la propriété sera retirée de l'objet. En revanche, si une propriété du même nom est présente sur la chaîne de prototypes de l'objet, l'objet héritera de cette propriété.

delete fonctionne uniquement pour les propriétés d'un objet. Il n'a aucun effet sur les variables ou les noms de fonctions.
Si on peut parfois les confondre avec des variables globales, les affectations qui ne définissent pas un objet particulier (ex : = 5) sont en fait des affectations de propriétés sur l'objet global.

delete ne peut pas retirer certaines propriétés des objets natifs (tels qu'Object, Array, Math etc.). En effet, à partir d'ECMAScript 5, certaines de leurs propriétés ont été définies comme non-configurables.

Si on essaie de supprimer une propriété qui n'existe pas, delete ne fera rien et renverra true.

Zone morte temporaire

La « zone morte temporaire » (ou « Temporal Dead Zone » (TDZ) en anglais), a été spécifiée par ECMAScript 6 et s'applique aux déclarations const, let et aussi à l'opérateur delete. Ainsi, le code suivant renverra une exception ReferenceError.

function toto() { 
  delete x;
  let x;
}

function truc() { 
  delete y; 
  const y; 
}

Exemples

x = 42;         // on crée une propriété x sur l'objet global
var y = 43;     // on déclare une nouvelle variable, y (non-configurable)
monObjet = {
  h: 4,
  k: 5
};

// x est une propriété de l'objet global, on peut la supprimer
delete x;       // renvoie true

// delete n'affecte pas les noms de variable 
//(y n'est pas configurable et ne peut être supprimée)
delete y;       // renvoie false 

// delete n'affecte pas certaines propriétés prédéfinies
delete Math.PI; // renvoie false 

// les propriétés définies par du code utilisateur peuvent être supprimées
delete monObjet.h; // renvoie true 

// monObjet est une propriété de l'objet global et n'est pas une variable
// on peut donc la supprimer
delete monObjet;   // renvoie true

function f() {
  var z = 44;
  
  // delete n'affecte pas les variables locales
  delete z; // renvoie false
}

Si l'objet hérite d'une propriété depuis son prototype et qu'il ne possède pas directement cette propriété, la propriété ne pourra pas être supprimée à partir de l'objet lui-même. En revanche, on pourra la supprimer en agissant directement sur le prototype.

function Toto(){}
Toto.prototype.truc = 42;
var toto = new Toto();

// renvoie true, mais n'a aucun effet
// car truc est une propriété héritée
delete toto.truc;           

// affiche 42, la propriété héritée est toujours présente
console.log(toto.truc);

// on supprime la propriété sur le prototype
delete Toto.prototype.truc; 

// affiche "undefined" car la propriété héritée n'existe plus
console.log(Toto.truc);           

Supprimer les éléments d'un tableau

Lorsqu'on supprimer un élément d'un tableau, la longueur du tableau n'est pas modifiée. Cela est également vrai lorsqu'on supprime le dernier élément du tableau.

Lorsqu'on utilise delete afin de retirer l'élément d'un tableau, cet élément ne fera plus partie du tableau. Ainsi, dans l'exemple suivant, arbres[3] est retiré grâce à delete.

var arbres = ["séquoia","laurier","cèdre","chêne","érable"];
delete arbres[3];
if (3 in arbres) {
    // ceci ne sera pas exécuté
}

Si on souhaite conserver l'élément mais ramener sa valeur à undefined, on affectera la valeur undefined à l'élément plutôt que d'utiliser l'opérateur delete. Dans l'exemple qui suit, arbres[3] reçoit la valeur undefined et l'élément du tableau continue d'exister :

var arbres = ["séquoia","laurier","cèdre","chêne","érable"];
arbres[3] = undefined;
if (3 in arbres) {
    // ceci sera exécuté
}

Spécifications

Spécification Statut Commentaires
ECMAScript 2017 Draft (ECMA-262)
La définition de 'The delete Operator' dans cette spécification.
Projet  
ECMAScript 2015 (6th Edition, ECMA-262)
La définition de 'delete' dans cette spécification.
Standard  
ECMAScript 5.1 (ECMA-262)
La définition de 'delete' dans cette spécification.
Standard  
ECMAScript 1st Edition (ECMA-262)
La définition de 'delete' dans cette spécification.
Standard Définition initiale, implémentée avec JavaScript 1.2.

Compatibilité des navigateurs

Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
Support simple (Oui) (Oui) (Oui) (Oui) (Oui)
Zone morte temporaire ? 36 (36) ? ? ?
Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Support simple (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)
Zone morte temporaire ? ? 36.0 (36) ? ? ?

Notes sur la compatibilité entre navigateurs

Bien qu'ECMAScript ne fixe pas d'ordre pour l'itération des propriétés d'un objet, il semblerait que la plupart des navigateurs se base sur l'ordre d'insertaion des propriétés (au moins pour les propriétés directement rattachées à l'objet). Cependant, avec Internet Explorer, lorsqu'on utilisee delete, on obtient parfois un comportement différent qui empêche d'utiliser les objets comme des tableaux associatifs ordonnés. En effet avec Internet Explorer, bien que la valeur de la propriété soit passée à undefined, si on ajoute après une autre propriété avec le même nom que l'ancienne, cette nouvelle propriété sera « placée » à l'ancienne position et non à la fin.

Aussi, si on souhaite simuler un tableau associatif ordonné pour les différents navigateurs, on utilisera deux tableaux séparés, un pour les clés et l'autre pour les valeurs (ou on construira un tableau d'objet avec une propriété d'ordre).

Voir aussi

Étiquettes et contributeurs liés au document

 Contributeurs à cette page : SphinxKnight, yasakura_, teoli, Jeremie, gregoiredavid, BenoitL
 Dernière mise à jour par : SphinxKnight,