1 files changed, 172 insertions, 0 deletions
diff --git a/files/de/web/javascript/reference/operators/instanceof/index.html b/files/de/web/javascript/reference/operators/instanceof/index.html
new file mode 100644
index 0000000000..a6729bb709
--- /dev/null
+++ b/files/de/web/javascript/reference/operators/instanceof/index.html
@@ -0,0 +1,172 @@
+---
+title: instanceof
+slug: Web/JavaScript/Reference/Operators/instanceof
+tags:
+  - JavaScript
+  - Object
+  - Operator
+  - Prototype
+  - Relational Operators
+  - instanceof
+translation_of: Web/JavaScript/Reference/Operators/instanceof
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Der <strong><code>instanceof</code> Operator</strong> prüft, ob ein Objekt die prototype Eigenschaft einer Konstruktorfunktion in seiner Prototypenkette besitzt.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-instanceof.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><em>object</em> instanceof <em>constructor</em></pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>object</code></dt>
+ <dd>Das zu prüfende Objekt.</dd>
+</dl>
+
+<dl>
+ <dt><code>constructor</code></dt>
+ <dd>Gegen die zu testende Funktion.</dd>
+</dl>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Der <code>instanceof</code> Operator prüft die Anwesenheit des <code>constructor.prototype</code> in der Prototypenkette eines Objekts.</p>
+
+<pre class="brush: js">// Konstruktoren definieren
+function C(){}
+function D(){}
+
+var o = new C();
+
+// true, weil: Object.getPrototypeOf(o) === C.prototype
+o instanceof C;
+
+// false, weil D.prototype nirgends in o's Prototypenkette ist
+o instanceof D;
+
+o instanceof Object; // true, weil:
+C.prototype instanceof Object // true
+
+C.prototype = {};
+var o2 = new C();
+
+o2 instanceof C; // true
+
+// false, weil C.prototype nirgends in
+// o's Prototypenkette ist
+o instanceof C;
+
+D.prototype = new C(); // Einsatz von Vererbung
+var o3 = new D();
+o3 instanceof D; // true
+o3 instanceof C; // true
+</pre>
+
+<p>Zu beachten ist, dass sich das Ergebnis des <code>instanceof</code> Tests ändern kann, wenn die <code>prototype</code> Eigenschaft eines Konstruktors geändert wird und auch, wenn ein Objektprototyp mit <code>Object.setPrototypeOf</code> geändert wird. Es ist auch möglich die nicht standardisierte Pseudoeigenschaft <code>__proto__</code> zu nutzen.</p>
+
+<h3 id="instanceof_und_verschiedene_Kontexte_(z._B._Frames_oder_Windows)"><code>instanceof</code> und verschiedene Kontexte (z. B. Frames oder Windows)</h3>
+
+<p>Verschiedene Scopes haben verschiedene Ausführungsumgebungen. Das bedeutet, sie haben verschiedene Standardobjekte (verschiedene globale Objekte, verschiedene Konstruktoren, etc.). Das kann zu unerwarteten Resultaten führt. Zum Beispiel gibt <code>[] instanceof window.frames[0].Array</code> <code>false</code> zurück, weil <code>Array.prototype !== </code><code>window.frames[0].Array</code> ist und Arrays vom Ersteren erben.</p>
+
+<p>Auf den ersten Blick ergibt das nicht viel Sinn, fängt man jedoch an Objekte zwischen verschiedenen Frames oder Windows zwischen Kontexten auszutauschen, wäre das valide und ein großes Problem. Zum Beispiel kann man mit sicher testen ob ein Objekt ein Array ist, indem man <code>Array.isArray(myObj)</code> benutzt.</p>
+
+<p>Zur Prüfung ob ein <a href="/de/docs/Web/API/Node">Node</a> ein SVGElement ist kann <code>myNode instanceof myNode.ownerDocument.defaultView.SVGElement</code> genutzt werden.</p>
+
+<div class="note"><strong>Hinweis for Mozilla Entwickler:</strong><br>
+In Code mit XPCOM, hat <code>instanceof</code> einen speziellen Effekt: <code>obj instanceof </code><em><code>xpcomInterface</code></em> (z. B. <code>Components.interfaces.nsIFile</code>) ruft <code>obj.QueryInterface(<em>xpcomInterface</em>)</code> auf und gibt <code>true</code> zurück, wenn QueryInterface erfolgreich war. Ein Seiteneffekt ist, dass Eigenschaften von <em><code>xpcomInterface</code></em> auf <code>obj</code> aufgerufen werden können, wenn erfolgreich mit <code>instanceof</code> getestet wurde. Im Gegensatz zu JavaScripts Standardobjekten, funktioniert <code>obj instanceof xpcomInterface</code> wie erwartet, auch wenn <code>obj</code> aus ein anderen Scope stammt.</div>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<h3 id="Demonstration_dass_String_und_Date_vom_Typ_Object_sind_und_Ausnahmefälle">Demonstration, dass <code>String</code> und <code>Date</code> vom Typ <code>Object</code> sind und Ausnahmefälle</h3>
+
+<p>Der folgende Quelltext nutzt <code>instanceof</code>, um zu demonstrieren, dass <code>String</code> und <code>Date</code> Objekte von Typ <code>Object</code> sind (sie sind von <code>Object</code> abgeleitet).</p>
+
+<p>Immer, wenn ein Objekt durch die Objekt Literal Notation erstellt wird, ist das eine Ausnahme: Auch wenn der Prototype <code>undefined</code> ist, ergibt <code>instanceof Object</code> <code>true</code>.</p>
+
+<pre class="brush: js">var simpleStr = "This is a simple string";
+var myString  = new String();
+var newStr    = new String("String created with constructor");
+var myDate    = new Date();
+var myObj     = {};
+var myNonObj  = Object.create(null);
+
+simpleStr instanceof String; // gibt false zurück; kontrolliert die Prototypenkette und findet undefined
+myString  instanceof String; // gibt true zurück
+newStr    instanceof String; // gibt true zurück
+myString  instanceof Object; // gibt true zurück
+
+myObj    instanceof Object;    // gibt true zurück, trotz eines undefined Prototypen
+({})     instanceof Object;    // gibt true zurück, gleicher Fall wie oben
+myNonObj instanceof Object;    // gibt false zurück, ein Weg ein Objekt zu erstellen, welches keine Instanz von Object ist
+
+myString instanceof Date;   // gibt false zurück
+
+myDate instanceof Date;     // gibt true zurück
+myDate instanceof Object;   // gibt true zurück
+myDate instanceof String;   // gibt false zurück
+</pre>
+
+<h3 id="Demonstration_dass_mycar_vom_Typ_Car_und_vom_Typ_Object_ist">Demonstration, dass <code>mycar</code> vom Typ <code>Car</code> und vom Typ<code> Object</code> ist</h3>
+
+<p>Der folgende Quelltext erstellt ein Objekttyp <code>Car</code> und einen Instanz dieses Typen, <code>mycar</code>. Der <code>instanceof</code> Operator demonstriert, dass das <code>mycar</code> Objekt vom Typ <code>Car</code> und <code>Object</code> ist.</p>
+
+<pre class="brush: js">function Car(make, model, year) {
+  this.make = make;
+  this.model = model;
+  this.year = year;
+}
+var mycar = new Car("Honda", "Accord", 1998);
+var a = mycar instanceof Car;    // gibt true zurück
+var b = mycar instanceof Object; // gibt true zurück
+</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-relational-operators', 'Relational Operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-relational-operators', 'Relational Operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.8.6', 'The instanceof operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-11.8.6', 'The instanceof operator')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initiale Definition. Implementiert in JavaScript 1.4.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.operators.instanceof")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("operators/typeof","typeof")}}</li>
+ <li>{{jsxref("Symbol.hasInstance")}}</li>
+</ul>