diff options
Diffstat (limited to 'files/de/web/javascript/reference/global_objects/number')
24 files changed, 2277 insertions, 0 deletions
diff --git a/files/de/web/javascript/reference/global_objects/number/epsilon/index.html b/files/de/web/javascript/reference/global_objects/number/epsilon/index.html new file mode 100644 index 0000000000..6259e2443f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/epsilon/index.html @@ -0,0 +1,75 @@ +--- +title: Number.EPSILON +slug: Web/JavaScript/Reference/Global_Objects/Number/EPSILON +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON +--- +<div>{{JSRef}}</div> + +<p>Die Eigenschaft <strong><code>Number.EPSILON</code></strong> beschreibt den Unterschied zwischen 1 und der kleinsten Gleitpunktzahl größer als 1.</p> + +<p>Man muss kein Objekt von Typ {{jsxref("Number")}} erzeugen, um auf diese statische Eigenschaft zuzugreifen. Man muss nur <code>Number.EPSILON</code> aufrufen.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die <code>EPSILON</code> Eigenschaft hat einen ungefähren Wert von <code>2.2204460492503130808472633361816E-16</code> order <code>2<sup>-52</sup></code>.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Testgleichung">Testgleichung</h3> + +<pre class="brush: js">x = 0.2; +y = 0.3; +z = 0.1; +equal = (Math.abs(x - y + z) < Number.EPSILON);</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">if</span> <span class="punctuation token">(</span>Number<span class="punctuation token">.</span>EPSILON <span class="operator token">===</span> undefined<span class="punctuation token">) </span><span class="punctuation token">{</span> + Number<span class="punctuation token">.</span>EPSILON <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">pow</span><span class="punctuation token">(</span><span class="number token">2</span><span class="punctuation token">,</span> <span class="operator token">-</span><span class="number token">52</span><span class="punctuation token">)</span><span class="punctuation token">; +}</span></code> +</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('ES2015', '#sec-number.epsilon', 'Number.EPSILON')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.EPSILON")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>Das {{jsxref("Number")}} Objekt.</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/index.html b/files/de/web/javascript/reference/global_objects/number/index.html new file mode 100644 index 0000000000..95bcd0652f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/index.html @@ -0,0 +1,180 @@ +--- +title: Number +slug: Web/JavaScript/Reference/Global_Objects/Number +tags: + - JavaScript + - Number + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number +--- +<div>{{JSRef}}</div> + +<p>Das JavaScript Objekt <strong><code>Number</code></strong> ist ein Container Objekt (Wrapper Objekt), welches das Arbeiten mit numerischen Werten erlaubt. Ein <code>Number</code> Objekt wird erzeugt indem der <code>Number()</code> Konstruktor verwendet wird.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox">new Number(value);</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Ein numerischer Wert, der als Objekt erstellt werden soll.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die hauptsächlichen Nutzungen des <code>Number</code> Objektes sind:</p> + +<ul> + <li>Wenn der Parameter nicht zu einer Nummer konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.</li> + <li>In einem nicht-Konstruktor Kontext (z. B. ohne den {{jsxref("Operators/new", "new")}} Operator) führt <code>Number</code> zu einer Typkonvertierung.</li> +</ul> + +<h2 id="Properties" name="Properties">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("Number.EPSILON")}}</dt> + <dd>Das kleinste Intervall zwischen zwei repräsentierbaren Zahlen.</dd> + <dt>{{jsxref("Number.MAX_SAFE_INTEGER")}}</dt> + <dd>Die größte sichere Ganzzahl in JavaScript (2<sup>53</sup> -1).</dd> + <dt>{{jsxref("Number.MAX_VALUE")}}</dt> + <dd>Die größte repräsentierbare Zahl.</dd> + <dt>{{jsxref("Number.MIN_SAFE_INTEGER")}}</dt> + <dd>Die kleinste sichere Ganzzahl in JavaScript (-(2<sup>53</sup> -1)).</dd> + <dt>{{jsxref("Number.MIN_VALUE")}}</dt> + <dd>Die kleinste positive repräsentierbare Zahl. Das ist die positive Zahl, die am nächsten an <code>0</code> ist (aber nicht <code>0</code> ist).</dd> + <dt>{{jsxref("Number.NaN")}}</dt> + <dd>Spezieller "keine Zahl" Wert.</dd> + <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt> + <dd>Spezieller Wert welcher negativ Unendlich repräsentiert; wird bei einem Overflow zurückgegeben.</dd> + <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt> + <dd>Spezieller Wert welcher positiv Unendlich repräsentiert; wird bei einem Overflow zurückgegeben.</dd> + <dt>{{jsxref("Number.prototype")}}</dt> + <dd> + <div id="gt-src-tools"> + <div id="tts_button"><span id="result_box" lang="de"><span>Ermöglicht das Hinzufügen</span> <span>von</span> <span>Eigenschaften</span> <span>zu</span> <span>einem</span> <span><code>Number</code> Objekt</span></span></div> + </div> + </dd> +</dl> + +<h2 id="Methods" name="Methods">Methoden</h2> + +<dl> + <dt>{{jsxref("Number.isNaN()")}}</dt> + <dd>Gibt an, ob der übergebene Wert {{jsxref("Number.NaN", "NaN")}} ist.</dd> + <dt>{{jsxref("Number.isFinite()")}}</dt> + <dd>Gibt an, ob der übergebene Wert eine endliche Zahl ist.</dd> + <dt>{{jsxref("Number.isInteger()")}}</dt> + <dd>Gibt an, ob der übergebene Wert eine ganze Zahl ist.</dd> + <dt>{{jsxref("Number.isSafeInteger()")}}</dt> + <dd>Gibt an, ob der der übergebene Wert eine sichere ganze Zahl ist (eine ganze Zahl zwischen -(2<sup>53</sup> -1) und 2<sup>53</sup> -1).</dd> + <dt><s class="obsoleteElement">{{jsxref("Number.toInteger()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Wurde eingesetzt um eine Zahl zu einer ganzen Zahl zu konvertieren. Die Funktion wurde entfernt.</s></dd> + <dt>{{jsxref("Number.parseFloat()")}}</dt> + <dd>Der Wert ist der gleiche wie bei der {{jsxref("parseFloat", "parseFloat()")}} Funktion des globalen Objektes.</dd> + <dt>{{jsxref("Number.parseInt()")}}</dt> + <dd>Der Wert ist der gleiche wie bei der {{jsxref("parseInt", "parseInt()")}} Funktion des globalen Objektes.</dd> +</dl> + +<h2 id="Number_instances" name="Number_instances"><code>Number</code> Instanzen</h2> + +<p>Alle Instanzen von <code>Number</code> erben von {{jsxref("Number.prototype")}}. Das Prototyp Objekt des <code>Number</code> Konstruktors kann verändert werden, um alle Instanzen von <code>Number</code> zu beeinflussen.</p> + +<h3 id="Methods_of_number_instance" name="Methods_of_number_instance">Methoden</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Number/prototype', 'Methoden')}}</div> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_the_Number_object_to_assign_values_to_numeric_variables" name="Example:_Using_the_Number_object_to_assign_values_to_numeric_variables">Einsatz des <code>Number</code> Objektes zur Zuweisung von numerischen Variablen</h3> + +<p>Das folgende Beispiel benutzt Eigenschaften des <code>Number</code> Objektes um Werte zu numerischen Variablen zuzuweisen:</p> + +<pre class="brush: js">var biggestNum = Number.MAX_VALUE; +var smallestNum = Number.MIN_VALUE; +var infiniteNum = Number.POSITIVE_INFINITY; +var negInfiniteNum = Number.NEGATIVE_INFINITY; +var notANum = Number.NaN; +</pre> + +<h3 id="Example:_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object">Ganzzahlbereich von <code>Number</code></h3> + +<p>Das folgende Beispiel zeigt die kleinste und größte Ganzzahl, welche mit <code>Number</code> Objekten repräsentiert werden kann (für Details siehe im ECMAScript Standard Kapitel <em><a href="https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type">6.1.6 The Number Type</a></em>):</p> + +<pre class="brush: js">var biggestInt = 9007199254740992; +var smallestInt = -9007199254740992; +</pre> + +<p>Wenn Daten im JSON Format eingelesen werden und Ganzzahlen den oben gezeigten Bereich übersteigen, kann es passieren, dass Fehler beim Erstellen von <code>Number</code> Objekten auftreten. Mit dem Einsatz von {{jsxref("String")}} können solche Fehler umgangen werden. </p> + +<h3 id="Example:_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object">Einsatz von <code>Number</code> zum Konvertieren eines <code>Date</code> Objekts</h3> + +<p>Das folgende Beispiel konvertiert ein {{jsxref("Date")}} Objekt in einen numerischen Wert. Dazu wird <code>Number</code> als Funktion verwendet:</p> + +<pre class="brush: js">var d = new Date("December 17, 1995 03:24:00"); +print(Number(d)); +</pre> + +<p>Ausgabe: "819199440000".</p> + +<h3 id="Konvertiertung_von_Strings_zu_Nummern">Konvertiertung von Strings zu Nummern</h3> + +<pre class="brush: js">Number('123') // 123 +Number('12.3') // 12.3 +Number('123e-1') // 12.3 +Number('') // 0 +Number('0x11') // 17 +Number('0b11') // 3 +Number('0o11') // 9 +Number('foo') // NaN +Number('100a') // NaN +</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. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7', 'Number')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number-objects', 'Number')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> + <p>Neue Methoden und Properties hinzugefügt: {{jsxref("Number.EPSILON", "EPSILON")}}, {{jsxref("Number.isFinite", "isFinite")}}, {{jsxref("Number.isInteger", "isInteger")}}, {{jsxref("Number.isNaN", "isNaN")}}, {{jsxref("Number.parseFloat", "parseFloat")}}, {{jsxref("Number.parseInt", "parseInt")}}</p> + </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number-objects', 'Number')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.Number")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("NaN", "NaN")}}</li> + <li>Das globale Objekt {{jsxref("Math", "Math")}}</li> + <li><a href="https://medium.com/@maximus.koretskyi/javascripts-number-type-8d59199db1b6#.9whwe88tz">Number type in details</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/isfinite/index.html b/files/de/web/javascript/reference/global_objects/number/isfinite/index.html new file mode 100644 index 0000000000..3db1065680 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/isfinite/index.html @@ -0,0 +1,93 @@ +--- +title: Number.isFinite() +slug: Web/JavaScript/Reference/Global_Objects/Number/isFinite +tags: + - JavaScript + - Method + - Number + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>Number.isFinite()</code></strong> stellt fest, ob ein Wert endlich ist oder nicht.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-isfinite.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Number.isFinite(<var>testWert</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>test</code><code><var>Wert</var></code></dt> + <dd>Wert, der auf <span class="dpf_sent" id="dpfsent_2">Endlichkeit </span>getestet wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Boolean")}} der beschreibt, ob eine Zahl endlich oder nicht endlich ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Im Vergleich zu der globalen Funktion {{jsxref("isFinite", "isFinite()")}}, werden übergeben Wert nicht in eine Zahl konvertiert. Das <span class="dpf_sent" id="dpfsent_3">bedeutet</span>, dass nur Werte vom Typ number die endlich sind <code>true</code> als <span class="dpf_sent" id="dpfsent_3">Resultat </span>haben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Number.isFinite(Infinity); // false +Number.isFinite(NaN); // false +Number.isFinite(-Infinity); // false + +Number.isFinite(0); // true +Number.isFinite(2e64); // true + +Number.isFinite('0'); // false, würde mit der globalen + // Funktion isFinite('0') true ergeben +Number.isFinite(null); // false, würde mit der globalen + // Funktion isFinite(null) true ergeben +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isFinite = Number.isFinite || function(value) { + return typeof value === 'number' && isFinite(value); +} +</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('ES6', '#sec-number.isfinite', 'Number.isInteger')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isfinite', 'Number.isInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.isFinite")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>Das {{jsxref("Number")}} Objekt.</li> + <li>Die globale Funktion {{jsxref("isFinite")}}.</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/isinteger/index.html b/files/de/web/javascript/reference/global_objects/number/isinteger/index.html new file mode 100644 index 0000000000..0befee0d25 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/isinteger/index.html @@ -0,0 +1,98 @@ +--- +title: Number.isInteger() +slug: Web/JavaScript/Reference/Global_Objects/Number/isInteger +tags: + - JavaScript + - Method + - Number + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Number.isInteger()</code></strong> Methode prüft, ob ein übergebener Parameter eine ganze Zahl ist.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-isinteger.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Number.isInteger(v<var>alue</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Wert der getestet wird, ob er eine ganze Zahl ist.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Boolean")}} der angibt, ob der übergebene Wert eine ganze Zahl ist oder nicht.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn der übergebene Wert eine ganze Zahl ist, wird <code>true</code> zurückgegeben, anderfalls wird <code>false</code> zurückgegeben. Wenn der Wert {{jsxref("NaN")}} oder Unendlich (Infinity) ist, wird <code>false</code> zurückgegeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Number.isInteger(0); // true +Number.isInteger(1); // true +Number.isInteger(-100000); // true +Number.isInteger(99999999999999999999999); // true + +Number.isInteger(0.1); // false +Number.isInteger(Math.PI); // false + +<code class="language-js">Number<span class="punctuation token">.</span><span class="function token">isInteger</span><span class="punctuation token">(</span><span class="number token">NaN</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// false</span></code> +Number.isInteger(Infinity); // false +Number.isInteger(-Infinity); // false +Number.isInteger('10'); // false +Number.isInteger(true); // false +Number.isInteger(false); // false +Number.isInteger([1]); // false +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) { + return typeof value === 'number' && + isFinite(value) && + Math.floor(value) === value; +}; +</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('ES6', '#sec-number.isinteger', 'Number.isInteger')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.isInteger")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/isnan/index.html b/files/de/web/javascript/reference/global_objects/number/isnan/index.html new file mode 100644 index 0000000000..08d1a52303 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/isnan/index.html @@ -0,0 +1,104 @@ +--- +title: Number.isNaN() +slug: Web/JavaScript/Reference/Global_Objects/Number/isNaN +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Number +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Number.isNaN()</code></strong> Methode stellt fest, ob der Übergabewert {{jsxref("NaN")}} ist und der Typ des Parameters {{jsxref("Number")}} ist . Dieses ist eine robustere Version der globalen Methode {{jsxref("isNaN", "isNaN()")}}</p> + +<div>{{EmbedInteractiveExample("pages/js/number-isnan.html", "taller")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Number.isNaN(<var>testWert</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>testWert</code></dt> + <dd>Der Wert, der auf {{jsxref("NaN")}} getestet werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><strong>true</strong> wenn der Wert {{jsxref("NaN")}} und der Typ {{jsxref("Number")}} ist. Anderfalls <strong>false</strong>.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil beide Gleichheitsoperatoren, {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} und {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}, den Vergleich, ob {{jsxref("NaN")}} <em>gleich</em> {{jsxref("NaN")}} ist, zu <code>false </code>auswerten, hat die Methode <code>Number.isNaN()</code> an Bedeutung gewonnen. Diese Situation ist anders als bei allen anderen Vergleichen von Werten in JavaScript.</p> + +<p>Im Vergleich zu der globalen Methode {{jsxref("isNaN", "isNaN()")}} hat die Methode <code>Number.isNaN()</code> nicht das Problem, dass Werte zu einer Nummer konvertiert werden. Das bedeutet, das Werte, die normalerweise zu {{jsxref("NaN")}} konvertiert würden, aber momentan nicht dem Wert {{jsxref("NaN")}} entsprechen, ohne Probleme der Methode übergeben werden können. Das wiederum bedeutet, dass nur Werte vom Typ {{jsxref("Number")}}, die zudem {{jsxref("NaN")}} entsprechen <code>true </code>als Resultat haben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Number.isNaN(NaN); // true +Number.isNaN(Number.NaN); // true +Number.isNaN(0 / 0) // true + +// Beispiele, bei denen isNaN() true zurück gibt +Number.isNaN('NaN'); // false +Number.isNaN(undefined); // false +Number.isNaN({}); // false +Number.isNaN('blabla'); // false + +// Diese alle geben false zurück +Number.isNaN(true); +Number.isNaN(null); +Number.isNaN(37); +Number.isNaN('37'); +Number.isNaN('37.37'); +Number.isNaN(''); +Number.isNaN(' '); +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Das Folgende funktioniert, weil <code>NaN</code> der einzige Wert ist, welcher nicht gleich mit sich selbst ist.</p> + +<pre class="brush: js">Number.isNaN = Number.isNaN || function(value) { + return value !== value; +} +</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('ES2015', '#sec-number.isnan', 'Number.isnan')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isnan', 'Number.isnan')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.isNaN")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/issafeinteger/index.html b/files/de/web/javascript/reference/global_objects/number/issafeinteger/index.html new file mode 100644 index 0000000000..9f9d35082d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/issafeinteger/index.html @@ -0,0 +1,99 @@ +--- +title: Number.isSafeInteger() +slug: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Number +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Number.isSafeInteger()</code></strong> Methode prüft, ob der übergebene Wert eine Nummer ist, die ein sichere ganze Zahl ist.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-issafeinteger.html")}}</div> + + + +<p>Eine sichere ganze Zahl ist</p> + +<ul> + <li>eine Zahl, die exakt als IEEE-754 double precision Zahl repräsentiert werden kann, und</li> + <li>eine Zahl, deren IEEE-754 Repräsentation nicht das Ergebnis von Rundungen anderer ganzer Zahlen sein kann.</li> +</ul> + +<p>Zum Beispiel ist <code>2<sup>53</sup> - 1</code> eine sichere ganze Zahle: sie kann exakt repräsentiert werden und keine andere ganze Zahl wird in jedem IEEE-754 Rundungsmodus zu ihr gerundet. Im gegensatz dazu ist <code>2<sup>53</sup></code> keine sichere ganze Zahl: Sie kann in IEEE-754 exakt repräsentiert werden, jedoch wird die ganze Zahl <code>2<sup>53</sup> + 1</code> kann nicht exakt repräsentiert werden und wird zu <code>2<sup>53</sup> </code>in den Modus <em>zum nächsten Runden</em> und <em>zu null runden </em>gerundet. Die sicheren ganzen Zahlen sind alle ganzen Zahlen im Bereich von <code>-(2<sup>53</sup> - 1)</code> inklusiv und <code>2<sup>53</sup> - 1</code> inklusiv.</p> + +<p>Der Einsatz von Zahlen größer ~9 Biliarden oder kleiner ~-9 Biliarder mit voller Präzision benötigen eine <a href="https://de.wikipedia.org/wiki/Langzahlarithmetik">Langzahlarythmetik Bibliothek</a>. Mehr Informationen über die Repräsentation von Gleitkommazahlen gibt es in dem Artikel <a href="http://floating-point-gui.de/">What Every Programmer Needs to Know about Floating Point Arithmetic</a>.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Number.isSafeInteger(<var>testValue</var>)</code> +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>testValue</code></dt> + <dd>Wert der getestet wird, ob er ein sichere ganze Zahl ist.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Boolean")}}, der angibt, ob die übergebenen Zahl eine sichere ganze Zahl ist oder nicht.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Number.isSafeInteger(3); // true +Number.isSafeInteger(Math.pow(2, 53)); // false +Number.isSafeInteger(Math.pow(2, 53) - 1); // true +Number.isSafeInteger(NaN); // false +Number.isSafeInteger(Infinity); // false +Number.isSafeInteger('3'); // false +Number.isSafeInteger(3.1); // false +Number.isSafeInteger(3.0); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isSafeInteger = Number.isSafeInteger || function (value) { + return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER; +}; +</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('ES2015', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.isSafeInteger")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>Das {{jsxref("Number")}} Objekt.</li> + <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/max_safe_integer/index.html b/files/de/web/javascript/reference/global_objects/number/max_safe_integer/index.html new file mode 100644 index 0000000000..1254955d54 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/max_safe_integer/index.html @@ -0,0 +1,68 @@ +--- +title: Number.MAX_SAFE_INTEGER +slug: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Number.MAX_SAFE_INTEGER</strong></code> Konstante repräsentiert die größte, sichere, ganze Zahl in JavaScript (<code>2<sup>53</sup> - 1</code>).</p> + +<div>{{EmbedInteractiveExample("pages/js/number-maxsafeinteger.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>MAX_SAFE_INTEGER</code> Konstante hat einen Wert von <code>9007199254740991</code> (9.007.199.254.740.991 oder ca. 9 <span class="short_text" id="result_box" lang="de"><span>Billiarde</span></span>). Die Bedeutung hinter dieser Zahl ist, dass in JavaScript <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">double-precision floating-point Zahlen</a> wie sie in <a href="http://en.wikipedia.org/wiki/IEEE_floating_point">IEEE 754</a> spezifiziert sind benutzt werden. Nach dieser Spezifikation ist die sichere Repräsentation von Zahlen nur zwischen <code>-(2<sup>53</sup> - 1)</code> und <code>2<sup>53</sup> - 1</code> möglich.</p> + +<p>Sicher heißt in diesem Kontext, dass es möglich ist ganze Zahlen exakt zu repräsentieren und sie korrekt zu vergleichen. Zum Beispiel wird <code>Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2</code> zu <code>true</code> ausgewertet, was mathematisch nicht richtig ist. Weiter Informationen sind im Artikel {{jsxref("Number.isSafeInteger()")}} zu finden. </p> + +<p>Weil <code>MAX_SAFE_INTEGER</code> eine statische Eigenschaft von {{jsxref("Number")}} ist, wird sie immer mit <code>Number.MAX_SAFE_INTEGER</code> abgerufen, im Gegensatz zu einer Eigenschaft eines {{jsxref("Number")}} Objektes, was erstellt wurde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Number.MAX_SAFE_INTEGER // 9007199254740991 +Math.pow(2, 53) - 1 // 9007199254740991 +</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('ES2015', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.MAX_SAFE_INTEGER")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.isSafeInteger()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/max_value/index.html b/files/de/web/javascript/reference/global_objects/number/max_value/index.html new file mode 100644 index 0000000000..9cb4be1929 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/max_value/index.html @@ -0,0 +1,82 @@ +--- +title: Number.MAX_VALUE +slug: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Number.MAX_VALUE</code></strong> Eigenschaft repräsentiert den größten nummerische Wert, der in JavaScript repräsentiert werden kann.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-maxvalue.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>MAX_VALUE</code> Eigenschaft hat einen ungefähren Wert von <code>1.79E+308</code> (<math><semantics><mrow><mn>1</mn><mo>,</mo><mn>79</mn><mo>⋅</mo><msup><mn>10</mn><mn>308</mn></msup></mrow><annotation encoding="TeX">1,79 \cdot 10^{308}</annotation></semantics></math>). Werte die größer sind, werden als "<code>Infinity</code>" (unendlich) repräsentiert.</p> + +<p>Weil <code>MAX_VALUE</code> eine statische Eigenschaft von {{jsxref("Number")}} ist, wird sie immer mit <code>Number.</code> <code>MAX_VALUE</code> abgerufen, im Gegensatz zu einer Eigenschaft eines {{jsxref("Number")}} Objektes, was erstellt wurde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_MAX_VALUE">Einsatz von <code>MAX_VALUE</code></h3> + +<p>Im folgenden Quelltext werden zwei nummerische Werte multipliziert. Wenn das Ergebnis kleiner oder gleich <code>MAX_VALUE</code> ist, wird <code>func1()</code> ausgeführt; andernfalls wird <code>func2() </code>ausgeführt. </p> + +<pre class="brush: js">if (num1 * num2 <= Number.MAX_VALUE) { + func1(); +} else { + func2(); +} +</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. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.2', 'Number.MAX_VALUE')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.max_value', 'Number.MAX_VALUE')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.max_value', 'Number.MAX_VALUE')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.MAX_VALUE")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.MIN_VALUE")}}</li> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/min_safe_integer/index.html b/files/de/web/javascript/reference/global_objects/number/min_safe_integer/index.html new file mode 100644 index 0000000000..4440e7d913 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/min_safe_integer/index.html @@ -0,0 +1,66 @@ +--- +title: Number.MIN_SAFE_INTEGER +slug: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Number.MIN_SAFE_INTEGER</strong></code> Konstante repräsentiert die kleinste sicheren ganze Zahl in JavaScript (<code>-(2<sup>53</sup> - 1)</code>).</p> + +<div>{{EmbedInteractiveExample("pages/js/number-min-safe-integer.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>MIN_SAFE_INTEGER</code> Konstante hat einen Wert von <code>-</code> <code>9007199254740991</code> (-9.007.199.254.740.991 oder ca. -9 <span class="short_text" id="result_box" lang="de"><span>Billiarde</span></span>). Die Bedeutung hinter dieser Zahl ist, dass in JavaScript <a class="external external-icon" href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">double-precision floating-point Zahlen</a> wie sie in <a class="external external-icon" href="http://en.wikipedia.org/wiki/IEEE_floating_point">IEEE 754</a> spezifiziert sind benutzt werden. Nach dieser Spezifikation ist die sichere Repräsentation von Zahlen nur zwischen <code>-(2<sup>53</sup> - 1)</code> und <code>2<sup>53</sup> - 1</code> möglich. Für mehr details Siehe im Artikel {{jsxref("Number.isSafeInteger()")}} nach.</p> + +<p>Weil <code>MIN_SAFE_INTEGER</code> eine statische Eigenschaft von {{jsxref("Number")}} ist, wird sie immer mit <code>Number.MIN_SAFE_INTEGER</code> abgerufen, im Gegensatz zu einer Eigenschaft eines {{jsxref("Number")}} Objektes, was erstellt wurde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Number.MIN_SAFE_INTEGER // -9007199254740991 +-(Math.pow(2, 53) - 1) // -9007199254740991 +</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('ES2015', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.MIN_SAFE_INTEGER")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.isSafeInteger()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/min_value/index.html b/files/de/web/javascript/reference/global_objects/number/min_value/index.html new file mode 100644 index 0000000000..3572b98118 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/min_value/index.html @@ -0,0 +1,83 @@ +--- +title: Number.MIN_VALUE +slug: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Number.MIN_VALUE</code></strong> Eigenschaft repräsentiert den kleinsten nummerische Wert größer als 0, der in JavaScript repräsentiert werden kann.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-min-value.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>MIN_VALUE</code> Eigenschaft ist die die am nächsten an 0 liegende positive Zahl, die JavaScript repräsentieren kann (nicht die kleinste negative Zahl).</p> + +<p><code>MIN_VALUE</code> hat einen ungefähren Wert von <math><semantics><mrow><mn>5</mn><mo>⋅</mo><msup><mn>10</mn><mrow><mo>-</mo><mn>324</mn></mrow></msup></mrow><annotation encoding="TeX">5 \cdot 10^{-324}</annotation></semantics></math>. Zahlen die zwischen <code>MIN_VALUE</code> und 0 liegen ( "underflow values" werden zu 0 konvertiert<code>.</code></p> + +<p>Weil <code>MIN_VALUE</code> eine statische Eigenschaft von {{jsxref("Number")}} ist, wird sie immer mit <code>Number.</code> <code>MIN_VALUE</code> abgerufen, im Gegensatz zu einer Eigenschaft eines {{jsxref("Number")}} Objektes, was erstellt wurde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_MIN_VALUE">Einsatz von <code>MIN_VALUE</code></h3> + +<p>Im folgenden Quelltext werden zwei nummerische Werte dividiert. Wenn das Ergebnis größer oder gleich <code>MIN_VALUE</code> ist, wird <code>func1()</code> ausgeführt; andernfalls wird <code>func2() </code>ausgeführt. </p> + +<pre class="brush: js notranslate">if (num1 / num2 >= Number.MIN_VALUE) { + func1(); +} else { + func2(); +} +</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. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.3', 'Number.MIN_VALUE')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.min_value', 'Number.MIN_VALUE')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.min_value', 'Number.MIN_VALUE')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.MIN_VALUE")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.MAX_VALUE")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/nan/index.html b/files/de/web/javascript/reference/global_objects/number/nan/index.html new file mode 100644 index 0000000000..25614786f3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/nan/index.html @@ -0,0 +1,65 @@ +--- +title: Number.NaN +slug: Web/JavaScript/Reference/Global_Objects/Number/NaN +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Number.NaN</code></strong> Eigenschaft repräsentiert Not-A-Number (keine Nummer). Sie ist identisch zu {{jsxref("NaN")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-nan.html")}}</div> + +<p>Die Eigenschaft <code>Number.NaN</code> ist statisch, weshalb kein {{jsxref("Number")}} Objekt erstellt werden muss.</p> + +<p>{{js_property_attributes(0, 0, 0)}}</p> + +<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> + <p>Initiale Definition. Implementiert in JavaScript 1.1.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.4', 'Number.NaN')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.nan', 'Number.NaN')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.NaN")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>Das globale {{jsxref("NaN")}} Objekt.</li> + <li>Das {{jsxref("Number")}} Objekt.</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/negative_infinity/index.html b/files/de/web/javascript/reference/global_objects/number/negative_infinity/index.html new file mode 100644 index 0000000000..a2cb81a0fb --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/negative_infinity/index.html @@ -0,0 +1,100 @@ +--- +title: Number.NEGATIVE_INFINITY +slug: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Number.NEGATIVE_INFINITY</code></strong> Eigenschaft repräsentiert den Wert der negativen Unendlichkeit.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-negative-infinity.html")}}</div> + + + +<p>Man muss kein Objekt vom Typ {{jsxref("Number")}} erzeugen, um Zugriff zu haben, weil diese Eigenschaft statisch ist (nutze <code>Number.NEGATIVE_INFINITY</code>).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Der Wert von <code>Number.NEGATIVE_INFINITY</code> ist der gleiche wie der negative Wert der Eigenschaft {{jsxref("Infinity")}} des <em>globalen Objektes</em>.</p> + +<p>Der Wert verhält sich leicht unterschiedlich zu der mathematischen Unendlichkeit:</p> + +<ul> + <li>Jeder positive Wert, auch {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, multipliziert mit <code>NEGATIVE_INFINITY</code> ergibt <code>NEGATIVE_INFINITY</code>.</li> + <li>Jeder negative Wert, auch <code>NEGATIVE_INFINITY</code>, multipliziert mit <code>NEGATIVE_INFINITY</code> ergibt {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li>Jeder positive Wert dividiert durch <code>NEGATIVE_INFINITY</code> ergibt 0.</li> + <li>Jeder negative Wert dividiert durch <code>NEGATIVE_INFINITY</code> ergibt 0.</li> + <li>0 multipliziert mit <code>NEGATIVE_INFINITY</code> ergibt {{jsxref("NaN", "NaN")}}.</li> + <li>{{jsxref("NaN")}} multipliziert mit <code>NEGATIVE_INFINITY</code> ergibt {{jsxref("NaN")}}.</li> + <li><code>NEGATIVE_INFINITY</code> dividiert durch jeden negativen Wert, mit Ausnahme <code>von NEGATIVE_INFINITY</code>, ergibt {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li><code>NEGATIVE_INFINITY</code> dividiert durch jeden positiven Wert, mit Ausnahme von {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, ergibt <code>NEGATIVE_INFINITY</code>.</li> + <li><code>NEGATIVE_INFINITY</code> dividiert durch <code>NEGATIVE_INFINITY</code> oder {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}} ergibt {{jsxref("NaN")}}.</li> +</ul> + +<p>Man kann <code>Number.NEGATIVE_INFINITY</code> nutzen, um einen Fehlerfall zu signalisieren, wenn im Normalfall ein endliches Ergebnis erwartet werden kann. Zudem kann ein Wert mit {{jsxref("isFinite")}} auf seine <span class="dpf_sent" id="dpfsent_4">Endlichkeit </span>geprüft werden.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Einsatz_von_NEGATIVE_INFINITY">Einsatz von <code>NEGATIVE_INFINITY</code></h3> + +<p>Im folgenden Beispiel wird der Variablen<code> smallNumber</code> ein kleinerer Wert als der minimale Wert zugewiesen. Wenn das {{jsxref("Statements/if...else", "if")}}-Statement ausgeführt wird, hat <code>smallNumber</code> den Wert <code>-Infinity</code>. In diesem Fall wird der Variablen ein endlicher Wert zugewiesen, um mit dem Wert besser umgehen zu können.</p> + +<pre class="brush: js">var smallNumber = (-Number.MAX_VALUE) * 2; + +if (smallNumber === Number.NEGATIVE_INFINITY) { + smallNumber = returnFinite(); +} +</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. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.5', 'Number.NEGATIVE_INFINITY')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.NEGATIVE_INFINITY")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Infinity", "Infinity")}}</li> + <li>{{jsxref("isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/parsefloat/index.html b/files/de/web/javascript/reference/global_objects/number/parsefloat/index.html new file mode 100644 index 0000000000..d659260090 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/parsefloat/index.html @@ -0,0 +1,72 @@ +--- +title: Number.parseFloat() +slug: Web/JavaScript/Reference/Global_Objects/Number/parseFloat +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Number +translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseFloat +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Number.parseFloat()</code></strong> Methode liest ein String-Argument ein und gibt eine Fließkommazahl zurück. Diese Methode verhält sich identisch zu der globalen Funktion {{jsxref("parseFloat", "parseFloat()")}} und ist Teil von ECMAScript 2015 (das Ziel ist die modularisierung von globalen Funktionen).</p> + +<div>{{EmbedInteractiveExample("pages/js/number-parsefloat.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Number.parseFloat(<var>string</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<p>{{page("de/docs/Web/JavaScript/Reference/Global_Objects/parseFloat", "Parameter")}}</p> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{page("de/docs/Web/JavaScript/Reference/Global_Objects/parseFloat", "Rückgabewert")}}</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Mehr Details und Beispiele sind im Artikel {{jsxref("parseFloat", "parseFloat()")}} nachzuschlagen.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.parseFloat = parseFloat;</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('ES2015', '#sec-number.parsefloat', 'Number.parseFloat')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.parsefloat', 'Number.parseFloat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.parseFloat")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("parseFloat", "parseFloat()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/parseint/index.html b/files/de/web/javascript/reference/global_objects/number/parseint/index.html new file mode 100644 index 0000000000..e9efe16f11 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/parseint/index.html @@ -0,0 +1,77 @@ +--- +title: Number.parseInt() +slug: Web/JavaScript/Reference/Global_Objects/Number/parseInt +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Number +translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Number.parseInt()</code></strong> Methode liest ein String-Argument ein und gibt eine ganze Zahl im angegebenen Zahlensystem zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-parseint.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Number.parseInt(<var>string</var>[, <var>radix</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<div>{{page("de/docs/Web/JavaScript/Reference/Global_Objects/parseInt", "Parameter")}}</div> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{page("de/docs/Web/JavaScript/Reference/Global_Objects/parseInt", "Rückgabewert")}}</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode hat den gleichen Funktionsumfang wie die globalen {{jsxref("parseInt", "parseInt()")}} Funktion:</p> + +<pre class="brush: js">Number.parseInt === parseInt; // true</pre> + +<p>Sie ist Teil von ECMAScript 2015 und hat als Ziel die Modularisierung von globalen Funktionen. Mehr Details und Beispiele im Artikel {{jsxref("parseInt", "parseInt()")}}.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (Number.parseInt === undefined) + Number.parseInt = window.parseInt;</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">Komment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.parseint', 'Number.parseInt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.parseint', 'Number.parseInt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.parseInt")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("parseInt", "parseInt()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/positive_infinity/index.html b/files/de/web/javascript/reference/global_objects/number/positive_infinity/index.html new file mode 100644 index 0000000000..0f9c9b1ccd --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/positive_infinity/index.html @@ -0,0 +1,100 @@ +--- +title: Number.POSITIVE_INFINITY +slug: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY +tags: + - JavaScript + - Number + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY +--- +<div>{{JSRef}}</div> + +<p>Die Eigenschaft <strong><code>Number.POSITIVE_INFINITY</code></strong> repräsentiert den Wert positiv <span class="dpf_sent" id="dpfsent_1">unendlich</span>.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-positive-infinity.html")}}</div> + + + +<p>Man muss kein Objekt vom Typ {{jsxref("Number")}} erzeugen, um Zugriff auf diese <span class="dpf_sent" id="dpfsent_2">Eigenschaft </span>zu bekommen, weil diese eine statische Eigeschaft ist (nutze <code>POSITIVE_INFINITY</code>).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Der Wert <code>Number.POSITIVE_INFINITY</code> ist der gleich wie der der Eigenschaft {{jsxref("Infinity")}} des globalen Objektes.</p> + +<p>Der Wert verhält sich leicht unterschiedlich zu der mathematischen Unendlichkeit:</p> + +<ul> + <li>Jeder positive Wert, auch <code>POSITIVE_INFINITY</code>, multipliziert mit <code>POSITIVE_INFINITY</code> ergibt <code>POSITIVE_INFINITY</code>.</li> + <li>Jeder negative Wert, auch {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, multipliziert mit <code>POSITIVE_INFINITY</code> ergibt {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li> + <li>Jede positive Zahl dividiert durch <code>POSITIVE_INFINITY</code> ergibt positiv 0.</li> + <li>Jede negative Zahl dividiert durch <code>POSITIVE_INFINITY</code> ergibt negativ 0.</li> + <li>0 multipliziert mit <code>POSITIVE_INFINITY</code> ergibt {{jsxref("NaN")}}.</li> + <li>{{jsxref("NaN")}} multipliziert mit <code>POSITIVE_INFINITY</code> ergibt {{jsxref("NaN")}}.</li> + <li><code>POSITIVE_INFINITY</code> dividiert durch jede negative Zahl, mit Ausnahme von {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, ergibt {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li> + <li><code>POSITIVE_INFINITY</code> dividiert durch jede positive Zahl, mit Ausnahme <code>von POSITIVE_INFINITY</code>, ergibt <code>POSITIVE_INFINITY</code>.</li> + <li><code>POSITIVE_INFINITY</code> dividiert durch {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} oder <code>POSITIVE_INFINITY</code> ergibt {{jsxref("NaN")}}.</li> +</ul> + +<p>Man kann <code>Number.POSITIVE_INFINITY</code> nutzen, um einen Fehlerfall zu signalisieren, wenn im Normalfall ein endliches Ergebnis erwartet werden kann. Zudem kann ein Wert mit {{jsxref("isFinite")}} auf seine <span class="dpf_sent" id="dpfsent_4">Endlichkeit </span>geprüft werden.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Einsatz_von_POSITIVE_INFINITY">Einsatz von <code>POSITIVE_INFINITY</code></h3> + +<p>Im folgenden Beispiel wird der Variablen<code> bigNumber</code> ein kleinerer Wert als der minimale Wert zugewiesen. Wenn das {{jsxref("Statements/if...else", "if")}}-Statement ausgeführt wird, hat <code>bigNumber</code> den Wert <code>Infinity</code>. In diesem Fall wird der Variablen ein endlicher Wert zugewiesen, um mit dem Wert besser umgehen zu können.</p> + +<pre class="brush: js">var bigNumber = Number.MAX_VALUE * 2; + +if (bigNumber == Number.POSITIVE_INFINITY) { + bigNumber = returnFinite(); +} +</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. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.6', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.POSITIVE_INFINITY")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/prototype/index.html b/files/de/web/javascript/reference/global_objects/number/prototype/index.html new file mode 100644 index 0000000000..df57903c60 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/prototype/index.html @@ -0,0 +1,89 @@ +--- +title: Number.prototype +slug: Web/JavaScript/Reference/Global_Objects/Number/prototype +tags: + - JavaScript + - Number + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number +--- +<div>{{JSRef}}</div> + +<p>Die Eigenschaft <strong><code>Number.prototype</code></strong> repräsentiert den Prototypen für den {{jsxref("Number")}} Konstruktor.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Alle {{jsxref("Number")}} Instanzen erben von <code>Number.prototype</code>. Das <code>prototype</code> Objekt des {{jsxref("Number")}} Konstruktors kann verändert werden um alle Instanzen von {{jsxref( "Number")}} zu erweitern.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Number.prototype.constructor</code></dt> + <dd>Gibt die Funktion zurück, die die Instanz dieses Objektes erzeugt hat. Als Standardwert ist das das {{jsxref("Number")}} Objekt.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Number.prototype.toExponential()")}}</dt> + <dd>Gibt eine Zeichenkette (<code>string</code>) zurück, die die Nummer in Exponential Notation repräsentiert.</dd> + <dt>{{jsxref("Number.prototype.toFixed()")}}</dt> + <dd>Gibt eine Zeichenkette (<code>string</code>) zurück, die die Nummer als Festkommazahl repräsentiert.</dd> + <dt>{{jsxref("Number.prototype.toLocaleString()")}}</dt> + <dd>Gibt eine Zeichenkette (<code>string</code>) zurück, die die sprachenübliche Repräsentation der Nummer repräsentiert. Überschreibt die {{jsxref("Object.prototype.toLocaleString()")}} Methode.</dd> + <dt>{{jsxref("Number.prototype.toPrecision()")}}</dt> + <dd>Gibt eine Zeichenzette (<code>string</code>) zurück, die die Zahl in einer bestimmten Genauigkeit als Festkommazahl repräsentiert.</dd> + <dt>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Gibt ein Objektliteral zurück, welches das {{jsxref("Number")}} Objekt spezifiziert. Diese Methode kann genutzt werden, um ein neues Objekt zu erzeugen. Überschreibt die {{jsxref("Object.prototype.toSource()")}} Methode.</dd> + <dt>{{jsxref("Number.prototype.toString()")}}</dt> + <dd>Gibt eine Zeichenkette (<code>string</code>) zurück, die die Zahl in einer bestimmten Basis repräsentiert. Überschreibt die {{jsxref("Object.prototype.toString()")}} Methode.</dd> + <dt>{{jsxref("Number.prototype.valueOf()")}}</dt> + <dd>Gibt einen primitiven Wert des Objektes zurück. Überschreibt die {{jsxref("Object.prototype.valueOf()")}} Methode.</dd> +</dl> + +<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. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.prototype")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/toexponential/index.html b/files/de/web/javascript/reference/global_objects/number/toexponential/index.html new file mode 100644 index 0000000000..c392b7012c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/toexponential/index.html @@ -0,0 +1,108 @@ +--- +title: Number.prototype.toExponential() +slug: Web/JavaScript/Reference/Global_Objects/Number/toExponential +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toExponential()</code></strong> Methode gibt eine string-Repräsentation eines {{jsxref("Number")}} Objektes in Exponentialdarstellung zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-toexponential.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toExponential([<var>fractionDigits</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>fractionDigits</code></dt> + <dd>Optional. Eine ganze Zahl, die die Anzahl der Nachkommastellen angibt. Der Standardwert ist die Anzahl der Nachkommastellen, die benötigt werden, um die Zahl genau darzustellen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine string, der das gegebene {{jsxref("Number")}} Objekt in Exponentialdarstellung repräsentiert. Das bedeutet, dass eine Stelle vor dem Komma steht und auf <code>fractionDigits</code> Stellen nach dem Komma gerundet wird.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Wenn <code>fractionDigits</code> zu klein oder groß ist. Werte zwischen 0 und 20 (inklusiv) werden keinen zu keinem {{jsxref("RangeError")}} führen. Manche Implementierungen erlauben es auch kleinere oder größere Wert einzusätzen.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Wenn die Methode auf einem Objekt, welches nicht vom Typ {{jsxref("Number")}} ist, aufgerufen wird.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn das <code>fractionDigits</code> Argument nicht angegeben wird, ist der Standardwert die Anzahl der Stellen, die benötigt werden um die Zahl ohne Verluste darzustellen.</p> + +<p>Wenn die <code>toExponential()</code> Methode für nummerische Literale engesetzt werden und das nummerische Literal keine Nachkommastellen besitzt, sollte ein Leerzeichen nach der Zahl hinzugefügt werden. Das sorgt dafür, dass der Punkt des Methodenaufrufes nicht als Dezimaltrenner (Komma) interpretiert wird.</p> + +<p>Wenn eine Zahl mehr Stellen hat, als im <code>fractionDigits</code> Argument definiert wurde, wird die Zahl zur nächst liegenden Zahl gerundet, die mit <code>fractionDigits</code> Stellen dargestellt werden kann. Weiter Informationen zum Runden sind im Artikel {{jsxref("Number.prototype.toFixed", "toFixed()")}} zu finden, die ebenfalls auf <code>toExponential()</code> zutreffen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toExponential()">Einsatz von <code>toExponential()</code></h3> + +<pre class="brush: js">var numObj = 77.1234; + +console.log(numObj.toExponential()); // logs 7.71234e+1 +console.log(numObj.toExponential(4)); // logs 7.7123e+1 +console.log(numObj.toExponential(2)); // logs 7.71e+1 +console.log(77.1234.toExponential()); // logs 7.71234e+1 +console.log(77 .toExponential()); // logs 7.7e+1 +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.6', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.toExponential")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/tofixed/index.html b/files/de/web/javascript/reference/global_objects/number/tofixed/index.html new file mode 100644 index 0000000000..0fe376aa4d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/tofixed/index.html @@ -0,0 +1,113 @@ +--- +title: Number.prototype.toFixed() +slug: Web/JavaScript/Reference/Global_Objects/Number/toFixed +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toFixed()</code></strong> Methode formatiert eine Zahl in Festkommadarstellung.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-tofixed.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toFixed([<var>digits</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>digits</code></dt> + <dd>Optional: Die Anzahl der Stellen, die nach dem Komma angezeigt werden sollen. Das ist ein Wert zwischen 0 und 20 (inklusiv), jedoch gibt es Implementierungen die optional einen größeren Bereich zulassen. Wenn das Argument nicht angegeben wird, wird der Parameter mit dem Standardwert 0 gesetzt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine String-Repräsentation der gegebenen Zahl in Festkommadarstellung.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>digits</code> zu klein oder groß ist. Werte <code>digits</code> zwischen 0 und 20 (inklusiv) ist, wird es nicht zu einem {{jsxref("RangeError")}} führen. Manche Implementierungen erlauben es auch kleinere oder größere Wert zu benutzen.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Wenn die Methode auf einem Objekt, welches nicht vom Typ {{jsxref("Number")}} ist, aufgerufen wird.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><strong><code>toFixed()</code></strong> gibt eine String-Repräsentation von <code>numObj</code> zurück, die keine Exponentialdarstellung benutzt und genau <code>digits</code> viele Nachkommastellen beseitzt. Wenn es nötig ist, wird eine Zahl gerundet oder fehlende Dezimalstellen werden mit Nullen aufgefüllt, um die gewünschten Nachkommastellen zu erreichen. Wenn <code>numObj</code> größer als 10<sup>21</sup> ist, ruft diese Methode {{jsxref("Number.prototype.toString()")}} auf und gibt den string in Exponentialdarstellung zurück.</p> + +<div class="warning"> +<p>JavaScript Numbers können nicht alle Zahlen präzise darstellen, was zu unerwarteten Ergebnissen führen kann, wie z. B. <code>0.1 + 0.2 === 0.3</code> <code>false</code> ergibt.</p> +</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toFixed">Einsatz von <code>toFixed</code></h3> + +<pre class="brush: js">var numObj = 12345.6789; + +numObj.toFixed(); // Rückgabe: '12346': Gerundet, keine Nachkommastellen +numObj.toFixed(1); // Rückgabe: '12345.7': Gerundet +numObj.toFixed(6); // Rückgabe: '12345.678900': Nullen hinzugefügt +(1.23e+20).toFixed(2); // Rückgabe: '123000000000000000000.00' +(1.23e-10).toFixed(2); // Rückgabe: '0.00' +2.34.toFixed(1); // Rückgabe: '2.3' +2.35.toFixed(1); // Rückgabe: '2.4'. Aufgerundet. +2.55.toFixed(1); // Rückgabe: '2.5'. Abgerundet - siehe die oben stehende Warnung +-2.34.toFixed(1); // Rückgabe: -2.3 (Negative Nummernliterale geben kein String zurück ...) +(-2.34).toFixed(1); // Rückgabe: '-2.3' (... außer es werden explizit Klammern verwendet.) +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.5', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.toFixed")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/tointeger/index.html b/files/de/web/javascript/reference/global_objects/number/tointeger/index.html new file mode 100644 index 0000000000..79545e9ad6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/tointeger/index.html @@ -0,0 +1,52 @@ +--- +title: Number.toInteger() +slug: Web/JavaScript/Reference/Global_Objects/Number/toInteger +tags: + - JavaScript + - Method + - Number + - Obsolete +translation_of: Archive/Web/JavaScript/Number.toInteger +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p>Die <strong><code>Number.toInteger()</code></strong> Methode wurde eingesetzt, um den übegebenen Wert zu analysieren und zu einer ganzen Zahl zu konvertieren, jedoch wurde die Implementierung entfernt.</p> + +<p>Wenn der übergebene Wert {{jsxref("NaN")}}, {{jsxref("null")}} oder {{jsxref("undefined")}} ist, gibt die Methode <code>0</code> zurück. Wenn der Wert <code>false</code> ist, wird <code>0</code> und bei <code>true</code> wird <code>1</code> zurückgegeben.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Number.toInteger(<var>zahl</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>zahl</code></dt> + <dd>Wert der zu einer ganzen Zahl konvertiert werden soll.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toInteger">Einsatz von <code>toInteger</code></h3> + +<pre class="brush: js">Number.toInteger(0.1); // 0 +Number.toInteger(1); // 1 +Number.toInteger(Math.PI); // 3 +Number.toInteger(null); // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p><code>Number.toInteger()</code> war Teil der des ECMAScript 6 Entwurfesspezifikation, jedoch wurde sie am 23. August 2013 im Draft Rev 17 entfernt.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.toInteger")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/tolocalestring/index.html b/files/de/web/javascript/reference/global_objects/number/tolocalestring/index.html new file mode 100644 index 0000000000..5e5e132045 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/tolocalestring/index.html @@ -0,0 +1,192 @@ +--- +title: Number.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString +tags: + - Internationalization + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toLocaleString()</code></strong> Methode gibt eine Zahl als String in sprachabhängiger Formatierung zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-tolocalestring.html")}}</div> + + + +<p>Die neuen <code>locales</code> und <code>options</code> Argumente ermöglichen es Anwendungen, sprachübliche Formatierungskonventionen zu benutzen und diese anzupassen. In älteren Implementierungen werden die <code>locales</code> und <code>options</code> Argumente ignoriert, und die Formatierung des Strings ist implementierungsabhängig.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>numObj</em>.toLocaleString(</code><code>[locales [, options]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<p>Prüfe die <a href="#Browserkompatibilität">Browserkompatibilität</a>, um zu sehen, welcher Browser den <code>locales</code> und <code>options</code> Parameter unterstützt, und das Beispiel <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Unterstützung für <code>locales</code> und <code>options</code> Argumente prüfen</a> für eine Funktionalitätsprüfung.</p> + +<div class="note"> +<p><strong>Anmerkung:</strong> Die ECMAScript Internationalization API, implementiert in Firefox 29, fügte das Argument <code>locales</code> zur Methode <code>Number.toLocaleString()</code> zu. Wenn das Argument {{jsxref("undefined")}} ist, arbeitet die Methode nach der Lokalisierung des OS, während Vorgängerversionen von Firefox <a href="https://en.wikipedia.org/wiki/Arabic_numerals">Western Arabic</a> zurück geben. Diese Änderung wurde als eine Rückwärtskompatibilität gemeldet. Das Problem wurde bereits behoben ({{bug(999003)}}).</p> +</div> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat', 'Parameter')}}</div> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der die gegebene Zahl in einer sprachspezifischen Formatierung repräsentiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toLocaleString()">Einsatz von <code>toLocaleString()</code></h3> + +<p>Bei der Nutzung ohne Parameter wird der string in der Standardsprache ohne Optionen zurückgegeben:</p> + +<pre class="brush: js">var number = 3500; + +console.log(number.toLocaleString()); // Ausgabe: "3.500" wenn in Deutscher locale +</pre> + +<h3 id="Unterstützung_für_locales_und_options_Argumente_prüfen">Unterstützung für <code>locales</code> und <code>options</code> Argumente prüfen</h3> + +<p>Die <code>locales</code> und <code>options</code> Argumente sind noch nicht in allen Browsern unterstützt. Zur Prüfung der Unterstützung von ES5.1 und neueren Implementierungen wird vorausgesetzt, dass unbekannte Sprachen zu einem {{jsxref("RangeError")}} führen, was folgendermaßen eingesetzt werden kann:</p> + +<pre class="brush: js">function toLocaleStringSupportsLocales() { + var number = 0; + try { + number.toLocaleString('i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<p>Vor ES5.1 mussten die Implementierungen keinen {{jsxref("RangeError")}} erzeugen, wenn <code>toLocaleString</code> mit Argumenten aufgerufen wurde.</p> + +<p>Eine Prüfung, die in allen Browser funktioniert, auch in denen, die ECMA-262 vor ES5.1 unterstützen, ist die Prüfung auf Funktionen aus ECMA-402, welche Optionen in <code>Number.prototype.toLocaleString</code> direkt unterstützen:</p> + +<pre class="brush: js">function toLocaleStringSupportsOptions() { + return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function'); +} +</pre> + +<p>Diese Tests auf dem globalen {{jsxref("Intl")}} Objekt prüfen, ob das Objekt existiert und die Eigenschaft vom Typ Funktion {{jsxref("Intl.NumberFormat")}} hat.</p> + +<h3 id="Einsatz_von_locales">Einsatz von <code>locales</code></h3> + +<p>Diese Beispiel zeigt einige der Variationen in internationalen Zahlenformaten. Um das Format der Sprache zu bekommen, welches in der Anwendung benutzt wird, spezifiziere die Sprache (und mögliche Rückfallsprachen (fallback)) mit dem <code>locales</code> Argument.</p> + +<pre class="brush: js">var number = 123456.789; + +// Englische Benutzer sehen ein Punkt anstatt eines Kommas als Dezimaltrenner +console.log(number.toLocaleString('en-GB')); +// → 123.456,789 + +// Arabisch ist in den meisten arabisch Sprechenden Ländern eingesetzt (<a href="https://en.wikipedia.org/wiki/Eastern_Arabic_numerals">Eastern Arabic</a>) Ziffern +console.log(number.toLocaleString('ar-EG')); +// → ١٢٣٤٥٦٫٧٨٩ + +// Indien benutzt Tausendertrennzeichen bei Tausend und allen weiteren <strong>zwei Stellen</strong> +console.log(number.toLocaleString('en-IN')); +// → 1,23,456.789 + +// Chinesisches Zahlensystem +console.log(number.toLocaleString('zh-Hans-CN-u-nu-hanidec')); +// → 一二三,四五六.七八九 + +// Wenn eine Sprache übergeben werden soll, die vielleicht nicht +// unterstützt wird (Balinesisch), nutze eine fallback Sprache (Indonesisch) +console.log(number.toLocaleString(['ban', 'id'])); +// → 123.456,789 +</pre> + +<h3 id="Einsatz_von_options">Einsatz von <code>options</code></h3> + +<p>Das Ergebnis von <code>toLocaleString</code> kann durch das <code>options</code> Argument angepasst werden.</p> + +<pre class="brush: js">var number = 123456.789; + +// Währungsformat +console.log(number.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' })); +// → 123.456,79 € + +// Der Japanische Yen hat keine Unterwährung (z. B. Cent) +console.log(number.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' })) +// → ￥123,457 + +// Limitiert auf drei signifikante Stellen +console.log(number.toLocaleString('en-IN', { maximumSignificantDigits: 3 })); +// → 1,23,000 + +// Einsatz der Host-Standard-Sprache mit Optionen für die Nummernformatierung +var num = 30000.65; +console.log(num.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2})); +// → 30,000.65 wenn Englisch die Standard-Sprache ist, oder +// → 30.000,65 wenn Deutsch die Standard-Sprache ist, oder +// → 30 000,65 wenn Französisch die Standard-Sprache ist +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Wenn eine lange Zahl formatiert werden soll, ist es besser ein {{jsxref("NumberFormat")}} Objekt zu erstellen und die Funktion {{jsxref("NumberFormat.format")}} zu benutzen.</p> + +<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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.3', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Number.prototype.toLocaleString', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.toLocaleString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/toprecision/index.html b/files/de/web/javascript/reference/global_objects/number/toprecision/index.html new file mode 100644 index 0000000000..53a27d59d2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/toprecision/index.html @@ -0,0 +1,107 @@ +--- +title: Number.prototype.toPrecision() +slug: Web/JavaScript/Reference/Global_Objects/Number/toPrecision +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision +--- +<div>{{JSRef}}</div> + +<p>Die <code>toPrecision()</code> Methode gibt einen String zurück, der ein {{jsxref("Number")}} Objekt mit einer spezifizierten Präzision repräsentiert.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-toprecision.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>numObj</var>.toPrecision([<var>precision</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>precision</code></dt> + <dd>Optional. Eine ganze Zahl, die die signifikanten Ziffern der Zahl angibt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein string, der ein {{jsxref("Number")}} Objekt in Fließkomma- oder Exponentialdarstellung auf die in <code>precision</code> angegeben Stellen gerundet zurück gibt. Weitere Informationen zum runden in dieser Methode sind in der Beschreibung von {{jsxref("Number.prototype.toFixed()")}} zu finden, die auch auf <code>toPrecision()</code> zutreffen.</p> + +<p>Wenn kein <code>precision</code> Argument angegeben wird, ist die rückgabe wie in der {{jsxref("Number.prototype.toString()")}} Methode. Wenn die <code>precision</code> keine ganze Zahl ist, wird zu der am nächst liegenden ganzen Zahl gerundet.</p> + +<h3 id="Auftretende_Fehler">Auftretende Fehler</h3> + +<dl> + <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt> + <dd>Wenn <code>precison</code> keine Zahl zwischen 1 und 100 (inklusiv) ist, tritt ein {{jsxref("RangeError")}} auf. Es gibt implementierungen die mehr und weniger signifikante Stellen zulassen. ECMA-262 spezifiziert nur eine Präzision von 21 signifikanten Stellen.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toPrecision">Einsatz von <code>toPrecision</code></h3> + +<pre class="brush: js">var numObj = 5.123456; + +console.log(numObj.toPrecision()); // Ausgabe: 5.123456 +console.log(numObj.toPrecision(5)); // Ausgabe: 5.1235 +console.log(numObj.toPrecision(2)); // Ausgabe: 5.1 +console.log(numObj.toPrecision(1)); // Ausgabe: 5 + +numObj = 0.000123 + +console.log(numObj.toPrecision()); // logs 0.000123 +console.log(numObj.toPrecision(5)); // logs 0.00012300 +console.log(numObj.toPrecision(2)); // logs 0.00012 +console.log(numObj.toPrecision(1)); // logs 0.0001 + +// In manchen Fällen wird die Exponentialdarstellung ausgegeben. +console.log((1234.5).toPrecision(2)); // Ausgabe: 1.2e+3 +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.7', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.toPrecision")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/tosource/index.html b/files/de/web/javascript/reference/global_objects/number/tosource/index.html new file mode 100644 index 0000000000..985df99c0a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/tosource/index.html @@ -0,0 +1,53 @@ +--- +title: Number.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Number/toSource +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <strong><code>toSource()</code></strong> Methode gibt einen string zurück, der den Quelltext des Objektes repräsentiert.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>numObj</var>.toSource() +Number.toSource()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der den Quelltext des Objektes repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toSource()</code> gibt die folgenden Werte zurück:</p> + +<p>Für das globale Standardobjekt {{jsxref("Number")}} gibt <code>toSource()</code> den folgenden string zurück, um anzuzeigen, dass der Quelltext nicht verfügbar ist:</p> + +<pre class="brush: js">function Number() { + [native code] +} +</pre> + +<p>Für Instanzen von {{jsxref("Number")}}, gibt <code>toSource()</code> einen string mit dem Quelltext zurück.</p> + +<p>Diese Methode wird intern von JavaScript aufgerufen und wird nicht im Quelltext von Webseiten verwendet.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Ist in keinem Standard. Implementiert in JavaScript 1.3.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.toSource")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/tostring/index.html b/files/de/web/javascript/reference/global_objects/number/tostring/index.html new file mode 100644 index 0000000000..ed5d600b3a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/tostring/index.html @@ -0,0 +1,116 @@ +--- +title: Number.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Number/toString +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toString()</code></strong> Methode gibt einen string (Zeichenkette), die ein {{jsxref("Number")}} Objekt repräsentiert zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-tostring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toString([<var>radix</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>radix</code></dt> + <dd>Optional. Eine ganze Zahl im Bereich von 2 bis 36 welche die Basis des Zahlensystems angibt, in dem die Zahl repräsentiert werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der das spezifizierte {{jsxref("Number")}} Objekt repräsentiert.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Wenn <code>toString()</code> als <em>radix</em> Parameter eine Zahl kleiner 2 oder größer 36 übergeben bekommt, wird ein {{jsxref("RangeError")}} erzeugt.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das {{jsxref("Number")}} Objekt überschreibt die <code>toString()</code> Methode des {{jsxref("Object")}} Objektes. Es erbt nicht von der {{jsxref("Object.prototype.toString()")}} Methode. Für {{jsxref( "Number")}} Objekte gibt die <code>toString()</code> Methode eine string-Repräsentation des Objektes in dem durch <em>radix</em> spezifizierten Zahlensystem zurück.</p> + +<p>Die <code>toString()</code> Methode analysiert das erste Argument und versucht eine string-Repräsentation im durch <em>radix</em> beschriebenen Zahlensystem zurück zu geben. Für <em>radix</em> (Basen) größer als 10 werden Buchstaben des Alphabets genutzt um Zahlen größer als 9 darzustellen. Zum Beispiel werden im Hexadezimalsystem (Basis 16) die Buchstaben <code>a</code> bis <code>f</code> eingesetzt.</p> + +<p>Wenn der <em>radix</em> Parameter nicht angegeben wird, wird 10, also das Dezimalsystem, angenommen.</p> + +<p>Wenn das <code>numObj</code> Objekt negativ ist, wird das Vorzeichen beibehalten. Dieses Verhalten ist auch im Binärsystem so: Der zurückgegebene string ist eine positive Binärdarstellung des <code>numObj</code> Objekts mit einem vorangestellten Minus (<code>-)</code> Zeichen. Es wird kein Zweierkomplement verwendet.</p> + +<p>Wenn das <code>numObj</code> Objekt keine ganze Zahl ist, wird ein Punkt (<code>.</code>) eingesetzt, um den ganzzahligen Teil von den Dezimalstellen zu trennen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toString">Einsatz von <code>toString</code></h3> + +<pre class="brush: js">var count = 10; + +console.log(count.toString()); // Ausgabe '10' +console.log((17).toString()); // Ausgabe '17' +console.log((17.2).toString()); // Ausgabe '17.2' + +var x = 6; + +console.log(x.toString(2)); // Ausgabe '110' +console.log((254).toString(16)); // Ausgabe 'fe' + +console.log((-10).toString(2)); // Ausgabe '-1010' +console.log((-0xff).toString(2)); // Ausgabe '-11111111' +</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. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.2', 'Number.prototype.tostring')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.toString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/number/valueof/index.html b/files/de/web/javascript/reference/global_objects/number/valueof/index.html new file mode 100644 index 0000000000..1538417ebf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/number/valueof/index.html @@ -0,0 +1,85 @@ +--- +title: Number.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Number/valueOf +tags: + - JavaScript + - Method + - Number + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/valueOf +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>valueOf()</code></strong> Methode gibt den im {{jsxref("Number")}} Objekt eingeschlossenen primitiven Wert zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-valueof.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.valueOf()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein primitiver Wert (Zahl), der die Zahl des {{jsxref("Number")}} Objektes repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die Methode wird intern von JavaScript aufgerufen, jedoch nicht explizit in einem programmierten Quelltext für eine Webseite eingesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_valueOf">Einsatz von <code>valueOf</code></h3> + +<pre class="brush: js">var numObj = new Number(10); +console.log(typeof numObj); // object + +var num = numObj.valueOf(); +console.log(num); // 10 +console.log(typeof num); // number +</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. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.4', 'Number.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.Number.valueOf")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.prototype.toSource()")}}</li> +</ul> |