Signatur
Beschreibung
Der delete-Operator entfernt eine Eigenschaft aus einem Objekt. Wenn der Wert der Eigenschaft ein Objekt ist und keine weiteren Referenzen auf dieses Objekt bestehen, wird das von dieser Eigenschaft gehaltene Objekt schließlich automatisch freigegeben.
Der delete-Operator hat dieselbe Präzedenz wie andere unäre Operatoren wie typeof. Daher akzeptiert er jeden Ausdruck, der aus Operatoren höherer Präzedenz gebildet wird. Die folgenden Formen führen jedoch im strict mode zu frühen Syntaxfehlern:
delete identifier;delete object.#privateProperty;
Da classes automatisch im strict mode sind und private elements nur innerhalb von Klassenkörpern legal referenziert werden können, bedeutet dies, dass private elements niemals gelöscht werden können. Obwohl delete identifier funktionieren kann, wenn identifier auf eine konfigurierbare Eigenschaft des globalen Objekts verweist, sollten Sie diese Form vermeiden und stattdessen globalThis voranstellen.
Andere Ausdrücke werden zwar akzeptiert, führen jedoch nicht zu sinnvollem Verhalten:
delete console.log(1); — Gibt 1 aus, liefert true zurück, es wird jedoch nichts gelöscht.
Der delete-Operator entfernt eine bestimmte Eigenschaft aus einem Objekt. Bei erfolgreichem Löschen wird true zurückgegeben, andernfalls false. Entgegen der weit verbreiteten Annahme (möglicherweise aufgrund anderer Programmiersprachen wie delete in C++) hat der delete-Operator nichts mit dem direkten Freigeben von Speicher zu tun. Die Speicherverwaltung erfolgt indirekt über das Auflösen von Referenzen.
Es ist wichtig, die folgenden Szenarien zu beachten:
- Wenn die Eigenschaft, die Sie zu löschen versuchen, nicht existiert, hat
deletekeine Auswirkung und gibttruezurück. deletewirkt sich nur auf eigene Eigenschaften aus. Wenn eine Eigenschaft mit demselben Namen in der prototype-Kette des Objekts existiert, verwendet das Objekt nach dem Löschen die Eigenschaft aus der prototype-Kette.- Nicht-konfigurierbare Eigenschaften können nicht entfernt werden. Dies umfasst Eigenschaften eingebauter Objekte wie
Math,Array,Objectsowie Eigenschaften, die mit Methoden wieObject.defineProperty()als nicht-konfigurierbar erstellt wurden. - Das Löschen von Variablen, einschließlich Funktionsparametern, funktioniert niemals.
delete variablewirft im strict mode einenSyntaxErrorund hat im non-strict mode keine Auswirkung.- Jede mit
vardeklarierte Variable kann nicht aus dem globalen Scope oder aus einem Funktions-Scope gelöscht werden, da sie zwar an das globale Objekt gebunden sein kann, jedoch nicht konfigurierbar ist. - Jede mit
letoderconstdeklarierte Variable kann nicht aus dem Scope gelöscht werden, in dem sie definiert wurde, da sie nicht an ein Objekt gebunden ist.
- Jede mit
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $object Pflicht | Object | — | Der Name eines Objekts oder ein Ausdruck, der zu einem Objekt ausgewertet wird. |
| $property Pflicht | string | symbol | — | Die zu löschende Eigenschaft. |
Rückgabewert
true in allen Fällen, außer wenn die Eigenschaft eine eigene nicht-konfigurierbare Eigenschaft ist; in diesem Fall wird im non-strict mode false zurückgegeben.Beispiele
delete verwenden
// 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 false
function f() {
var z = 44;
// delete doesn't affect local variable names
delete z; // returns false
}delete und die prototype-Kette
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); // undefinedArray-Elemente löschen
const trees = ["redwood", "bay", "cedar", "oak", "maple"];
delete trees[3];
console.log(3 in trees); // falseElement mit undefined-Wert erhalten
const trees = ["redwood", "bay", "cedar", "oak", "maple"];
trees[3] = undefined;
console.log(3 in trees); // trueElement mit splice() entfernen
const trees = ["redwood", "bay", "cedar", "oak", "maple"];
trees.splice(3, 1);
console.log(trees); // ["redwood", "bay", "cedar", "maple"]Nicht-konfigurierbare Eigenschaften löschen
const Employee = {};
Object.defineProperty(Employee, "name", { configurable: false });
console.log(delete Employee.name); // returns falsevar erzeugt nicht-konfigurierbare Eigenschaften
// Since "nameOther" is added using with the
// var keyword, it is marked as non-configurable
var 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 falseGlobale Eigenschaften löschen
globalThis.globalVar = 1;
console.log(globalVar); // 1
// In non-strict mode, you can use `delete globalVar` as well
delete globalThis.globalVar;
console.log(globalVar); // ReferenceError: globalVar is not defined// Wichtig · Fallstricke
delete-Operator, aber nur die oben genannten Formen führen zu sinnvollem Verhalten. — Im strict mode wird ein TypeError geworfen, wenn die Eigenschaft eine eigene nicht-konfigurierbare Eigenschaft ist. Ein ReferenceError wird geworfen, wenn object ein super ist.