Derdelete Operator entfernt eine Eigenschaft aus einem Objekt. Wenn der Wert der Eigenschaft ein Objekt ist und es keine Verweise mehr auf dieses Objekt gibt, wird das Objekt, das von dieser Eigenschaft gehalten wird, schließlich automatisch freigegeben.

Probieren Sie es aus

const employee = {  firstName: "Maria",  lastName: "Sanchez",};console.log(employee.firstName);// Expected output: "Maria"delete employee.firstName;console.log(employee.firstName);// Expected output: undefined

Syntax

delete object.propertydelete object[property]

Parameter

object

Der Name eines Objekts oder ein Ausdruck, der zu einem Objekt ausgewertet wird.

property

Die zu löschende Eigenschaft.

Rückgabewert

true in allen Fällen, außer wenn die Eigenschaft eineeigenenicht-konfigurierbare Eigenschaft ist, in welchem Fallfalse im Nicht-Strikt-Modus zurückgegeben wird.

Ausnahmen

TypeError

Wird imStriktmodus geworfen, wenn die Eigenschaft eine eigene nicht-konfigurierbare Eigenschaft ist.

ReferenceError

Wird geworfen, wennobjectsuper ist.

Beschreibung

Derdelete Operator hat die gleichePriorität wie andere unäre Operatoren wietypeof. Daher akzeptiert er jeden Ausdruck, der von Operatoren höherer Priorität gebildet wird. Jedoch führen die folgenden Formen imStriktmodus zu frühen Syntaxfehlern:

delete identifier;delete object.#privateProperty;

DaKlassen automatisch im Striktmodus sind undprivate Elemente nur legal in Klassenkörpern referenziert werden können, bedeutet dies, dass private Elemente niemals gelöscht werden können. Währenddelete identifierfunktionieren kann, wennidentifier auf eine konfigurierbare Eigenschaft des globalen Objekts verweist, sollten Sie diese Form vermeiden und stattdessen mitglobalThis voranstellen.

Obwohl andere Ausdrücke akzeptiert werden, führen sie nicht zu sinnvollen Verhaltensweisen:

delete console.log(1);// Logs 1, returns true, but nothing deleted

Derdelete Operator entfernt eine gegebene Eigenschaft aus einem Objekt. Bei erfolgreichem Löschen wirdtrue zurückgegeben, andernfallsfalse. Anders als oft angenommen (vielleicht aufgrund anderer Programmiersprachen wiedelete in C++), hat derdelete Operatornichts mit der direkten Speicherfreigabe zu tun. Der Speicher wird indirekt durch das Aufbrechen von Verweisen verwaltet. Weitere Informationen finden Sie auf der Seite zumSpeichermanagement.

Es ist wichtig, die folgenden Szenarien zu berücksichtigen:

• Wenn die Eigenschaft, die Sie zu löschen versuchen, nicht existiert, hatdelete keine Auswirkung und gibttrue zurück.
• delete hat nur Auswirkung auf eigene Eigenschaften. Wenn eine Eigenschaft mit demselben Namen in der Prototypenkette des Objekts existiert, wird das Objekt nach der Löschung die Eigenschaft aus der Prototypenkette verwenden.
• Nicht-konfigurierbare Eigenschaften können nicht entfernt werden. Dazu gehören Eigenschaften eingebauter Objekte wieMath,Array,Object und Eigenschaften, die als nicht konfigurierbar mit Methoden wieObject.defineProperty() erstellt wurden.
• Das Löschen von Variablen, einschließlich Funktionsparametern, funktioniert nie.delete variable wird im Striktmodus einenSyntaxError werfen und im Nicht-Strikt-Modus keine Wirkung haben.
  • Jede mitvar deklarierte Variable kann nicht aus dem globalen oder einem Funktionsbereich gelöscht werden, da sie, obwohl sie möglicherweise an dasglobale Objekt angehängt sind, nicht konfigurierbar sind.
  • Jede mitlet oderconst deklarierte Variable kann nicht aus dem Bereich gelöscht werden, in dem sie definiert wurde, da sie nicht an ein Objekt gebunden sind.

Beispiele

Nutzung von delete

// Creates the property empCount on the global scope.// Since we are using var, this is marked as non-configurable.var empCount = 43;// Creates the property EmployeeDetails on the global scope.// Since it was defined without "var", it is marked configurable.EmployeeDetails = {  name: "xyz",  age: 5,  designation: "Developer",};// delete can be used to remove properties from objects.delete EmployeeDetails.name; // returns true// Even when the property does not exist, delete returns "true".delete EmployeeDetails.salary; // returns true// EmployeeDetails is a property of the global scope.delete EmployeeDetails; // returns true// On the contrary, empCount is not configurable// since var was used.delete empCount; // returns false// delete also does not affect built-in static properties// that are non-configurable.delete Math.PI; // returns falsefunction f() {  var z = 44;  // delete doesn't affect local variable names  delete z; // returns false}

delete und die Prototypenkette

Im folgenden Beispiel löschen wir eine eigene Eigenschaft eines Objekts, während eine Eigenschaft mit demselben Namen in der Prototypenkette verfügbar ist:

function Foo() {  this.bar = 10;}Foo.prototype.bar = 42;const foo = new Foo();// foo.bar is associated with the// own property.console.log(foo.bar); // 10// Delete the own property within the// foo object.delete foo.bar; // returns true// foo.bar is still available in the// prototype chain.console.log(foo.bar); // 42// Delete the property on the prototype.delete Foo.prototype.bar; // returns true// The "bar" property can no longer be// inherited from Foo since it has been// deleted.console.log(foo.bar); // undefined

Löschen von Array-Elementen

Wenn Sie ein Array-Element löschen, wird dielength des Arrays nicht beeinflusst. Dies gilt auch, wenn Sie das letzte Element des Arrays löschen.

Wenn derdelete Operator ein Array-Element entfernt, befindet sich dieses Element nicht mehr im Array. Im folgenden Beispiel wirdtrees[3] mitdelete entfernt.

const trees = ["redwood", "bay", "cedar", "oak", "maple"];delete trees[3];console.log(3 in trees); // false

Dies erzeugt eindünn besetztes Array mit einem leeren Slot. Wenn Sie möchten, dass ein Array-Element existiert, aber einen undefinierten Wert hat, verwenden Sie den Wertundefined anstelle desdelete Operators. Im folgenden Beispiel wirdtrees[3] der Wertundefined zugewiesen, aber das Array-Element existiert weiterhin:

const trees = ["redwood", "bay", "cedar", "oak", "maple"];trees[3] = undefined;console.log(3 in trees); // true

Wenn Sie stattdessen ein Array-Element durch Ändern des Inhalts des Arrays entfernen möchten, verwenden Sie die Methodesplice(). Im folgenden Beispiel wirdtrees[3] vollständig aus dem Array mitsplice() entfernt:

const trees = ["redwood", "bay", "cedar", "oak", "maple"];trees.splice(3, 1);console.log(trees); // ["redwood", "bay", "cedar", "maple"]

Löschen nicht-konfigurierbarer Eigenschaften

Wenn eine Eigenschaft als nicht konfigurierbar markiert ist, hatdelete keine Wirkung und gibtfalse zurück. Im Striktmodus wird dies einenTypeError auslösen.

const Employee = {};Object.defineProperty(Employee, "name", { configurable: false });console.log(delete Employee.name); // returns false

var erstellt nicht-konfigurierbare Eigenschaften, die nicht mit demdelete Operator gelöscht werden können:

// Since "nameOther" is added using with the// var keyword, it is marked as non-configurablevar nameOther = "XYZ";// We can access this global property using:Object.getOwnPropertyDescriptor(globalThis, "nameOther");// {//   value: "XYZ",//   writable: true,//   enumerable: true,//   configurable: false// }delete globalThis.nameOther; // return false

Im Striktmodus würde dies eine Ausnahme auslösen.

Löschen globaler Eigenschaften

Wenn eine globale Eigenschaft konfigurierbar ist (z. B. durch direkte Eigenschaftszuweisung), kann sie gelöscht werden, und nachfolgende Verweise darauf als globale Variablen werden einenReferenceError erzeugen.

globalThis.globalVar = 1;console.log(globalVar); // 1// In non-strict mode, you can use `delete globalVar` as welldelete globalThis.globalVar;console.log(globalVar); // ReferenceError: globalVar is not defined

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Reflect.deleteProperty()
• Map.prototype.delete()