delete Operator

Der JavaScript delete-Operator entfernt eine Eigenschaft eines Objekts. Wenn keine weitere Referenz auf dieselbe Eigenschaft mehr existiert, wird diese automatisch freigegeben.

Syntax

delete Ausdruck 

wobei Ausdruck zu eine Referenz auf eine Eigenschaft ausgewertet werden sollte, z. B.:

delete object.property
delete 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 f├╝r alle F├Ąlle, au├čer wenn die Eigenschaft eine eigene nicht konfigurierbare Eigenschaft ist, in diesem Fall wird im nicht strict Modus false zur├╝ckgegeben.

Fehler

Erzeugt einen Global_objects/SyntaxError im strict Modus, wenn die Eigenschaft eine eigene nicht konfigurierbare Eigenschaft ist.

Beschreibung

Anders als es allgemein ├╝blich ist, hat der delete Operator nichts mit dem Freigeben von Speichers zu tun. Speicherverwaltung wird indirekt ├╝ber fehlende Referenzen gemacht, dazu mehr Details auf der Seite Speicherverwaltung.

Der delete Operator entfernt eigene gegebene Eigenschaft von einem Objekt. Ist dieses Erfolgreich, wird true zur├╝ckgegeben, andernfalls false. Jedoch ist es wichtig die folgenden Szenarien zu bedenken:

  • Wenn die Eigenschaft, die gel├Âscht werden soll, nicht existiert, hat delete keinen Effekt und wird true zur├╝ckgeben.
  • Wenn eine Eigenschaft mit dem selben Namen in der Prototypenkette existiert, wird nach dem L├Âschen diese Eigenschaft aus der Prototypenkette weiter benutzt (in anderen Worten, delete hat nur auf eigenen Eigenschaften einen Effekt).
  • Jede Eigenschaft, die mit var deklariert wurde, kann nicht vom globalen oder Funktionsg├╝ltigkeitsbereich gel├Âscht werden.
    • delete kann keine Funktion im globalen G├╝ltigkeitsbereich l├Âschen (egal ob diese Teil einer Funktionsdeklaration oder eines Funktionsausdrucks ist).
    • Funktionen die Teil eines Objektes sind (au├čer dem globalen Objekt) k├Ânnen mit delete gel├Âscht werden.
  • Jede Eigenschaft, die mit let oder const deklariert wurde, kann nicht vom G├╝ltigkeitsbereich, indem diese definiert wurde, gel├Âscht werden.
  • Nicht konfigurierbare Eigenschaften k├Ânnen nicht gel├Âscht werden. Eingenommen sind Eigenschaften von Standardobjekten wie Math, Array, Object und Eigenschaften die mit Methoden wie Object.defineProperty() als nicht konfigurierbar erstellt wurden.

Der folgende Ausschnitt enth├Ąlt ein einfaches Beispiel:

var Employee = {
  age: 28,
  name: 'abc',
  designation: 'developer'
}

console.log(delete Employee.name);  // gibt true zur├╝ck
console.log(delete Employee.age);   // gibt true zur├╝ck

// Wenn versucht wird eine Eigenschaft zu l├Âschen,
// die nicht existiert, wird true zur├╝ckgegeben
console.log(delete Employee.salery) // gibt true zur├╝ck

Nicht konfigurierbare Eigenschaften

Wenn eine Eigenschaft als nicht konfigurierbar markiert ist, hat delete keinen Effekt und wird false zur├╝ckgeben. Im strict Modus wird es zu einem SyntaxError kommen.

var Employee = {};
Object.defineProperty(Employee, 'name', {configurable: false});

console.log(delete Employee.name);  // gibt false zur├╝ck

var, let und const erstellen nicht konfigurierbare Eigenschaften, die nicht mit dem delete Operator gel├Âscht werden k├Ânnen.

var nameOther = 'XYZ';

// Man kann die globale Eigenschaft mit folgenden erreichen:
Object.getOwnPropertyDescriptor(window, 'nameOther');

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

// Wenn "nameOther" mit dem Schl├╝sselwort var hinzugef├╝gt
// wird, ist sie als nicht konfigurierbar markiert

delete nameOther;   // gibt false zur├╝ck

Im strict Modus wird diese zu einem Fehler f├╝hren.

Strict vs. nicht strict Modus

Wenn im strict Mode delete direkt auf einer Referenz einer Variablen, eines Funktionsargumentes oder eines Funktionsnamens genutzt wird, wird ein SyntaxError erzeugt.

Jede Variable, die mit var definiert wird, wird als nicht konfigurierbar markiert. Im folgenden Beispiel ist salary nicht konfigurierbar und kann nicht gel├Âscht werden. Im nicht strict Modus wird der delete Operator false zur├╝ckgeben.

function Employee() {
  delete salary;
  var salary;
}

Employee();

Mal sehen, wie sich der selbe Code im strict Modus verh├Ąlt. Statt dem Zur├╝ckgeben von false, wird das Statement zu einem SyntaxError f├╝hren.

"use strict";

function Employee() {
  delete salary;  // SyntaxError
  var salary;
}

Employee();

// Genauso f├╝hrt jeder direkte Zugriff auf
// eine Funktion mit delete zu einem SyntaxError

funciton DemoFunction() {
  // etwas Code
}

delete DemoFunction; // SyntaxError

Beispiele

// Die Eigenschaft adminName im globalen G├╝ltigkeitsbereich erstellen
adminName = 'xyz';

// Die Eigenschaft empCount im globalen G├╝ltigkeitsbereich erstellen
// Weil var genutzt wurde, ist diese als nicht konfigurierbar markiert. Das selbe gibt auch f├╝r let und const.
var empCount = 43;

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

// adminName ist eine Eigenschaft im globalen G├╝ltigkeitsbereich.
// Sie kann gel├Âscht werden, weil sie nicht mit var erstellt wurde.
// Demnach ist sie konfigurierbar.
delete adminName     // gibt true zur├╝ck

// Im Gegensatz dazu ist empCount nicht konfigurierbar,
// weil var eingesetzt wurde
delete empCount;     // gibt false zur├╝ck

// delete kann f├╝r das L├Âschen von Eigenschaften von Objekte eingesetzt werden.
delete EmployeeDetails.name // gibt true zur├╝ck

// Auch wenn die Eigenschaft nicht existiert, wird "true" zur├╝ckgegeben.
delete EmployeeDetails.salary; // gibt true zur├╝ck

// delete hat keinen Effekt auf statische Eigenschaften von Standardobjekten.
delete Math.PI; // gibt false zur├╝ck

// EmployeeDetails ist eine Eigenschaft im globalen G├╝ltigkeitsbereich.
// Weil es ohne "var" definiert wurde, ist es als Konfigurierbar markiert.
delete EmployeeDetails;  // gibt true zur├╝ck

function f() {
  var z = 44;

  // delete hat keinen Effekt auf lokale Variablen
  delete z;     // returns false
}

delete und die Prototypenkette

Im folgenden Beispiel l├Âschen wir eine eigene Eigenschaft eines Objektes, w├Ąhrend ein Eigenschaft mit dem selben Namen in der Prototypenkette vorhanden ist:

function Foo(){
  this.bar = 10;
}

Foo.prototype.bar = 42;

var foo = new Foo();

// gibt true zur├╝ck, weil die eigene Eigenschaft
// vom foo Objekt gel├Âscht wird.
delete foo.bar;

// foo.bar ist weiter verf├╝gbar, weil es
// in der Prototypenkette verf├╝gbar ist.
console.log(foo.bar);

// L├Âschen der Eigenschaft auf dem Prototypen
delete Foo.prototype.bar;

// gibt "undefined" aus, weil die Eigenschaft
// nicht l├Ąnger vererbt wird.
console.log(foo.bar);           

Arrayelemente l├Âschen

Wenn ein Arrayelement gel├Âscht wird, hat das keinen Effekt auf die Arrayl├Ąnge. Das funktioniert nur, wenn man das letzte Arrayelement l├Âsche.

Wenn der delete Operator ein Arrayelement l├Âscht, ist das Element nicht mehr l├Ąnger im Array. Im folgenden Beispiel wird trees[3] mit delete gel├Âscht.

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];
if (3 in trees) {
    // das wird nicht ausgef├╝hrt
}

Wenn ein Arrayelement existent sein soll, aber den Wert undefined haben soll, benutzt man undefined statt dem delete Operator. Im folgenden Beispiel bekommt trees[3] den Wert undefined zugewiesen, aber das Arrayelement existiert noch:

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees[3] = undefined;
if (3 in trees) {
    // das wird ausgef├╝hrt
}

Wenn stattdessen ein Arrayelement gel├Âscht werden soll, wobei auch der Inhalt des Arrays ge├Ąndert werden soll, so benutzt man die splice Methode. Das folgende Beispiel entfernt trees[3] komplett vom Array mit dem Einsatz von splice:

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

Spezifikationen

Browserkompatibilit├Ąt

BCD tables only load in the browser

Browser├╝bergeifende Hinweise

Obwohl ECMAScript die Iterationsreihenfolge von Objekten, die von der Implementierung abh├Ąngig ist, vornimmt, scheint es, dass alle g├Ąngigen Browser eine Iterationsreihenfolge basierend auf der fr├╝hesten hinzugef├╝gten Eigenschaft unterst├╝tzen (zumindest f├╝r Eigenschaften, die nicht auf dem Prototyp basieren). Wenn jedoch bei Internet Explorer delete f├╝r eine Eigenschaft verwendet wird, f├╝hrt dies zu verwirrendem Verhalten und verhindert, dass andere Browser einfache Objekte wie Objektliterale als geordnete assoziative Arrays verwenden. Wenn im Explorer der Wert der Eigenschaft tats├Ąchlich auf undefiniert festgelegt ist, wird die Eigenschaft, wenn sie sp├Ąter eine Eigenschaft mit demselben Namen zur├╝ckgibt, an der alten Position iteriert - nicht am Ende der Iterationssequenz, wie beim l├Âschte und wieder einf├╝gen der Eigenschaft erwartet.

Wenn man also ein geordnetes assoziatives Array in einer browser├╝bergreifenden Umgebung simulieren m├Âchten, muss man entweder zwei separate Arrays verwenden (eines f├╝r die Schl├╝ssel und das andere f├╝r die Werte) oder ein Array von Objekten mit einer einzigen Eigenschaft erstellen. etc.

Siehe auch