L'oprateur delete

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 value comme une rfrence une proprit :

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

Paramtres

objet

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

propriete

La proprit qu'on souhaite supprimer.

Valeur de retour

true pour tous les cas sauf lorsque la proprit est une proprit propre non-configurable auquel cas false est renvoy en mode non-strict.

Exceptions

Cet oprateur lve une exception TypeError en mode strict si la proprit est une proprit propre qui est non-configurable.

Description

Contrairement ce qu'on pourrait penser, l'oprateur delete n'a rien voir avec une libration de mmoire directe. La gestion de la mmoire en JavaScript est ralise de faon indirecte en tenant compte des rfrences, voir cette page pour plus de dtails.

L'oprateur delete permet de retirer une proprit donne d'un objet. Lorsque la suppression se droule sans problme, l'opration renvoie true, sinon c'est la valeur false qui est renvoye. Voici quelques scnarios importants qui prcisent ce comportement :

• Si la proprit qu'on souhaite supprimer n'existe pas, delete n'aura aucun effet et l'opration renverra true

• Si une proprit du mme nom existe sur la chane de prototypes, aprs la suppression, l'objet utilisera la proprit disponible sur la chane de prototypes. Autrement dit, delete n'a d'effet que sur les proprits directement rattaches un objet (les proprits propres ).

• Toute proprit dclare avec var ne peut pas tre supprime de la porte globale ou de la porte d'une fonction.

  • Aussi, delete ne pourra supprimer des fonctions de la porte globale (que ce soit une dfinition de fonction ou une expression de fonction).
  • Les fonctions qui font partie d'un objet ( l'exception de la porte globale) peuvent tre supprimes avec delete.

• Toute proprit dclare avec let ou const ne peut tre supprime de la porte dans laquelle elles ont t cres.

• Les proprits non-configurable ne peuvent pas tre retires. Cela inclut les proprits des objets natifs comme Math, Array, Object et les proprits qui sont cres comme non-configurable grce la mthode Object.defineProperty().

Voici un fragment de code qui illustre certains cas :

var Employe = {
  age: 28,
  nom: "abc",
  designation: "developpeur",
};

console.log(delete Employe.nom); // renvoie true
console.log(delete Employe.age); // renvoie true

// Lorsqu'on souhaite supprimer une proprit
// inexistante, on obtient true
console.log(delete Employe.salaire); // renvoie true

Les proprits non-configurables

Lorsqu'une proprit est marque comme non-configurable, delete n'aura aucun effet et l'opration renverra false. En mode strict, cela dclenchera une exception TypeError.

var Employe = {};
Object.defineProperty(Employe, "nom", { configurable: false });

console.log(delete Employe.nom); // renvoie false

var (ou let ou const) cre des proprits non-configurables qui ne peuvent pas tre supprimes via delete :

var autreNom = "XYZ";

// On peut accder  la description de cette
// proprit globale grce  :
Object.getOwnPropertyDescriptor(window, "autreNom");

/* Object {value: "XYZ",
                  writable: true,
                  enumerable: true,
                  configurable: false}
*/

// On voit que "autreNom", ajout avec var
// est marque comme "non-configurable"

delete autreNom; // renvoie false

En mode strict, cela aurait dclench une exception.

Mode strict ou non-strict ?

Lorsqu'on est en mode strict, si delete est utilis sur une rfrence directe une variable, un argument de fonction ou un nom de fonction, il dclenchera une exception SyntaxError.

Toute variable dfinie avec var est marque comme non-configurable. Dans l'exemple qui suit, salaire est non-configurable et ne peut pas tre supprim. En mode non-strict, l'opration delete renverra false.

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

Employe();

Voyons comment ce code se comporte en mode strict : au lieu de renvoyer false, l'instruction lve une exception SyntaxError.

"use strict";

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

// De mme, tout accs direct  une fonction
// avec delete lvera une SyntaxError

function DemoFunction() {
  //du code
}

delete DemoFunction; // SyntaxError

Exemples

// on cre la proprit adminName sur la porte globale
adminName = "xyz";

// on cre la proprit empCount sur la porte globale
// On utilise var, elle est donc non-configurable
var empCount = 43;

EmployeeDetails = {
  name: "xyz",
  age: 5,
  designation: "Developer",
};

// adminName est une proprit de la porte globale
// qui peut tre supprime car configurable.
delete adminName; // renvoie true

// En revanche empCount n'est pas configurable
// car c'est var qui a t utilise.
delete empCount; // renvoie false

// delete peut tre utilis pour retirer des proprits
// d'objets
delete EmployeeDetails.name; // renvoie true

// Mme lorsque la proprit n'existe pas,
// l'opration renvoie "true"
delete EmployeeDetails.salary; // renvoie true

// delete n'a pas d'impact sur les proprits
// statiques natives
delete Math.PI; // renvoie false

// EmployeeDetails est une proprit de la porte globale
// dfinie sans var, elle est donc configurable
delete EmployeeDetails; // renvoie true

function f() {
  var z = 44;

  // delete n'a pas d'impact sur les noms
  // des variables locales
  delete z; // returns false
}

delete et la chane de prototypes

Dans l'exemple qui suit, on supprime une proprit directement rattache un objet (une proprit propre ) alors qu'une proprit du mme nom existe sur la chane de prototypes :

function Toto() {
  this.truc = 10;
}

Toto.prototype.truc = 42;

var toto = new Toto();

// L'instruction suivante renvoie true,
// aprs avoir effectivement supprim
// la proprit de l'objet toto
delete toto.truc;

// toto.truc est toujours disponible car
// elle est disponible sur la chane de
// prototypes
console.log(toto.truc);

// Ici on supprime la proprit du prototype
delete Toto.prototype.truc;

// On aura "undefined" dans la console
// car l'objet n'hrite plus de cette proprit
// qui a t supprime
console.log(toto.truc);

Supprimer les lments d'un tableau

Lorsqu'on supprime un lment d'un tableau, la longueur du tableau n'est pas modifie. Cela vaut galement lorsqu'on supprime le dernier lment du tableau.

Lorsqu'on utilise delete pour retirer un lment du tableau, cet lment n'est plus dans le tableau. Dans l'exemple suivant, on retire arbres[3] grce delete.

var arbres = ["cdre", "pin", "chne", "rable", "sapin"];
delete arbres[3];
if (3 in arbres) {
  // Le code ici ne sera pas excut
}

Si on veut conserver l'existence d'un lment du tableau avec une valeur indfinie, on pourra affecter la valeur undefined cet lment. Ainsi, contrairement l'exemple prcdent, en utilisant undefined, arbres[3] continue d'tre prsent :

var arbres = ["cdre", "pin", "chne", "rable", "sapin"];
arbres[3] = undefined;
if (3 in arbres) {
  // Le code ici sera bien excut
}

Si on souhaite plutt retirer un lment du tableau en changeant le contenu du tableau, on pourra utiliser la mthode Array.splice(). Dans l'exemple qui suit, la valeur actuelle de arbres[3] est retire du tableau grce splice() mais l'index suivant se dcale et arbres[4] devient arbres[3] :

var arbres = ["cdre", "pin", "chne", "rable", "sapin"];
if (3 in arbres) {
  // Le code ici sera excut
}
arbres.splice(3, 1);
console.log(arbres); // ["cdre","pin","chne","sapin"];
if (3 in arbres) {
  // Le code ici sera galement excut
}

Spcifications

Compatibilit des navigateurs

Voir aussi

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