initial commit

1 files changed, 192 insertions, 0 deletions

diff --git a/files/de/web/javascript/reference/global_objects/isnan/index.html b/files/de/web/javascript/reference/global_objects/isnan/index.html
new file mode 100644
index 0000000000..328ef94557
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/isnan/index.html
@@ -0,0 +1,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>