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

Exemple interactif

const Employee = {  firstname: "Maria",  lastname: "Sanchez",};console.log(Employee.firstname);// Expected output: "Maria"delete Employee.firstname;console.log(Employee.firstname);// Expected output: undefined

Syntaxe

delete expression;

oùexpression est évaluée comme une référence à une propriété :

delete objet.propriete;delete objet["propriete"];

Paramètres

objet

Le nom d'un objet ou une expression dont l'évaluation fournit un objet.

propriete

La propriété qu'on souhaite supprimer.

Valeur de retour

true pour tous les cas sauf lorsque la propriété est une propriétéproprenon-configurable auquel casfalse est renvoyé en mode non-strict.

Exceptions

Cet opérateur lève une exceptionTypeError enmode strict si la propriété est une propriété propre qui est non-configurable.

Description

Contrairement à ce qu'on pourrait penser, l'opérateurdelete n'a rien à voir avec une libération de mémoire directe. La gestion de la mémoire en JavaScript est réalisée de façon indirecte en tenant compte des références,voir cette page pour plus de détails.

L'opérateurdelete permet de retirer une propriété donnée d'un objet. Lorsque la suppression se déroule sans problème, l'opération renvoietrue, sinon c'est la valeurfalse qui est renvoyée. Voici quelques scénarios importants qui précisent ce comportement :

• Si la propriété qu'on souhaite supprimer n'existe pas,delete n'aura aucun effet et l'opération renverratrue

• Si une propriété du même nom existe sur la chaîne de prototypes, après la suppression, l'objet utilisera la propriété disponible sur la chaîne de prototypes. Autrement dit,delete n'a d'effet que sur les propriétés directement rattachées à un objet (les propriétés « propres »).

• Toute propriété déclarée avecvar ne peut pas être supprimée de la portée globale ou de la portée d'une fonction.

  • Aussi,delete ne pourra supprimer des fonctions de la portée globale (que ce soit une définition de fonction ou une expression de fonction).
  • Les fonctions qui font partie d'un objet (à l'exception de la portée globale) peuvent être supprimées avecdelete.

• Toute propriété déclarée aveclet ouconst ne peut être supprimée de la portée dans laquelle elles ont été créées.

• Les propriétés non-configurable ne peuvent pas être retirées. Cela inclut les propriétés des objets natifs commeMath,Array,Object et les propriétés qui sont créées comme non-configurable grâce à la méthodeObject.defineProperty().

Voici un fragment de code qui illustre certains cas :

var Employe = {  age: 28,  nom: "abc",  designation: "developpeur",};console.log(delete Employe.nom); // renvoie trueconsole.log(delete Employe.age); // renvoie true// Lorsqu'on souhaite supprimer une propriété// inexistante, on obtient trueconsole.log(delete Employe.salaire); // renvoie true

Les propriétés non-configurables

Lorsqu'une propriété est marquée comme non-configurable,delete n'aura aucun effet et l'opération renverrafalse. En mode strict, cela déclenchera une exceptionTypeError.

var Employe = {};Object.defineProperty(Employe, "nom", { configurable: false });console.log(delete Employe.nom); // renvoie false

var (oulet ouconst) crée des propriétés non-configurables qui ne peuvent pas être supprimées viadelete :

var autreNom = "XYZ";// On peut accéder à la description de cette// propriété globale grâce à :Object.getOwnPropertyDescriptor(window, "autreNom");/* Object {value: "XYZ",                  writable: true,                  enumerable: true,                  configurable: false}*/// On voit que "autreNom", ajouté avec var// est marquée comme "non-configurable"delete autreNom; // renvoie false

En mode strict, cela aurait déclenché une exception.

Mode strict ou non-strict ?

Lorsqu'on est en mode strict, sidelete est utilisé sur une référence directe à une variable, un argument de fonction ou un nom de fonction, il déclenchera une exceptionSyntaxError.

Toute variable définie avecvar est marquée comme non-configurable. Dans l'exemple qui suit,salaire est non-configurable et ne peut pas être supprimé. En mode non-strict, l'opérationdelete renverrafalse.

function Employe() {  delete salaire;  var salaire;}Employe();

Voyons comment ce code se comporte en mode strict : au lieu de renvoyer false, l'instruction lève une exceptionSyntaxError.

"use strict";function Employe() {  delete salaire; // SyntaxError  var salaire;}// De même, tout accès direct à une fonction// avec delete lèvera une SyntaxErrorfunction DemoFunction() {  //du code}delete DemoFunction; // SyntaxError

Exemples

// on crée la propriété adminName sur la portée globaleadminName = "xyz";// on crée la propriété empCount sur la portée globale// On utilise var, elle est donc non-configurablevar empCount = 43;EmployeeDetails = {  name: "xyz",  age: 5,  designation: "Developer",};// adminName est une propriété de la portée globale// qui peut être supprimée car configurable.delete adminName; // renvoie true// En revanche empCount n'est pas configurable// car c'est var qui a été utilisée.delete empCount; // renvoie false// delete peut être utilisé pour retirer des propriétés// d'objetsdelete EmployeeDetails.name; // renvoie true// Même lorsque la propriété n'existe pas,// l'opération renvoie "true"delete EmployeeDetails.salary; // renvoie true// delete n'a pas d'impact sur les propriétés// statiques nativesdelete Math.PI; // renvoie false// EmployeeDetails est une propriété de la portée globale// définie sans var, elle est donc configurabledelete EmployeeDetails; // renvoie truefunction f() {  var z = 44;  // delete n'a pas d'impact sur les noms  // des variables locales  delete z; // returns false}

delete et la chaîne de prototypes

Dans l'exemple qui suit, on supprime une propriété directement rattachée à un objet (une propriété « propre ») alors qu'une propriété du même nom existe sur la chaîne de prototypes :

function Toto() {  this.truc = 10;}Toto.prototype.truc = 42;var toto = new Toto();// L'instruction suivante renvoie true,// après avoir effectivement supprimé// la propriété de l'objet totodelete toto.truc;// toto.truc est toujours disponible car// elle est disponible sur la chaîne de// prototypesconsole.log(toto.truc);// Ici on supprime la propriété du prototypedelete Toto.prototype.truc;// On aura "undefined" dans la console// car l'objet n'hérite plus de cette propriété// qui a été suppriméeconsole.log(toto.truc);

Supprimer les éléments d'un tableau

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

Lorsqu'on utilisedelete pour retirer un élément du tableau, cet élément n'est plus dans le tableau. Dans l'exemple suivant, on retirearbres[3] grâce àdelete.

var arbres = ["cèdre", "pin", "chêne", "érable", "sapin"];delete arbres[3];if (3 in arbres) {  // Le code ici ne sera pas exécuté}

Si on veut conserver l'existence d'un élément du tableau avec une valeur indéfinie, on pourra affecter la valeurundefined à cet élément. Ainsi, contrairement à l'exemple précédent, en utilisantundefined,arbres[3] continue d'être présent :

var arbres = ["cèdre", "pin", "chêne", "érable", "sapin"];arbres[3] = undefined;if (3 in arbres) {  // Le code ici sera bien exécuté}

Si on souhaite plutôt retirer un élément du tableau en changeant le contenu du tableau, on pourra utiliser la méthodeArray.splice(). Dans l'exemple qui suit, la valeur actuelle dearbres[3] est retirée du tableau grâce àsplice() mais l'index suivant se décale et arbres[4] devient arbres[3] :

var arbres = ["cèdre", "pin", "chêne", "érable", "sapin"];if (3 in arbres) {  // Le code ici sera exécuté}arbres.splice(3, 1);console.log(arbres); // ["cèdre","pin","chêne","sapin"];if (3 in arbres) {  // Le code ici sera également exécuté}

Spécifications

Compatibilité des navigateurs

Voir aussi

• Une analyse dedelete par Kangax, en anglais
• Reflect.deleteProperty()
• Map.prototype.delete()