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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
---
title: isNaN()
slug: Web/JavaScript/Reference/Global_Objects/isNaN
tags:
- JavaScript
- Method
translation_of: Web/JavaScript/Reference/Global_Objects/isNaN
---
<div>{{jsSidebar("Objects")}}</div>
<p>Die <code><strong>isNaN()</strong></code> Methode prüft, ob ein Wert {{jsxref("NaN")}} ist. Bemerkung: Aufgrund innerer Zwänge weist die <code>isNaN</code> Methode <a href="#Description">interessante</a> Regeln auf. Alternativ kann die in ECMAScript 2015 definierte Methode {{jsxref("Number.isNaN()")}} genutzt werden.</p>
<div>{{EmbedInteractiveExample("pages/js/globalprops-isnan.html")}}</div>
<h2 id="Syntax">Syntax</h2>
<pre class="syntaxbox"><code>isNaN(<em>testWert</em>)</code></pre>
<h3 id="Parameters" name="Parameters">Parameter</h3>
<dl>
<dt><code>testWert</code></dt>
<dd>Der zu testende Wert.</dd>
</dl>
<h3 id="Rückgabewert">Rückgabewert</h3>
<p><strong><code>true</code></strong> wenn der gegebene Wert {{jsxref("NaN")}} ist, andernfalls <strong><code>false</code></strong>.</p>
<h2 id="Description" name="Description">Beschreibung</h2>
<h3 id="The_necessity_of_an_isNaN_function" name="The_necessity_of_an_isNaN_function">Die notwendigkeit einer <code>isNaN Methode</code></h3>
<p>Anders als bei allen anderen Werten in JavaScript, ist es nicht möglich mit den Gleichheitsoperatoren ({{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} and {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}) zu prüfen, ob ein Wert {{jsxref("NaN")}} ist oder nicht. <code>NaN == NaN</code> und <code>NaN === NaN</code> werden zu <code>false </code>ausgewertet. Aus diesem Grund wird eine <code>isNaN</code> Methode benötigt. </p>
<h3 id="Origin_of_NaN_values" name="Origin_of_NaN_values">Ursprünge des <code>NaNWertes</code></h3>
<p><code>NaN</code> Werte werden generiert, wenn das Ergebnis einer arithmetischen Operation ein undefinierter Wert oder ein nicht repräsentierbarer Wert ist. Diese Werte entsprechen nicht unbedingt dem Überlauf von Wertebereichen. Ein <code>NaN</code> Ergebnis kann ebenfalls entstehen, wenn es für eine Operation keine primitive Zahl als Darstellung gibt.</p>
<p>Beispielsweise ist das Ergebnis einer Division von null durch null <code>NaN</code>. Jedoch ist das Ergebnis nicht <code>NaN</code> wenn andere Zahlen durch null geteilt werden.</p>
<h3 id="Verwirrende_Spezialfälle">Verwirrende Spezialfälle</h3>
<p>Schon seit den frühesten Versionen der <code>isNaN</code> Methodendefinition ist das Verhalten für nicht numerische Typen nicht trivial. Wenn der zu überprüfende Wert nicht vom Typ <a href="http://es5.github.com/#x8.5" title="http://es5.github.com/#x8.5">Number</a> ist, so wird dieser Wert zuerst in den Typ <a href="http://es5.github.com/#x8.5" title="http://es5.github.com/#x8.5">Number</a> konvertiert. Erst dann wird geprüft, ob der Wert {{jsxref("NaN")}} ist. Weil einige nicht numerischen Werte trotzdem als Zahlen interpretiert werden können (leere Strings und Werte vom Typ boolean können als Nullen und Einsen dargestellt werden) ist das <code>false</code>-Resultat der Funktion manchmal unerwartet. Der leere String ist ein Beispiel dafür, weil dieser definitiv keine Nummer ist. Das verwirrende ist jedoch dass "not a number" eine spezielle Repräsentation in den IEEE-754 Gleitkommazahlen besitzt. Aus diesem Grund kann die Methode so interpretiert werden, dass sie die Antwort auf die Frage gibt, ob ein Wert, der als Nummer interpretiert wird, eine IEEE-754 'Not a number' ist.</p>
<p>Die aktuelle Version von ECMAScript (ES2015) enthält die Methode {{jsxref("Number.isNaN()")}}. <code>Number.isNaN(x)</code> wird eine zuverlässige Möglichkeit sein um zu testen ob <code>x</code> den Wert <code>NaN</code> entspricht oder nicht. Mit <code>Number.isNaN</code> wird exakt abgefragt, ob es sich um eine Nummer handelt. Eine Alternative zu testen ob eine Variable <code>NaN</code> ist, ist die Abfrage <code>(x != x)</code>. Diese wird im Normalfall zu <code>false </code>ausgewertet, außer wenn der wert <code>NaN ist.</code></p>
<p>Ein Polyfill für <code>isNaN</code> ist folgender (der<span id="result_box" lang="de"><span> Polyfill nutzt die einzigartigen Eigenschaften von <code>NaN</code>, dass dieses niemals gleichwertig mit <code>NaN</code> ist</span></span>):</p>
<pre class="brush: js line-numbers language-js"><code class="language-js">var isNaN <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span>value<span class="punctuation token">)</span> <span class="punctuation token">{
var n = Number(value);</span>
return n !== n<span class="punctuation token">;</span>
<span class="punctuation token">}</span></code></pre>
<h2 id="Examples" name="Examples">Beispiele</h2>
<pre class="brush: js">isNaN(NaN); // true
isNaN(undefined); // true
isNaN({}); // true
isNaN(true); // false
isNaN(null); // false
isNaN(37); // false
// strings
isNaN("37"); // false: "37" wird in die Nummer 37 konvertiert welche nicht NaN ist
isNaN("37.37"); // false: "37.37" wird in die Nummer 37.37 konvertiert welche nicht NaN ist
isNaN("37,5"); // true
isNaN("123ABC"); // true: parseInt("123ABC") ist 123 aber Number("123ABC") ist NaN
isNaN(""); // false: der leere String wird zu 0 konvertiert welche nicht NaN ist
isNaN(" "); // false: ein String mit Leerzeichen wird zu 0 konvertiert welche nicht NaN ist
// dates
isNaN(new Date()); // false
isNaN(new Date().toString()); // true
// Dieses ist das Beispiel, warum isNaN nicht zuverlässig ist.
isNaN("blabla") // true: "blabla" wird zu einer Nummer konvertiert
// Das Konvertieren schlägt fehl und gibt NaN zurück
</pre>
<h3 id="Nützliche_Spezialfälle">Nützliche Spezialfälle</h3>
<p>Es gibt weitere nützliche Wege <code>isNaN()</code> einzusetzen: Wenn <code>isNaN(x)</code> <code>false</code> zurückgibt, kann <code>x</code> in einer arithmetischen Operation eingesetzt werden, ohne dass diese zu <code>NaN</code> ausgewertet wird. Wenn <code>true</code> zurückgegeben wird, wird jede arithmetische Operation zu <code>NaN</code> ausgewertet. Das bedeutet, dass in JavaScript <code>isNaN(x) == true</code> gleich zu "<code>x - 0</code> ergibt <code>NaN</code>" (in JavaScript wird <code>x - 0 == NaN</code> immer false zurückgeben, was bedeutet, man kann es nicht testen). Aktuell geben <code>isNaN(x)</code>, <code>isNaN(x - 0)</code>, <code>isNaN(Number(x))</code>, <code>Number.isNaN(x - 0)</code>, und <code>Number.isNaN(Number(x))</code> immer das selbe Ergebnis zurück und <code>isNaN(x)</code> ist der kürzest mögliche Ausdruck.</p>
<p>Dieses kann zum Beispiel eingesetzt werden, um zu prüfen, ob ein Funktionsargument arithmetisch verarbeitet werden kann. Wenn diese Verarbeitung nicht möglich ist, kann ein Standardwert unterstützt werden oder irgendetwas anderes. Damit kann man sich die volle Vielseitigkeit, die JavaScript mit implizierten Typkonvertierungen abhängig vom Kontext unterstützt, zu nutze machen.</p>
<h2 id="Beispiele">Beispiele</h2>
<pre class="brush: js">function increment(x) {
if (isNaN(x)) x = 0;
return x + 1;
};
// Gleicher Wirkung wie bei Number.isNaN():
function increment(x) {
if (Number.isNaN(Number(x))) x = 0;
return x + 1;
};
// In den folgenden Fällen ist für das Funktionsargument x
// isNaN(x) immer false, weil es keine Nummer ist,
// jedoch kann es in arithmetischen Operationen eingesetzt
// werden.
increment(""); // 1: "" is converted to 0
increment(new String()); // 1: String object representing an empty string is converted to 0
increment([]); // 1: [] is converted to 0
increment(new Array()); // 1: Array object representing an empty array is converted to 0
increment("0"); // 1: "0" is converted to 0
increment("1"); // 2: "1" is converted to 1
increment("0.1"); // 1.1: "0.1" is converted to 0.1
increment("Infinity"); // Infinity: "Infinity" is converted to Infinity
increment(null); // 1: null is converted to 0
increment(false); // 1: false is converted to 0
increment(true); // 2: true is converted to 1
increment(new Date()); // returns current date/time in milliseconds plus 1
// In den folgenden Fällen ist für das Funktionsargument x
// isNaN(x) immer false und x ist eine Nummer
increment(-1); // 0
increment(-0.1); // 0.9
increment(0); // 1
increment(1); // 2
increment(2); // 3
// ... und so weiter ...
increment(Infinity); // Infinity
// In den folgenden Fällen ist für das Funktionsargument x
// isNaN(x) immer true und x ist keine Nummer,
// weshalb die Funktion es mit 0 ersetzt und 1 zurück gibt.
increment(String); // 1
increment(Array); // 1
increment("blabla"); // 1
increment("-blabla"); // 1
increment(0/0); // 1
increment("0/0"); // 1
increment(Infinity/Infinity); // 1
increment(NaN); // 1
increment(undefined); // 1
increment(); // 1
// isNaN(x) ist immer identisch mit isNaN(Number(x)),
// aber die Präsenz wenn x ist immer zwingend erforderlich.
isNaN(x) == isNaN(Number(x)) // true für jeden Wert von x, auch x == undefined,
// weil isNaN(undefined) == true und Number(undefined) gibt NaN,
// aber ...
isNaN() == isNaN(Number()) // false, weil isNaN() == true und Number() == 0</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('ES1')}}</td>
<td>{{Spec2('ES1')}}</td>
<td>Initiale Definition.</td>
</tr>
<tr>
<td>{{SpecName('ES5.1', '#sec-15.1.2.4', 'isNaN')}}</td>
<td>{{Spec2('ES5.1')}}</td>
<td> </td>
</tr>
<tr>
<td>{{SpecName('ES6', '#sec-isnan-number', 'isNaN')}}</td>
<td>{{Spec2('ES6')}}</td>
<td> </td>
</tr>
<tr>
<td>{{SpecName('ESDraft', '#sec-isnan-number', 'isNaN')}}</td>
<td>{{Spec2('ESDraft')}}</td>
<td> </td>
</tr>
</tbody>
</table>
<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
<p>{{Compat("javascript.builtins.isNaN")}}</p>
<h2 id="See_also" name="See_also">Siehe auch</h2>
<ul>
<li>{{jsxref("NaN")}}</li>
<li>{{jsxref("Number.isNaN()")}}</li>
</ul>
|
