1 files changed, 295 insertions, 0 deletions
diff --git a/files/de/web/javascript/reference/operators/delete/index.html b/files/de/web/javascript/reference/operators/delete/index.html
new file mode 100644
index 0000000000..dff87c8998
--- /dev/null
+++ b/files/de/web/javascript/reference/operators/delete/index.html
@@ -0,0 +1,295 @@
+---
+title: delete Operator
+slug: Web/JavaScript/Reference/Operators/delete
+tags:
+  - JavaScript
+  - Memory Management
+  - Object
+  - Operator
+  - Property
+  - Reference
+  - Release
+  - Unary
+  - delete
+translation_of: Web/JavaScript/Reference/Operators/delete
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Der JavaScript <strong><code>delete</code>-Operator</strong> entfernt eine Eigenschaft eines Objekts. Wenn keine weitere Referenz auf dieselbe Eigenschaft mehr existiert, wird diese automatisch freigegeben.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-deleteoperator.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">delete <em>Ausdruck</em> </pre>
+
+<p>wobei <em>Ausdruck</em> zu eine Referenz auf eine Eigenschaft ausgewertet werden sollte, z. B.:</p>
+
+<pre class="syntaxbox">delete <em>object.property</em>
+delete <em>object</em>['<em>property</em>']
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>object</code></dt>
+ <dd>Der Name eines Objekts oder ein Ausdruck der zu einem Objekt ausgewertet wird.</dd>
+ <dt><code>property</code></dt>
+ <dd>Die zu löschende Eigenschaft.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p><code>true</code> für alle Fälle, außer wenn die Eigenschaft eine eigene nicht konfigurierbare Eigenschaft ist, in diesem Fall wird im nicht strict Modus <code>false</code> zurückgegeben.</p>
+
+<h3 id="Fehler">Fehler</h3>
+
+<p>Erzeugt einen {{jsxref("Global_objects/SyntaxError")}} im <a href="/de/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">strict Modus</a>, wenn die Eigenschaft eine eigene nicht konfigurierbare Eigenschaft ist.</p>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Anders als es allgemein üblich ist, hat der <code>delete</code> Operator <strong>nichts</strong> mit dem Freigeben von Speichers zu tun. Speicherverwaltung wird indirekt über fehlende Referenzen gemacht, dazu mehr Details auf der Seite <a href="/de/docs/Web/JavaScript/Memory_Management">Speicherverwaltung</a>.</p>
+
+<p>Der <strong><code>delete</code></strong> Operator entfernt eigene gegebene Eigenschaft von einem Objekt. Ist dieses Erfolgreich, wird <code>true</code> zurückgegeben, andernfalls <code>false</code>. Jedoch ist es wichtig die folgenden Szenarien zu bedenken:</p>
+
+<ul>
+ <li>Wenn die Eigenschaft, die gelöscht werden soll, nicht existiert, hat <code>delete</code> keinen Effekt und wird <code>true</code> zurückgeben.</li>
+ <li>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, <code>delete</code> hat nur auf eigenen Eigenschaften einen Effekt).</li>
+ <li>Jede Eigenschaft, die mit {{jsxref("Statements/var","var")}} deklariert wurde, kann nicht vom globalen oder Funktionsgültigkeitsbereich gelöscht werden.
+  <ul>
+   <li><code>delete</code> kann keine Funktion im globalen Gültigkeitsbereich löschen (egal ob diese Teil einer Funktionsdeklaration oder eines Funktionsausdrucks ist).</li>
+   <li>Funktionen die Teil eines Objektes sind (außer dem globalen Objekt) können mit <code>delete</code> gelöscht werden.</li>
+  </ul>
+ </li>
+ <li>Jede Eigenschaft, die mit {{jsxref("Statements/let","let")}} oder {{jsxref("Statements/const","const")}} deklariert wurde, kann nicht vom Gültigkeitsbereich, indem diese definiert wurde, gelöscht werden.</li>
+ <li>Nicht konfigurierbare Eigenschaften können nicht gelöscht werden. Eingenommen sind Eigenschaften von Standardobjekten wie {{jsxref("Math")}}, {{jsxref("Array")}}, {{jsxref("Object")}} und Eigenschaften die mit Methoden wie {{jsxref("Object.defineProperty()")}} als nicht konfigurierbar erstellt wurden.</li>
+</ul>
+
+<p>Der folgende Ausschnitt enthält ein einfaches Beispiel:</p>
+
+<pre class="brush: js">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</pre>
+
+<h3 id="Nicht_konfigurierbare_Eigenschaften">Nicht konfigurierbare Eigenschaften</h3>
+
+<p>Wenn eine Eigenschaft als nicht konfigurierbar markiert ist, hat <code>delete</code> keinen Effekt und wird <code>false</code> zurückgeben. Im strict Modus wird es zu einem <code>SyntaxError</code> kommen.</p>
+
+<pre class="brush: js">var Employee = {};
+Object.defineProperty(Employee, 'name', {configurable: false});
+
+console.log(delete Employee.name);  // gibt false zurück</pre>
+
+<p>{{jsxref("Statements/var","var")}}, {{jsxref("Statements/let","let")}} und {{jsxref("Statements/const","const")}} erstellen nicht konfigurierbare Eigenschaften, die nicht mit dem <code>delete</code> Operator gelöscht werden können.</p>
+
+<pre class="brush: js">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
+</pre>
+
+<p>Im strict Modus wird diese zu einem Fehler führen.</p>
+
+<h3 id="Strict_vs._nicht_strict_Modus">Strict vs. nicht strict Modus</h3>
+
+<p>Wenn im strict Mode <code>delete</code> direkt auf einer Referenz einer Variablen, eines Funktionsargumentes oder eines Funktionsnamens genutzt wird, wird ein {{jsxref("SyntaxError")}} erzeugt.</p>
+
+<p>Jede Variable, die mit <code>var</code> definiert wird, wird als nicht konfigurierbar markiert. Im folgenden Beispiel ist <code>salary</code> nicht konfigurierbar und kann nicht gelöscht werden. Im nicht strict Modus wird der <code>delete</code> Operator <code>false</code> zurückgeben.</p>
+
+<pre class="brush: js">function Employee() {
+  delete salary;
+  var salary;
+}
+
+Employee();</pre>
+
+<p>Mal sehen, wie sich der selbe Code im strict Modus verhält. Statt dem Zurückgeben von <code>false</code>, wird das Statement zu einem <code>SyntaxError</code> führen.</p>
+
+<pre class="brush: js">"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</pre>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">// 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
+}
+</pre>
+
+<h3 id="delete_und_die_Prototypenkette"><code>delete</code> und die Prototypenkette</h3>
+
+<p>Im folgenden Beispiel löschen wir eine eigene Eigenschaft eines Objektes, während ein Eigenschaft mit dem selben Namen in der Prototypenkette vorhanden ist:</p>
+
+<pre class="brush: js">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);           </pre>
+
+<h3 id="Arrayelemente_löschen">Arrayelemente löschen</h3>
+
+<p>Wenn ein Arrayelement gelöscht wird, hat das keinen Effekt auf die Arraylänge. Das funktioniert nur, wenn man das letzte Arrayelement lösche.</p>
+
+<p>Wenn der <code>delete</code> Operator ein Arrayelement löscht, ist das Element nicht mehr länger im Array. Im folgenden Beispiel wird <code>trees[3]</code> mit <code>delete</code> gelöscht.</p>
+
+<pre class="brush: js">var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
+delete trees[3];
+if (3 in trees) {
+    // das wird nicht ausgeführt
+}</pre>
+
+<p>Wenn ein Arrayelement existent sein soll, aber den Wert undefined haben soll, benutzt man <code>undefined</code> statt dem <code>delete</code> Operator. Im folgenden Beispiel bekommt <code>trees[3]</code> den Wert undefined zugewiesen, aber das Arrayelement existiert noch:</p>
+
+<pre class="brush: js">var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
+trees[3] = undefined;
+if (3 in trees) {
+    // das wird ausgeführt
+}</pre>
+
+<p>Wenn stattdessen ein Arrayelement gelöscht werden soll, wobei auch der Inhalt des Arrays geändert werden soll, so benutzt man die <code>{{jsxref("Array.splice", "splice")}}</code> Methode. Das folgende Beispiel entfernt <code>trees[3]</code> komplett vom Array mit dem Einsatz von <code>{{jsxref("Array.splice", "splice")}}</code>:</p>
+
+<pre class="brush: js">var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
+trees.splice(3, 1);
+console.log(trees); // ["redwood", "bay", "cedar", "maple"];</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-delete-operator', 'The delete Operator')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-delete-operator', 'The delete Operator')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.4.1', 'The delete Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-11.4.1', 'The delete Operator')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initiale Definition. Implementiert in JavaScript 1.2.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.operators.delete")}}</p>
+
+<h2 id="Browserübergeifende_Hinweise">Browserübergeifende Hinweise</h2>
+
+<p>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.</p>
+
+<p>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.</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li><a href="http://perfectionkills.com/understanding-delete/">In depth analysis on delete</a></li>
+ <li>{{jsxref("Reflect.deleteProperty()")}}</li>
+ <li>{{jsxref("Map.prototype.delete()")}}</li>
+</ul>