1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
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>
|
