delete

object

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

property

Die zu löschende Eigenschaft.

true in allen Fällen, außer wenn die Eigenschaft eine own non-configurable Eigenschaft ist, in diesem Fall wird im nicht-strikten Modus false zurückgegeben.

TypeError

Wird im strict mode ausgelöst, wenn die Eigenschaft eine eigene nicht-konfigurierbare Eigenschaft ist.

ReferenceError

Wird ausgelöst, wenn object super ist.

Der delete-Operator hat die gleiche Präzedenz wie andere unäre Operatoren wie typeof. Daher akzeptiert er jeden Ausdruck, der durch Operatoren höherer Präzedenz gebildet wird. Die folgenden Formen führen jedoch zu frühen Syntaxfehlern im strict mode:

delete identifier;
delete object.#privateProperty;

Da Klassen automatisch im strict mode sind und private Eigenschaften nur legal in Klassenkörpern referenziert werden können, bedeutet dies, dass private Eigenschaften niemals gelöscht werden können. Während delete identifier funktionieren könnte, wenn identifier sich auf eine konfigurierbare Eigenschaft des globalen Objekts bezieht, sollten Sie diese Form vermeiden und stattdessen mit globalThis voranstellen.

Während andere Ausdrücke akzeptiert werden, führen sie nicht zu sinnvollen Verhaltensweisen:

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

Der delete-Operator entfernt eine gegebene Eigenschaft aus einem Objekt. Bei erfolgreicher Löschung wird true zurückgegeben, andernfalls wird false zurückgegeben. Entgegen der allgemeinen Annahme (vielleicht aufgrund anderer Programmiersprachen wie delete in C++) hat der delete-Operator nichts mit dem direkten Freigeben von Speicher zu tun. Das Speichermanagement erfolgt indirekt durch Aufbrechen von Verweisen. Weitere Einzelheiten finden Sie auf der Seite memory management.

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

• Wenn die zu löschende Eigenschaft nicht existiert, hat delete keine Wirkung und wird true zurückgeben.
• delete hat nur Auswirkungen auf eigene Eigenschaften. Wenn eine Eigenschaft mit demselben Namen in der Prototypenkette des Objekts existiert, wird nach der Löschung die Eigenschaft aus der Prototypenkette verwendet.
• Nicht-konfigurierbare Eigenschaften können nicht entfernt werden. Dies schließt Eigenschaften von eingebauten Objekten wie Math, Array, Object und Eigenschaften ein, die als nicht-konfigurierbar mit Methoden wie Object.defineProperty() erstellt wurden.
• Das Löschen von Variablen, einschließlich Funktionsparametern, funktioniert niemals. delete variable wird im strict mode einen SyntaxError auslösen und hat im nicht-strikten Modus keine Wirkung.
  • Jede mit var deklarierte Variable kann nicht aus dem globalen Scope oder aus dem Scope einer Funktion gelöscht werden, da sie zwar am global object angehängt sein kann, aber nicht konfigurierbar ist.
  • Jede mit let oder const deklarierte Variable kann nicht aus dem Scope gelöscht werden, in dem sie definiert wurde, da sie nicht an ein Objekt geheftet sind.

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

Wenn Sie ein Array-Element löschen, wird die length des Arrays nicht beeinträchtigt. Dies gilt auch, wenn Sie das letzte Element des Arrays löschen.

Wenn der delete-Operator ein Array-Element entfernt, ist dieses Element nicht mehr im Array. Im folgenden Beispiel wird trees[3] mit delete entfernt.

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

Dies erzeugt ein sparse array mit einem leeren Slot. Wenn Sie möchten, dass ein Array-Element existiert, aber einen undefinierten Wert hat, verwenden Sie den Wert undefined anstelle des delete-Operators. Im folgenden Beispiel wird trees[3] der Wert undefined 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 Array-Inhalts entfernen möchten, verwenden Sie die Methode splice(). Im folgenden Beispiel wird trees[3] vollständig aus dem Array entfernt, indem der splice() verwendet wird:

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

Wenn eine Eigenschaft als nicht-konfigurierbar markiert ist, hat delete keine Wirkung und wird false zurückgeben. Im strict mode führt dies zu einem TypeError.

const Employee = {};
Object.defineProperty(Employee, "name", { configurable: false });

console.log(delete Employee.name); // returns false

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

// 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 false

Im strict mode würde dies eine Ausnahme auslösen.

Wenn eine globale Eigenschaft konfigurierbar ist (zum Beispiel durch direkte Eigenschaften-Zuweisung), kann sie gelöscht werden, und nachfolgende Verweise auf sie als globale Variablen werden einen ReferenceError erzeugen.

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

• Detaillierte Analyse zu delete
• Reflect.deleteProperty()
• Map.prototype.delete()