diff options
Diffstat (limited to 'files/de/web/javascript/reference/global_objects')
374 files changed, 47317 insertions, 0 deletions
diff --git a/files/de/web/javascript/reference/global_objects/array/@@iterator/index.html b/files/de/web/javascript/reference/global_objects/array/@@iterator/index.html new file mode 100644 index 0000000000..790a7abcff --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/@@iterator/index.html @@ -0,0 +1,89 @@ +--- +title: 'Array.prototype[@@iterator]()' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +tags: + - Array + - ECMAScript 2015 + - Iterator + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +--- +<div>{{JSRef}}</div> + +<div>Der Initialwert der <code><strong>@@iterator</strong></code> Eigenschaft ist das selbe Funktionsobjekt wie der Initialwert der {{jsxref("Array.prototype.values()", "values()")}} Eigenschaft.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>[Symbol.iterator]()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Initialwert für den {{jsxref("Array.prototype.values()", "values()")}} <strong>Iterator</strong>. Im Standardfall gibt <code>arr[Symbol.iterator]</code> die Funktion von {{jsxref("Array.prototype.values()", "values()")}} zurück.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Iterieren_mit_einer_for...of_Schleife">Iterieren mit einer <code>for...of</code> Schleife</h3> + +<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p']; +var eArr = arr[Symbol.iterator](); +// your browser must support for..of loop +// and let-scoped variables in for loops +for (let letter of eArr) { + console.log(letter); +} +</pre> + +<h3 id="Alternative_Iteration">Alternative Iteration</h3> + +<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p']; +var eArr = arr[Symbol.iterator](); +console.log(eArr.next().value); // w +console.log(eArr.next().value); // y +console.log(eArr.next().value); // k +console.log(eArr.next().value); // o +console.log(eArr.next().value); // p +</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-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.@@iterator")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("Array.prototype.values()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/@@species/index.html b/files/de/web/javascript/reference/global_objects/array/@@species/index.html new file mode 100644 index 0000000000..c4de8a7978 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/@@species/index.html @@ -0,0 +1,76 @@ +--- +title: 'get Array[@@species]' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@species +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@species +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Array[@@species]</strong></code> Zugriffseigenschaft gibt den Array Konstruktor zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Array[Symbol.species] +</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der {{jsxref("Array")}} Konstruktor.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>species</code> Zugriffseigenschaft gibt den Standard-Konstruktor des <code>Array</code> Objekts zurück. Unterklassen können die Zuweisung Überschreiben, um die Konstruktorzuweisung ändern.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Die <code>species</code> Eigenschaft gibt die Standard-Konstruktor-Funktion, welches der <code>Array</code> Konstruktor für <code>Array</code> Objekte ist.</p> + +<pre class="brush: js">Array[Symbol.species]; // function Array()</pre> + +<p>In einem abgeleiteten Collection Objekt (z. B. ein benutzerdefiniertes Array <code>MyArray</code>), ist der <code>MyArray</code> der species des <code>MyArray</code> Konstruktors. Manchmal möchte man in abgeleiteten Klassenden Oberklassenkonstruktor zurückgeben. Dieses kann mit Überschreiben erreicht werden:</p> + +<pre class="brush: js">class MyArray extends Array { + // Overwrite MyArray species to the parent Array constructor + static get [Symbol.species]() { return Array; } +}</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-get-array-@@species', 'get Array [ @@species ]')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-array-@@species', 'get Array [ @@species ]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.@@species")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Symbol.species")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/@@unscopables/index.html b/files/de/web/javascript/reference/global_objects/array/@@unscopables/index.html new file mode 100644 index 0000000000..2cb4b51b11 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/@@unscopables/index.html @@ -0,0 +1,76 @@ +--- +title: 'Array.prototype[@@unscopables]' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>@@unscopable</strong></code> Symbol Eigenschaft enthält Namen von Eigenschaften, welche vor der ES2015 Version nicht im ECMAScript Standard waren. Diese Eigenschaften werden bei <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> Statement Bindungen ignoriert.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>[Symbol.unscopables]</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Der Standard Array Eigenschaften, die von den <code>with</code> Bindungen ausgenommen werden, sind: <code>copyWithin</code>, <code>entries</code>, <code>fill</code>, <code>find</code>, <code>findIndex</code>, <code>includes</code>, <code>keys</code>, und <code>values</code>.</p> + +<p>Siehe {{jsxref("Symbol.unscopables")}} für das setzten von <code>unscopables</code> für eigene Objekte</p> + +<p>{{js_property_attributes(0,0,1)}}</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Der Folgende Quelltext funktioniert in ES5 und niedriger. Jedoch wurde in ECMAScript 2015 und Später die {{jsxref("Array.prototype.keys()")}} eingeführt. Das bedeutet, dass in <code>with</code> Umgebungen "keys" jetzt eine Methode und keine Variable ist. Hier kommt die eingebaute <code>@@unscopables</code> <code>Array.prototype[@@unscopables]</code> Symboleigenschaft ins Spiel und verhindert, dass einige der Array Methoden in einer <code>with</code> Anweisung gescoped werden.</p> + +<pre class="brush: js">var keys = []; + +with (Array.prototype) { + keys.push('something'); +} + +Object.keys(Array.prototype[Symbol.unscopables]); +// ["copyWithin", "entries", "fill", "find", "findIndex", +// "includes", "keys", "values"]</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('ES2015', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.@@unscopables")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Symbol.unscopables")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/concat/index.html b/files/de/web/javascript/reference/global_objects/array/concat/index.html new file mode 100644 index 0000000000..6bd46675da --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/concat/index.html @@ -0,0 +1,156 @@ +--- +title: Array.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/Array/concat +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>concat()</code></strong> führt zwei oder mehr Arrays zu einem zusammen. Die Methode ändert nicht die existierenden Arrays, sondern gibt stattdessen ein neues zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-concat.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox">var <var>new_array</var> = <var>old_array</var>.concat(<var>value1</var>[, <var>value2</var>[, ...[, <var>valueN</var>]]])</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>value<em>N</em></code></dt> + <dd>Arrays und/oder Werte, die mit dem aktuellen zu einem neuen Array zusammenführt werden sollen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine neue {{jsxref("Array")}} Instanz.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>concat</code> generiert ein neues Array. Dieses besteht aus den Elementen des Arrays, auf dem diese Methode aufgerufen wurde, gefolgt von dem Element oder den Elementen, die als Argument übergeben wurden.</p> + +<p>Die <code>concat </code>Methode verändert nicht das <code>this</code> Objekt oder eines der übergebenen Argumente, sondern gibt eine flache Kopie (<em>shallow copy</em>) zurück, die Kopien der Elemente in den ursprünglichen Arrays enthält. Elemente der ursprünglichen Arrays werden folgendermaßen in das neue Array kopiert:</p> + +<ul> + <li>Objektreferenzen (und nicht das eigentliche Objekt): <code>concat</code> kopiert Objektreferenzen in das neue Array. Sowohl das ursprüngliche Array als auch das neue Array zeigen auf das gleiche Objekt. Das heißt, wenn ein referiertes Objekt verändert wird, sind diese Änderungen sowohl im neuen als auch in den ursprünglichen Arrays sichtbar.</li> + <li>Zeichenketten (Strings), Zahlen und Booleane (nicht {{jsxref("Global_Objects/String", "String")}}, {{jsxref("Global_Objects/Number", "Number")}} und {{jsxref("Global_Objects/Boolean", "Boolean")}} Objekte): <code>concat</code> kopiert die Werte von Strings und Zahlen in das neue Array.</li> +</ul> + +<div class="note"> +<p><strong>Anmerkung:</strong> Die Zusammenführung von Arrays und Werten verändert die Ausgangswerte und -objekte nicht. Etwaige weitere Operationen auf dem neuen Array (nur wenn Elemente keine Objekt-Referenz sind) haben keine Auswirkungen auf die Ausgangsarrays und umgekehrt.</p> +</div> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Concatenating_two_arrays" name="Example:_Concatenating_two_arrays">Zusammenführen zweier Arrays</h3> + +<p>Der folgende Quellcode führt zwei Arrays zusammen:</p> + +<pre class="brush: js">var alpha = ['a', 'b', 'c'],; +var numeric = [1, 2, 3]; + +alpha.concat(numeric); +// Result: ['a', 'b', 'c', 1, 2, 3] +</pre> + +<h3 id="Example:_Concatenating_three_arrays" name="Example:_Concatenating_three_arrays">Zusammenführen von drei Arrays</h3> + +<p>Der folgende Quellcode führt drei Arrays zusammen:</p> + +<pre class="brush: js">var num1 = [1, 2, 3], + num2 = [4, 5, 6], + num3 = [7, 8, 9]; + +var nums = num1.concat(num2, num3); + +console.log(nums); +// Result: [1, 2, 3, 4, 5, 6, 7, 8, 9] +</pre> + +<h3 id="Example:_Concatenating_three_arrays" name="Example:_Concatenating_three_arrays">Zusammenführen von Werten in ein Array</h3> + +<p>Der folgende Quellcode führt drei Werte in ein Array zusammen:</p> + +<pre class="brush: js">var alpha = ['a', 'b', 'c']; + +var alphaNumeric = alpha.concat(1, [2, 3]); + +console.log(alphaNumeric); +// Result: ['a', 'b', 'c', 1, 2, 3] +</pre> + +<h3 id="Zusammenführen_von_geschachtelten_Arrays">Zusammenführen von geschachtelten Arrays</h3> + +<p>Der folgende Quellcode führt inneinander geschachtelte Array zusammen und demonstriert die Erhaltung der Referenzen:</p> + +<pre class="brush: js">var num1 = [[1]]; +var num2 = [2, [3]]; + +var nums = num1.concat(num2); + +console.log(nums); +// result in [[1], 2, [3]] + +// modify the first element of num1 +num1[0].push(4); + +console.log(nums); +// results in [[1, 4], 2, [3]]; +</pre> + +<h2 id="Specifications" name="Specifications">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.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.4', 'Array.prototype.concat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.concat', 'Array.prototype.concat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.concat', 'Array.prototype.concat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.concat")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.push", "push")}} / {{jsxref("Array.pop", "pop")}} — Hinzufügen/Entfernen eines Elemente am Ende des Arrays.</li> + <li>{{jsxref("Array.unshift", "unshift")}} / {{jsxref("Array.shift", "shift")}} — Hinzufügen/Entfernen eines Elemente am Beginn des Arrays.</li> + <li>{{jsxref("Array.splice", "splice")}} — Hinzufügen/Entfernen eines Elemente an der angegebenen Stelle im Array.</li> + <li>{{jsxref("String.prototype.concat()")}}</li> + <li>{{jsxref("Symbol.isConcatSpreadable")}} – Kontrolle über flaches Konkatinieren.</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/copywithin/index.html b/files/de/web/javascript/reference/global_objects/array/copywithin/index.html new file mode 100644 index 0000000000..6a7e9391d6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/copywithin/index.html @@ -0,0 +1,187 @@ +--- +title: Array.prototype.copyWithin() +slug: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>copyWithin()</strong></code> Methode kopiert einen Teil eines Arrays in eine andere Stelle des gleichen Arrays und gibt das Array zurück, ohne die Länge des Arrays zu verändern.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-copywithin.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.copyWithin(<var>target</var>) +<var>arr</var>.copyWithin(<var>target</var>, <var>start) +arr</var>.copyWithin(<var>target</var>, <var>start</var>, <var>end</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>target</code></dt> + <dd>Null-Basierter Index an dem die kopierte Sequenz kopiert wird. Wenn <code>target</code> negativ ist, wird vom Ende angefangen zu zählen.</dd> + <dd>Wenn <code>target</code> glößer oder gleich <code>arr.length</code> ist, wird nicht kopiert. Wenn <code>target</code> nach <code>start</code> positioniert ist, wird die kopierte Sequenz gekürzt, um in die Länge des Arrays zu passen.</dd> + <dt><code>start</code> {{optional_inline}}</dt> + <dd>Null-Basierter Index an dem das Kopieren begonnen werden soll. Wenn <code>start</code> negativ ist, wird vom Ende angefangen zu zählen.</dd> + <dd>Wenn <code>start</code> nicht angegeben wird, nutzt <code>copyWithin</code> den Standardwert 0.</dd> + <dt><code>end</code> {{optional_inline}}</dt> + <dd>Null-Basierter Index an dem das Kopieren beendet werden soll. <code>end</code> ist exklusiv und wird deswegen nicht mitkopiert. Wenn <code>end</code> negativ ist, wird vom Ende angefangen zu zählen.</dd> + <dd>Wenn <code>end</code> nicht angegeben wird, nutzt <code>copyWithin</code> den Standardwert <code>arr.length</code>.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das geänderte Array</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>copyWithin</code> arbeitet wie die <code>memcpy</code> Funktion in C und C++ und ist eine hoch perfomante Methode zum Verschieben von Daten in einem {{jsxref("Array")}} oder {{jsxref("TypedArray")}}. Die Sequenz wird in einer Operation kopiert und eingefügt; Die eingefügte Sequenz wird den kopierten Wert haben, auch wenn sich die Regionen im Array überschneiden.</p> + +<p>Die <code>copyWithin</code> Funktion ist absichtlich generisch. Es wird nicht vorausgesetzt, dass <code>this</code> ein {{jsxref("Array")}} Objekt ist.</p> + +<p>Die <code>copyWithin</code> Methode ist eine veränderbare Methode. Sie ändert nichts an der Länge von <code>this</code>, aber sie ändert den Inhalt von <code>this</code> und erstellt neue Eigenschaften, wenn es notwendig ist.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<pre class="brush: js">[1, 2, 3, 4, 5].copyWithin(-2); +// [1, 2, 3, 1, 2] + +[1, 2, 3, 4, 5].copyWithin(0, 3); +// [4, 5, 3, 4, 5] + +[1, 2, 3, 4, 5].copyWithin(0, 3, 4); +// [4, 2, 3, 4, 5] + +[1, 2, 3, 4, 5].copyWithin(-2, -3, -1); +// [1, 2, 3, 3, 5] + +[].copyWithin.call({length: 5, 3: 1}, 0, 3); +// {0: 1, 3: 1, length: 5} + +// ES2015 Typed-Arrays sind Unterklassen von Array +var i32a = new Int32Array([1, 2, 3, 4, 5]); + +i32a.copyWithin(0, 2); +// Int32Array [3, 4, 5, 4, 5] + +// Für Plattformen die noch nicht ES6 unterstützen: +[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4); +// Int32Array [4, 2, 3, 4, 5] +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<pre>if (!Array.prototype.copyWithin) { + Array.prototype.copyWithin = function(target, start/*, end*/) { + // Steps 1-2. + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + var O = Object(this); + + // Steps 3-5. + var len = O.length >>> 0; + + // Steps 6-8. + var relativeTarget = target >> 0; + + var to = relativeTarget < 0 ? + Math.max(len + relativeTarget, 0) : + Math.min(relativeTarget, len); + + // Steps 9-11. + var relativeStart = start >> 0; + + var from = relativeStart < 0 ? + Math.max(len + relativeStart, 0) : + Math.min(relativeStart, len); + + // Steps 12-14. + var end = arguments[2]; + var relativeEnd = end === undefined ? len : end >> 0; + + var final = relativeEnd < 0 ? + Math.max(len + relativeEnd, 0) : + Math.min(relativeEnd, len); + + // Step 15. + var count = Math.min(final - from, len - to); + + // Steps 16-17. + var direction = 1; + + if (from < to && to < (from + count)) { + direction = -1; + from += count - 1; + to += count - 1; + } + + // Step 18. + while (count > 0) { + if (from in O) { + O[to] = O[from]; + } else { + delete O[to]; + } + + from += direction; + to += direction; + count--; + } + + // Step 19. + return O; + }; +}</pre> + +<h2 id="Specifications" name="Specifications">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-array.prototype.copywithin', 'Array.prototype.copyWithin')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES2016', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}}</td> + <td>{{Spec2('ES2016')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.copywithin', 'Array.prototype.copyWithin')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.copyWithin")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/entries/index.html b/files/de/web/javascript/reference/global_objects/array/entries/index.html new file mode 100644 index 0000000000..2bd4fb9942 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/entries/index.html @@ -0,0 +1,84 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Array/entries +tags: + - Array + - ECMAScript 2015 + - Iterator + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>entries()</strong></code> Methode gibt ein neues <code><strong>Array Iterator</strong></code> Objekt zurück, das Schlüssel-Wert-Paare für jeden Index im Array enthält.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-entries.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.entries()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues {{jsxref("Array")}}-iterator Objekt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_einer_for…of_Schleife">Einsatz einer <a href="/de/docs/Web/JavaScript/Reference/Statements/for...of">for…of</a> Schleife</h3> + +<pre class="brush:js">var a = ['a', 'b', 'c']; +var iterator = a.entries(); + +for (let e of iterator) { + console.log(e); +} +// [0, 'a'] +// [1, 'b'] +// [2, 'c'] +</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-array.prototype.entries', 'Array.prototype.entries')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.entries")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.values()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li><a href="/de/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/every/index.html b/files/de/web/javascript/reference/global_objects/array/every/index.html new file mode 100644 index 0000000000..a29a0e4e0c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/every/index.html @@ -0,0 +1,195 @@ +--- +title: Array.prototype.every() +slug: Web/JavaScript/Reference/Global_Objects/Array/every +tags: + - Array + - ECMAScript 5 + - JavaScript + - Method + - Prototype + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/every +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>every()</strong></code> Methode testet ob alle Elemente in einem Array einen Test bestehen, welcher mittels einer implementierten Funktion bereitgestellt wird.</p> + +<div class="note"> +<p>Hinweis: Diese Methode gibt <code>true</code> für jede Bedingung bei einem leeren Array zurück.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/array-every.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.every(<var>callback</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funktion welche jedes Element testet, mit drei Argumenten: + <dl> + <dt><code>currentValue</code> (required)</dt> + <dd>Der aktuelle Wert des Arrays.</dd> + <dt><code>index</code>{{Optional_inline}}</dt> + <dd>Der Index des aktuellen Elementes im Array.</dd> + <dt><code>array</code>{{Optional_inline}}</dt> + <dd>Das Array auf welchem <code>every</code> aufgerufen wurde.</dd> + </dl> + </dd> + <dt><code>thisArg</code>{{Optional_inline}}</dt> + <dd>Optional. Wert welcher als <code>this</code> in der <code>callback </code> Funktion benutzt wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><code><strong>true</strong></code> wenn die callback-Funktion einen {{Glossary("truthy")}} Wert für jedes Array-Element zurückgibt, andernfalls <code><strong>false</strong></code>.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>every</code> Methode führt die übergebene <code>callback</code> Funktion für jedes Element in dem Array aus, solange die <code>callback</code> Funktion keinen {{Glossary("falsy")}} Wert zurückgibt. Wenn ein solches Element gefunden wird gibt die <code>every</code> Methode <code>false</code> zurück. Anderfalls, wenn<code> callback</code> für jedes Element einen {{Glossary("truthy")}} Wert zurück gibt, gibt die Funktion <code>every</code> <code>true</code> zurück. Die <code>callback</code> Funktion wird nur für Indizes im Array aufgerufen, denen ein Wert zugewiesen wurde; sie wird nicht aufgerufen für Indizes, die gelöscht wurden, oder welche, die nie beschrieben wurden.</p> + +<p>Die <code>callback</code> Funktion wird mit drei Argumenten aufgerufen: Der Wert eines Elements, der Index des Elements und Array auf dem <code>every</code> aufgerufen wurde.</p> + +<p>Wenn der <code>thisArg</code> Parameter von <code>every</code> angegeben wird, wird auf diesem Objekt die <code>callback</code> Funktion aufgerufen und dieses Objekt kann mit <code>this</code> aufgerufen werden. Anderfalls wird der Wert <code>undefined</code> für den Einsatz von <code>this</code> übergeben. Der <code>this</code> Wert ist nur in der <code>callback</code> Funktion verfügbar und wird nach den <a href="/de/docs/Web/JavaScript/Reference/Operators/this">normalen Regeln für das ermitteln von this</a> für die Funktion ermittelt.</p> + +<p>Die <code>every</code> Funktion verändert nicht die Werte des Arrays, auf dem sie aufgerufen wird.</p> + +<p>Die Anzahl der von <code>every</code> abzuarbeitenden Elemente wird vor dem ersten Aufruf von <code>callback</code> ermittelt. Elemente welche nach dem Aufruf von <code>every</code> angehängt werden, werden nicht von der <code>callback</code> Funktion besucht. Wenn existierende Element eines Arrays geändert werden, wird der <code>callback</code> Funktion der Wert übergeben, der zu dem Zeitpunkt des Aufrufens von <code>callback</code> im Array steht. Werte die gelöscht werden, werden nicht besucht.</p> + +<p><code>every</code> Arbeitet wie ein <a href="https://de.wikipedia.org/wiki/Quantor#Existenz-_und_Allquantor">Allquantor</a> in der Mathematik. Wenn das Array leer ist, gibt er <code>true</code> zurück. (Es ist wahr, dass alle Elemente einer <a href="https://de.wikipedia.org/wiki/Leere_Menge">leeren Menge</a> immer alle Bedingungen erfüllen.)</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Größe_aller_Arrayelemente_abprüfen">Größe aller Arrayelemente abprüfen</h3> + +<p>Das folgende Beispiel testet, ob alle Elemente in einem Array größer oder gleich 10 sind.</p> + +<pre class="brush: js">function isBigEnough(element, index, array) { + return element >= 10; +} +[12, 5, 8, 130, 44].every(isBigEnough); // false +[12, 54, 18, 130, 44].every(isBigEnough); // true +</pre> + +<h3 id="Einsatz_von_arrow_Funktionen">Einsatz von arrow Funktionen</h3> + +<p><a href="/de/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Arrow Funktionen</a> unterstützen eine kürzere Syntax für den gleichen Test.</p> + +<pre class="brush: js">[12, 5, 8, 130, 44].every(elem => elem >= 10); // false +[12, 54, 18, 130, 44].every(elem => elem >= 10); // true</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>every</code> wurde im ECMA-262 Standard in der 5. Auflage hinzugefügt. Es kann sein, dass diese Funktion in anderer Implementierungen des Standards nicht vorkommt. Man dieses beheben, indem man den folgenden Quelltext an den Anfang eines Programms hinzufügt. Dadurch wird die <code>every</code> Funktion dort hinzugefügt, wo sie nicht nativ unterstützt wird. Der Algorithmus ist exakt der aus der 5. Auflage des ECMA-262 Standards, mit der Voraussetzung, dass <code>Object</code> und <code>TypeError</code> ihre originalen Werte haben und dass <code>callbackfn.call</code> die originale Funktion {{jsxref("Function.prototype.call")}} aufrufen kann.</p> + +<pre class="brush: js">if (!Array.prototype.every) { + Array.prototype.every = function(callbackfn, thisArg) { + 'use strict'; + var T, k; + + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + // 1. Let O be the result of calling ToObject passing the this + // value as the argument. + var O = Object(this); + + // 2. Let lenValue be the result of calling the Get internal method + // of O with the argument "length". + // 3. Let len be ToUint32(lenValue). + var len = O.length >>> 0; + + // 4. If IsCallable(callbackfn) is false, throw a TypeError exception. + if (typeof callbackfn !== 'function') { + throw new TypeError(); + } + + // 5. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 1) { + T = thisArg; + } + + // 6. Let k be 0. + k = 0; + + // 7. Repeat, while k < len + while (k < len) { + + var kValue; + + // a. Let Pk be ToString(k). + // This is implicit for LHS operands of the in operator + // b. Let kPresent be the result of calling the HasProperty internal + // method of O with argument Pk. + // This step can be combined with c + // c. If kPresent is true, then + if (k in O) { + + // i. Let kValue be the result of calling the Get internal method + // of O with argument Pk. + kValue = O[k]; + + // ii. Let testResult be the result of calling the Call internal method + // of callbackfn with T as the this value and argument list + // containing kValue, k, and O. + var testResult = callbackfn.call(T, kValue, k, O); + + // iii. If ToBoolean(testResult) is false, return false. + if (!testResult) { + return false; + } + } + k++; + } + return true; + }; +} +</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('ES5.1', '#sec-15.4.4.16', 'Array.prototype.every')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.every', 'Array.prototype.every')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.every', 'Array.prototype.every')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.every")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("TypedArray.prototype.every()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/fill/index.html b/files/de/web/javascript/reference/global_objects/array/fill/index.html new file mode 100644 index 0000000000..5f4821e986 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/fill/index.html @@ -0,0 +1,155 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Reference/Global_Objects/Array/fill +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>fill()</strong></code> Methode befüllt ein Array mit einem statischen Wert von einem Startindex bis zu einem Endindex. Der Endindex wird nicht mit eingeschlossen.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-fill.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.fill(<var>value</var>[, <var>start<var>[, <var>end</var>]])</var></var></code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Wert, mit dem ein Array gefüllt werden soll.</dd> + <dt><code>start</code> {{optional_inline}}</dt> + <dd>Startindex, Standardwert ist 0.</dd> + <dt><code>end</code> {{optional_inline}}</dt> + <dd>Endindex, Standardwert ist <code>this.length</code>.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das geänderte Array.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <strong><code>fill</code></strong> Methode nimmt bis zu drei Argumente entgegen: <code>value</code>, <code>start</code> und <code>end</code>. Die Argumente <code>start</code> und <code>end</code> sind optional und haben als Standardwert 0 und <code>length</code> des <code>this</code> Objektes.</p> + +<p>Wenn <code>start</code> negativ ist, wird stattdessen <code>length+start</code> benutzt, wobei <code>length</code> die Länge des Arrays ist. Wenn <code>end</code> negativ ist, wird stattdessen <code>length+end</code> benutzt.</p> + +<p>Die <code><strong>fill</strong></code> Funktion ist absichtlich generisch. Es ist nicht nötig, dass der <code>this</code> Wert ein Array Objekt ist.</p> + +<p>Die <code><strong>fill</strong></code> Methode ist eine verändernde Methode. Sie verändert das <code>this</code> Objekt selbst und gibt dieses zurück. Sie erstellt keine Kopie des Objektes.</p> + +<p>Wenn der <code><strong>fill</strong></code> Methode ein Objekt übergeben wird, wird das Objekt kopiert und die Referenz der Kopie wird im Array eingesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">[1, 2, 3].fill(4); // [4, 4, 4] +[1, 2, 3].fill(4, 1); // [1, 4, 4] +[1, 2, 3].fill(4, 1, 2); // [1, 4, 3] +[1, 2, 3].fill(4, 1, 1); // [1, 2, 3] +[1, 2, 3].fill(4, 3, 3); // [1, 2, 3] +[1, 2, 3].fill(4, -3, -2); // [4, 2, 3] +[1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3] +[1, 2, 3].fill(4, 3, 5); // [1, 2, 3] +Array(3).fill(4); // [4, 4, 4] +[].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3} + +// Objects by reference. +var arr = Array(3).fill({}) // [{}, {}, {}]; +arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.fill) { + Object.defineProperty(Array.prototype, 'fill', { + value: function(value) { + + // Steps 1-2. + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + var O = Object(this); + + // Steps 3-5. + var len = O.length >>> 0; + + // Steps 6-7. + var start = arguments[1]; + var relativeStart = start >> 0; + + // Step 8. + var k = relativeStart < 0 ? + Math.max(len + relativeStart, 0) : + Math.min(relativeStart, len); + + // Steps 9-10. + var end = arguments[2]; + var relativeEnd = end === undefined ? + len : end >> 0; + + // Step 11. + var final = relativeEnd < 0 ? + Math.max(len + relativeEnd, 0) : + Math.min(relativeEnd, len); + + // Step 12. + while (k < final) { + O[k] = value; + k++; + } + + // Step 13. + return O; + } + }); +} +</pre> + +<p>Wenn es wirklich notwendig ist veraltete JavaScript-Umgebungen zu unterstützen, die <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code> nicht unterstützen, ist es meistens besser Methoden von <code>Array.prototype</code> nicht mit einem Polyfill zu unterstützen, weil sie nicht als nicht-aufzählbar eingestellt werden können.</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('ES2015', '#sec-array.prototype.fill', 'Array.prototype.fill')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.fill', 'Array.prototype.fill')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.fill")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("TypedArray.prototype.fill()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/filter/index.html b/files/de/web/javascript/reference/global_objects/array/filter/index.html new file mode 100644 index 0000000000..6f1ee08498 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/filter/index.html @@ -0,0 +1,235 @@ +--- +title: Array.prototype.filter() +slug: Web/JavaScript/Reference/Global_Objects/Array/filter +tags: + - Array + - ECMAScript 5 + - JavaScript + - Method + - Prototype + - Reference + - filter + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter +--- +<div>{{JSRef}}</div> + +<p><code>filter()</code> erstellt ein neues Array mit allen Elementen, die den von der bereitgestellten Funktion implementierten Test bestehen.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-filter.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><var>let newArray = arr</var>.filter(<var>callback(element[, index[, array]])</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Eine Funktion, um jedes Element des Arrays zu testen. Die Funktion gibt <code>true</code> zurück, um das Element zu behalten, ansonsten <code>false</code>.</dd> + <dd> + <dl> + <dt><code>element</code></dt> + <dd>Das aktuell zu testende Element aus dem Array.</dd> + <dt><code>index</code> {{optional_inline}}</dt> + <dd>Der Index des aktuell zu testenden Elements aus dem Array.</dd> + <dt><code>array</code> {{optional_inline}}</dt> + <dd>Das Array auf welchem <code>filter</code> aufgerufen wurde.</dd> + </dl> + </dd> + <dt><code>thisArg</code> {{optional_inline}}</dt> + <dd>Wert, der als <code>this</code> innerhalb der Funktion genutzt wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues Array mit den Elementen, die den Test bestanden haben. Wenn kein Element den Test besteht, wird ein leeres Array zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>filter()</code> ruft eine bereitgestellte <code>callback</code>-Funktion einmal für jedes Element in einem Array auf und erstellt ein neues Array aller Werte, für die <code>callback</code> einen Wert zurückgibt <a href="/de/docs/Glossary/Truthy">der umgewandelt <code>true</code> ergibt</a>. <code>callback</code> wird nur für Indizes des Arrays aufgerufen, denen Werte zugewiesen wurden. Es wird nicht für Indizes aufgerufen, die gelöscht oder denen nie Werte zugewiesen wurden. Array-Elemente, die den Test in <code>callback</code> nicht bestehen, werden einfach übersprungen und sind im neuen Array nicht enthalten.</p> + +<p><code>callback</code> wird mit drei Argumenten aufgerufen:</p> + +<ol> + <li>Der Wert des Elements</li> + <li>Der Index des Elements</li> + <li>Das Array-Objekt, das durchlaufen wird</li> +</ol> + +<p>Falls der Parameter <code>thisArg</code> an <code>filter</code> übergeben wird, wird er als Wert für <code>this</code> innerhalb von <code>callback</code> verwendet. Andernfalls hat <code>this</code> den Wert {{jsxref("undefined")}}. Welchen Wert <code>callback</code> letztendlich in <code>this</code> sieht wird gemäß <a href="/de/docs/Web/JavaScript/Reference/Operators/this">der üblichen Regeln bestimmt, nach denen <code>this</code> für eine Funktion ermittelt wird</a>.</p> + +<p><code>filter()</code> selbst verändert das Array nicht, auf dem es aufgerufen wird.</p> + +<p>Der Bereich der von <code>filter()</code> verarbeiteten Elemente wird vor dem ersten Aufruf von <code>callback</code> festgelegt. Elemente, die nach Beginn des Aufrufs von <code>filter()</code> an das Array angehängt werden, werden von <code>callback</code> nicht berücksichtigt. Wenn vorhandene Elemente des Arrays geändert werden, ist der Wert maßgeblich, den <code>filter()</code> beim Erreichen eines Elements antrifft und dann an <code>callback</code> übergibt. Nachfolgende Elemente, die nach Beginn eines Durchlaufs von <code>filter()</code> gelöscht werden, bevor sie eingelesen werden konnten, werden nicht mehr berücksichtigt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Alle_kleinen_Werte_herausfiltern">Alle kleinen Werte herausfiltern</h3> + +<p>Das folgende Beispiel nutzt <code>filter()</code>, um ein gefiltertes Array zu erstellen, aus dem alle Element mit Werten kleiner als 10 entfernt werden.</p> + +<pre class="brush: js notranslate">function isBigEnough(value) { + return value >= 10; +} + +let filtered = [12, 5, 8, 130, 44].filter(isBigEnough); +// filtered is [12, 130, 44] +</pre> + +<h3 id="Filtern_von_ungültigen_Werten_aus_JSON">Filtern von ungültigen Werten aus JSON</h3> + +<p>Das folgende Beispiel nutzt <code>filter()</code>, um ein gefiltertes JSON zu erstellen, in welchem alle Elemente mit numerischer <code>id</code> ungleich null sind.</p> + +<pre class="brush: js notranslate">let arr = [ + { id: 15 }, + { id: -1 }, + { id: 0 }, + { id: 3 }, + { id: 12.2 }, + { }, + { id: null }, + { id: NaN }, + { id: 'undefined' } +]; + +let invalidEntries = 0; + +function isNumber(obj) { + return obj !== undefined && typeof(obj) === 'number' && !isNaN(obj); +} + +function filterByID(obj) { + if (isNumber(obj.id) && obj.id !== 0) { + return true; + } + invalidEntries++; + return false; +} + +let arrByID = arr.filter(filterByID); + +console.log('Filtered Array\n', arrByID); +// Filtered Array +// [{ id: 15 }, { id: -1 }, { id: 3 }, { id: 12.2 }] + +console.log('Number of Invalid Entries = ', invalidEntries); +// <span class="diff_add">Number of Invalid Entries = 5</span> +</pre> + +<h3 id="Suchen_in_Arrays">Suchen in Arrays</h3> + +<p>Das folgende Beispiel nutzt <code>filter()</code>, um ein Array gemäß eines Suchkriterius zu filtern.</p> + +<pre class="brush: js notranslate">let fruits = ['apple', 'banana', 'grapes', 'mango', 'orange']; + +/** + * Filter array items based on search criteria (query) + */ +function filterItems(arr, query) { + return arr.filter(function(el) { + return el.toLowerCase().indexOf(query.toLowerCase()) > -1; + }) +} + +console.log(filterItems(fruits, 'ap')); // ['apple', 'grapes'] +console.log(filterItems(fruits, 'an')); // ['banana', 'mango', 'orange']</pre> + +<h4 id="ES2015_Implementierung">ES2015 Implementierung</h4> + +<pre class="brush: js notranslate">const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange']; + +/** + * Filter array items based on search criteria (query) + */ +const filterItems = (arr, query) => { + return arr.filter(el => el.toLowerCase().indexOf(query.toLowerCase()) > -1); +}; + +console.log(filterItems(fruits, 'ap')); // ['apple', 'grapes'] +console.log(filterItems(fruits, 'an')); // ['banana', 'mango', 'orange']</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>filter()</code> wurde dem ECMA-262-Standard in der 5. Auflage hinzugefügt. Als solches ist es möglicherweise nicht in allen Implementierungen des Standards enthalten. Sie können dies umgehen, indem Sie den folgenden Code am Anfang Ihrer Skripte einfügen, um die Verwendung von <code>filter()</code> in Implementierungen zu ermöglichen, die es nicht nativ unterstützen. Dieser Algorithmus entspricht dem in der 5. Auflage von ECMA-262 angegebenen Algorithmus, vorausgesetzt dass <code>callback.call()</code> mit dem ursprünglichen Wert von {{jsxref("Function.prototype.call()")}} auswertet wird und {{jsxref("Array.prototype.push()")}} seinen ursprünglichen Wert hat.</p> + +<pre class="brush: js notranslate">if (!Array.prototype.filter) { + Array.prototype.filter = function(func, thisArg) { + 'use strict'; + if ( ! ((typeof func === 'Function' || typeof func === 'function') && this) ) + throw new TypeError(); + + let len = this.length >>> 0, + res = new Array(len), // preallocate array + t = this, c = 0, i = -1; + if (thisArg === undefined) { + while (++i !== len){ + // checks to see if the key was set + if (i in this){ + if (func(t[i], i, t)){ + res[c++] = t[i]; + } + } + } + } + else{ + while (++i !== len){ + // checks to see if the key was set + if (i in this){ + if (func.call(thisArg, t[i], i, t)){ + res[c++] = t[i]; + } + } + } + } + + res.length = c; // shrink down array to proper size + return res; + }; +}</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('ES5.1', '#sec-15.4.4.20', 'Array.prototype.filter')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.filter', 'Array.prototype.filter')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.filter', 'Array.prototype.filter')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.filter")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("Array.prototype.reduce()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/find/index.html b/files/de/web/javascript/reference/global_objects/array/find/index.html new file mode 100644 index 0000000000..2741360a67 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/find/index.html @@ -0,0 +1,243 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Reference/Global_Objects/Array/find +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/find +--- +<div>{{JSRef}}</div> + +<p>Die Methode <code><strong>find()</strong></code> gibt den <strong>Wert</strong> des Elements eines Arrays zurück, welches <strong>als erstes</strong> die Bedingung einer bereitgestellten Testfunktion erfüllt. Andernfalls wird {{jsxref("undefined")}} zurückgegeben.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-find.html")}}</div> + + + +<p>Siehe auch die Methode {{jsxref("Array.prototype.findIndex()", "findIndex()")}}, die den <strong>Index</strong> eines gefundenen Elements im Array anstelle seines Werts zurückgibt.</p> + +<p>Wenn Sie die Position eines Elements ermitteln oder feststellen müssen, ob ein Element in einem Array vorhanden ist, verwenden Sie {{jsxref("Array.prototype.indexOf()", "indexOf()")}} oder {{jsxref("Array.prototype.includes()", "includes()")}}.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.find(callback<var>[, thisArg]</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funktion, die auf jedes Element angewendet wird mit drei Argumenten: + <dl> + <dt><code>element</code></dt> + <dd>Das aktuelle Element, das im Array verarbeitet wird.</dd> + <dt><code>index</code> {{optional_inline}}</dt> + <dd>Der Index des aktuellen Elements im Array.</dd> + <dt><code>array</code> {{optional_inline}}</dt> + <dd>Das Array, welches mit <code>find()</code> durlaufen wird.</dd> + </dl> + </dd> + <dt><code>thisArg</code> {{optional_inline}}</dt> + <dd>Wert der als <code>this</code> verwendet wird, wenn <code>callback</code> ausgeführt wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der <strong>Wert</strong> des Elements, welches <strong>als erstes</strong> die Bedingung der bereitgestellten Testfunktion erfüllt. Andernfalls wird {{jsxref("undefined")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>find()</code> führt die <code>callback</code>-Funktion einmal für jeden Index des Arrays aus, bis ein Index gefunden wird, in dem <code>callback</code> einen {{Glossary("truthy")}}-Wert zurückgibt. Wenn ein solches Element gefunden wird, gibt <code>find()</code> sofort den Wert dieses Elements zurück, {{jsxref("undefined")}}. <code>callback</code> wird für jeden Index des Arrays von <code>0</code> bis <code>length - 1</code> aufgerufen und nicht nur für Indizes, denen Werte zugewiesen wurden. Dies kann bedeuten, dass es für Arrays mit Leerstellen weniger effizient ist als andere Methoden, die nur Indizes durchlaufen, denen ein Wert zugewiesen wurde.</p> + +<p><code>callback</code> wird mit drei Argumenten aufgerufen:</p> + +<ol> + <li>Der Wert des Elements</li> + <li>Der Index des Elements</li> + <li>Das Array-Objekt, das durchlaufen wird</li> +</ol> + +<p> </p> + +<p>Falls der Parameter <code>thisArg</code> an <code>find()</code> übergeben wird, wird er als Wert für <code>this</code> innerhalb von <code>callback</code> verwendet. Andernfalls hat <code>this</code> den Wert {{jsxref("undefined")}}. Welchen Wert <code>callback</code> letztendlich in <code>this</code> sieht wird gemäß <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/this">der üblichen Regeln bestimmt, nach denen <code>this</code> für eine Funktion ermittelt wird</a>.</p> + +<p><code>find()</code> selbst verändert das Array nicht, auf dem es aufgerufen wird.</p> + +<p>Der Bereich der von <code>find()</code> verarbeiteten Elemente wird vor dem ersten Aufruf von <code>callback</code> festgelegt. Elemente, die nach Beginn des Aufrufs von <code> find()</code> an das Array angehängt werden, werden von <code>callback</code> nicht berücksichtigt. Wenn vorhandene Elemente des Arrays geändert werden, ist der Wert maßgeblich, den <code>find()</code> beim Erreichen eines Elements antrifft und dann an <code>callback</code> übergibt. <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/delete">Gelöschte</a> Elemente werden weiterhin verarbeitet.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ermitteln_eines_Objekts_innerhalb_eines_Arrays_anhand_eines_seiner_Eigenschaften">Ermitteln eines Objekts innerhalb eines Arrays anhand eines seiner Eigenschaften</h3> + +<pre class="brush: js">var inventory = [ + {name: 'apples', quantity: 2}, + {name: 'bananas', quantity: 0}, + {name: 'cherries', quantity: 5} +]; + +function isCherries(fruit) { + return fruit.name === 'cherries'; +} + +console.log(inventory.find(isCherries)); +// { name: 'cherries', quantity: 5 }</pre> + +<h4 id="Benutzung_einer_ES2015_Pfeilfunktion">Benutzung einer ES2015 Pfeilfunktion</h4> + +<pre class="brush: js">const inventory = [ + {name: 'apples', quantity: 2}, + {name: 'bananas', quantity: 0}, + {name: 'cherries', quantity: 5} +]; + +const result = inventory.find( fruit => fruit.name === 'cherries' ); + +console.log(result) // { name: 'cherries', quantity: 5 }</pre> + +<h3 id="Ermitteln_einer_Primzahl_innerhalb_eines_Arrays">Ermitteln einer Primzahl innerhalb eines Arrays</h3> + +<p>Im folgenden Beispiel wird ein Element im Array ermittelt, das eine Primzahl ist (oder {{jsxref("undefined")}} zurückgibt, wenn keine Primzahl vorhanden ist).</p> + +<pre class="brush: js">function isPrime(element, index, array) { + var start = 2; + while (start <= Math.sqrt(element)) { + if (element % start++ < 1) { + return false; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].find(isPrime)); // undefined, not found +console.log([4, 5, 8, 12].find(isPrime)); // 5 +</pre> + +<p>Das folgende Beispiel zeigt, dass nicht vorhandene und gelöschte Elemente durchlaufen werden und der Wert maßgeblich ist, der beim Erreichen des Elements angetroffen und an <code>callback</code> übergeben wird.</p> + +<pre class="brush: js">// Array deklarieren, das an Index 2, 3 und 4 keine Elemente hat +var array = [0,1,,,,5,6]; + +// Zeige alle Indizes, nicht nur die denen Werte zugewiesen wurden +array.find(function(value, index) { + console.log('Visited index ' + index + ' with value ' + value); +}); + +// Zeige alle Indizes, inklusive gelöschter +array.find(function(value, index) { + + // Lösche Element 5 in erstem Durchlauf + if (index == 0) { + console.log('Deleting array[5] with value ' + array[5]); + delete array[5]; + } + // Element 5 wird weiterhin durchlaufen, obwohl es gelöscht wurde + console.log('Visited index ' + index + ' with value ' + value); +}); +// Erwartete Ausgaben: +// Deleting array[5] with value 5 +// Visited index 0 with value 0 +// Visited index 1 with value 1 +// Visited index 2 with value undefined +// Visited index 3 with value undefined +// Visited index 4 with value undefined +// Visited index 5 with value undefined +// Visited index 6 with value 6 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Methode wurde der ECMAScript 2015-Spezifikation hinzugefügt und ist möglicherweise noch nicht in allen JavaScript-Implementierungen verfügbar. Sie können <code>Array.prototype.find()</code> jedoch mit dem folgenden Snippet nachrüsten:</p> + +<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.find +if (!Array.prototype.find) { + Object.defineProperty(Array.prototype, 'find', { + value: function(predicate) { + // 1. Let O be ? ToObject(this value). + if (this == null) { + throw new TypeError('"this" is null or not defined'); + } + + var o = Object(this); + + // 2. Let len be ? ToLength(? Get(O, "length")). + var len = o.length >>> 0; + + // 3. If IsCallable(predicate) is false, throw a TypeError exception. + if (typeof predicate !== 'function') { + throw new TypeError('predicate must be a function'); + } + + // 4. If thisArg was supplied, let T be thisArg; else let T be undefined. + var thisArg = arguments[1]; + + // 5. Let k be 0. + var k = 0; + + // 6. Repeat, while k < len + while (k < len) { + // a. Let Pk be ! ToString(k). + // b. Let kValue be ? Get(O, Pk). + // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)). + // d. If testResult is true, return kValue. + var kValue = o[k]; + if (predicate.call(thisArg, kValue, k, o)) { + return kValue; + } + // e. Increase k by 1. + k++; + } + + // 7. Return undefined. + return undefined; + }, + configurable: true, + writable: true + }); +} +</pre> + +<p>Wenn Sie stark veraltete JavaScript-Engines unterstützen müssen, die {{jsxref("Object.defineProperty()")}} nicht unterstützen, empfiehlt es sich Methoden aus <code>Array.prototype</code> gar nicht mit Polyfills nachzubauen, da es nicht möglich ist sie als nicht-enumerierbar zu kennzeichnen.</p> + +<h2 id="Specifikationen">Specifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.find', 'Array.prototype.find')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.find', 'Array.prototype.find')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.find")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.findIndex()")}}</li> + <li>{{jsxref("Array.prototype.includes()")}}</li> + <li>{{jsxref("Array.prototype.filter()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/findindex/index.html b/files/de/web/javascript/reference/global_objects/array/findindex/index.html new file mode 100644 index 0000000000..904ff025fc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/findindex/index.html @@ -0,0 +1,189 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Reference/Global_Objects/Array/findIndex +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">Die Methode <code><strong>findIndex()</strong></code> gibt den <strong>Index</strong> des ersten Elements im Array zurück, <strong>das die bereitgestellte Testfunktion erfüllt.</strong> Andernfalls wird -1 zurückgegeben, um anzuzeigen, dass kein Element den Test bestanden hat.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/array-findindex.html")}}</div> + + + +<p>Siehe auch die Methode {{jsxref("Array.find", "find()")}}, die den Wert eines Arrayelements anstelle dessen Index zurückgibt.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.findIndex(callback(element<var>[, index[, array]]</var>)<var>[, thisArg]</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Eine Funktion, die für jeden Wert im Array ausgeführt wird, bis sie <code>true</code> zurückgibt, um anzuzeigen, dass das gewünschte Element gefunden wurde. Sie akzeptiert 3 Argumente: + <dl> + <dt><code>element</code></dt> + <dd>Das aktuelle Element, das im Array verarbeitet wird.</dd> + <dt><code>index</code> {{optional_inline}}</dt> + <dd>Der Index des aktuellen Elements, das im Array verarbeitet wird.</dd> + <dt><code>array</code> {{optional_inline}}</dt> + <dd>Das Array, welches mit <code>findIndex()</code> durchlaufen wird.</dd> + </dl> + </dd> + <dt><code>thisArg</code> {{optional_inline}}</dt> + <dd>Wert der als <code>this</code> verwendet wird, wenn <code>callback</code> ausgeführt wird</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein Index im Array, wenn ein Element den Test besteht, ansonsten <strong>-1.</strong></p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>findIndex()</code> ruft eine bereitgestellte <code>callback</code>-Funktion einmal für jeden Array-Index <code>0..length-1</code> (inklusive) im Array auf bis <code>callback</code> einen {{Glossary("truthy")}}-Wert findet.</p> + +<p>Wird ein solches Element gefunden gibt <code>findIndex()</code> sofort den Index des gefundenen Elements zurück. Gibt callback nie einen {{Glossary("truthy")}}-Wert zurück oder ist <code>length</code> gleich 0 gibt <code>findIndex()</code> -1 zurück. Im Gegensatz zu einigen anderen Array-Methoden wie {{jsxref("Array.prototype.some()", "some()")}} wird in Arrays mit Leerstellen <code>callback</code> <strong>auch für</strong> Indizes aufgerufen, die keinen Inhalt haben.</p> + +<p><code>callback</code> wird mit drei Argumenten aufgerufen:</p> + +<ol> + <li>Der Wert des Elements</li> + <li>Der Index des Elements</li> + <li>Das Array-Objekt, das durchlaufen wird</li> +</ol> + +<p>Falls der Parameter <code>thisArg</code> an <code>findIndex()</code> übergeben wird, wird er als Wert für <code>this</code> innerhalb von <code>callback</code> verwendet. Andernfalls hat <code>this</code> den Wert {{jsxref("undefined")}}. Welchen Wert <code>callback</code> letztendlich in <code>this</code> sieht wird gemäß <a href="/de/docs/Web/JavaScript/Reference/Operators/this">der üblichen Regeln bestimmt, nach denen <code>this</code> für eine Funktion ermittelt wird</a>.</p> + +<p>Der Bereich der von <code>findIndex()</code> verarbeiteten Elemente wird vor dem ersten Aufruf von <code>callback</code> festgelegt. Elemente, die nach Beginn des Aufrufs von <code> findIndex()</code> an das Array angehängt werden, werden von <code>callback</code> nicht berücksichtigt. Wenn vorhandene Elemente des Arrays geändert werden, ist der Wert maßgeblich, den <code>findIndex()</code> beim Erreichen eines Elements antrifft und dann an <code>callback</code> übergibt. <a href="/de/docs/Web/JavaScript/Reference/Operators/delete">Gelöschte</a> Elemente werden weiterhin verarbeitet.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Index_einer_Primzahl_in_einem_Array_finden">Index einer Primzahl in einem Array finden</h3> + +<p>Das folgende Beispiel gibt den Index eines Elements im Array zurück, das eine Primzahl ist, oder -1, wenn keine Primzahl vorhanden ist.</p> + +<pre class="brush: js">function isPrime(element, index, array) { + var start = 2; + while (start <= Math.sqrt(element)) { + if (element % start < 1) { + return false; + } else { + start++; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, not found +console.log([4, 6, 7, 12].findIndex(isPrime)); // 2 (array[2] is 7) +</pre> + +<h3 id="Index_mithilfe_einer_Pfeilfunktion_ermitteln">Index mithilfe einer Pfeilfunktion ermitteln</h3> + +<p>Im folgenden Beispiel wird der Index einer Frucht mithilfe einer Pfeilfunktion ermittelt:</p> + +<pre class="brush: js">const fruits = ["apple", "banana", "cantaloupe", "blueberries", "grapefruit"]; + +const index = fruits.findIndex(fruit => fruit === "blueberries"); + +console.log(index); // 3 +console.log(fruits[index]); // blueberries +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.findindex +if (!Array.prototype.findIndex) { + Object.defineProperty(Array.prototype, 'findIndex', { + value: function(predicate) { + // 1. Let O be ? ToObject(this value). + if (this == null) { + throw new TypeError('"this" is null or not defined'); + } + + var o = Object(this); + + // 2. Let len be ? ToLength(? Get(O, "length")). + var len = o.length >>> 0; + + // 3. If IsCallable(predicate) is false, throw a TypeError exception. + if (typeof predicate !== 'function') { + throw new TypeError('predicate must be a function'); + } + + // 4. If thisArg was supplied, let T be thisArg; else let T be undefined. + var thisArg = arguments[1]; + + // 5. Let k be 0. + var k = 0; + + // 6. Repeat, while k < len + while (k < len) { + // a. Let Pk be ! ToString(k). + // b. Let kValue be ? Get(O, Pk). + // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)). + // d. If testResult is true, return k. + var kValue = o[k]; + if (predicate.call(thisArg, kValue, k, o)) { + return k; + } + // e. Increase k by 1. + k++; + } + + // 7. Return -1. + return -1; + }, + configurable: true, + writable: true + }); +} +</pre> + +<p>Wenn Sie stark veraltete JavaScript-Engines unterstützen müssen, die {{jsxref("Object.defineProperty()")}} nicht unterstützen, empfiehlt es sich Methoden aus <code>Array.prototype</code> gar nicht mit Polyfills nachzubauen, da es nicht möglich ist sie als nicht-enumerierbar zu kennzeichnen.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array.prototype.findindex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.findIndex")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/flat/index.html b/files/de/web/javascript/reference/global_objects/array/flat/index.html new file mode 100644 index 0000000000..4e18ff7649 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/flat/index.html @@ -0,0 +1,116 @@ +--- +title: Array.prototype.flat() +slug: Web/JavaScript/Reference/Global_Objects/Array/flat +tags: + - Array + - Experimental + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat +--- +<div>{{JSRef}} {{SeeCompatTable}}</div> + +<p>Die <code><strong>flat()</strong></code> Methode erstellt rekursiv ein neues Array mit allen Elementen von Unterarrays bis zu einer spezifizierten Tiefe.</p> + +<p class="hidden">\{{EmbedInteractiveExample("pages/js/array-flatten.html")}}</p> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>var newArray = arr</var>.flat(<var>depth</var>);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>depth</code> {{optional_inline}}</dt> + <dd>Das Tiefenlevel, welches angibt, bis zu welcher Tiefe die Arraystruktur abgeflacht werden soll. Der Standardwert ist 1.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues Array, welches die Elemente der Unterarrays enthält.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Abflachen_von_geschachtelten_Arrays">Abflachen von geschachtelten Arrays</h3> + +<pre class="brush: js">var arr1 = [1, 2, [3, 4]]; +arr1.flat(); +// [1, 2, 3, 4] + +var arr2 = [1, 2, [3, 4, [5, 6]]]; +arr2.flat(); +// [1, 2, 3, 4, [5, 6]] + +var arr3 = [1, 2, [3, 4, [5, 6]]]; +arr3.flat(2); +// [1, 2, 3, 4, 5, 6] +</pre> + +<h3 id="Abflachen_und_Löcher_in_Arrays">Abflachen und Löcher in Arrays</h3> + +<p>Die <code>flat</code> Methode entfernt leere Plätze in Arrays:</p> + +<pre class="brush: js">var arr4 = [1, 2, , 4, 5]; +arr4.flat(); +// [1, 2, 4, 5]</pre> + +<h2 id="Alternative">Alternative</h2> + +<h3 id="reduce_und_concat"><code>reduce</code> und <code>concat</code></h3> + +<pre>var arr1 = [1, 2, [3, 4]]; +arr1.flat(); + +// Um ein Array um eine Ebene zu glätten. +arr1.reduce((acc, val) => acc.concat(val), []); +// [1, 2, 3, 4] + +// Um mehrere Ebenen zu glätten muss reduce und concat rekursiv eingesetzt werden. + +var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]]; + +function flattenDeep(arr1) { + return arr1.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []); +} +flattenDeep(arr1); + +// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4] +</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><a href="https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flat"><code>Array.prototype.flat</code> proposal</a></td> + <td>Candidate (3)</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.flat")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.flatMap()")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("Array.prototype.reduce()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/flatmap/index.html b/files/de/web/javascript/reference/global_objects/array/flatmap/index.html new file mode 100644 index 0000000000..2840429333 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/flatmap/index.html @@ -0,0 +1,117 @@ +--- +title: Array.prototype.flatMap() +slug: Web/JavaScript/Reference/Global_Objects/Array/flatMap +tags: + - Array + - Experimental + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flatMap +--- +<div>{{JSRef}} {{SeeCompatTable}}</div> + +<p>Die <code><strong>flatMap()</strong></code> Methode bildet jedes Element über eine Funktion ab und flacht das Ergebnis in ein Array ab. Sie ist identisch zu einem <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a> gefolgt von einem <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array/flat">flat</a> der Tiefe 1, aber <code>flatMap</code> ist <span id="result_box" lang="de"><span>oft nützlich und beide in einer Methode zusammenführen ist etwas effizienter.</span></span></p> + +<p class="hidden">\{{EmbedInteractiveExample("pages/js/array-flatmap.html")}}</p> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>var new_array = arr</var>.flatMap(function <var>callback(currentValue[, index[, array]]) { + // return element for new_array +}</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funktion, die ein Element für das neue Array erzeugt, welche drei Argumente hat: + <dl> + <dt> </dt> + <dt><code>currentValue</code></dt> + <dd>Das aktuelle Element, das im Array verarbeitet wird.</dd> + <dt><code>index</code>{{optional_inline}}</dt> + <dd>Der Index des aktuell zu verarbeitende Elements in dem Array.</dd> + <dt><code>array</code>{{optional_inline}}</dt> + <dd>Das Array, auf dem <code>flatMap</code> aufgerufen wurde.</dd> + </dl> + </dd> + <dt><code>thisArg</code>{{optional_inline}}</dt> + <dd>Wert, der bei der Ausführung von <code>callback</code> für <code>this</code> genutzt wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues Array mit jedem Element, dass aus dem Resultat der callback Funktion hervorgeht und auf die Tiefe 1 abgeflacht wurde.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Siehe auf der Seite {{jsxref("Array.prototype.map()")}} für eine detaillierte Beschreibung der <code>callback</code> Funktion. Die <code>flatMap</code> Methode ist identisch zu <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a></code> gefolgt von <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat">flat</a></code> mit der Tiefe 1.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="map_und_flatMap"><code>map</code> und <code>flatMap</code></h3> + +<pre class="brush: js">var arr1 = <span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>[</span></span><span class="constant decimal js numeric"><span>1</span></span><span class="comma delimiter js meta object"><span>,</span></span><span> </span><span class="brace js meta square"><span>2, 3, 4]; + +arr1.map(</span></span></span></span></span>x => [x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>);</span></span></span></span></span> +// [[2], [4], [6], [8]] + +arr1.flatMap(x => [x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>); +// [2, 4, 6, 8]</span></span></span></span></span> + +// only one level is flattened +arr1.flatMap(x => [[x * 2]]); +// [[2], [4], [6], [8]] +</pre> + +<h2 id="Alternative">Alternative</h2> + +<h3 id="reduce_und_concat"><code>reduce</code> und <code>concat</code></h3> + +<pre class="brush: js"><code>var arr1 = [1, 2, 3, 4]; + +arr1.flatMap(x => [x * 2]); +// ist equivalent zu +arr1.reduce((acc, x) => acc.concat([x * 2]), []); +// [2, 4, 6, 8] +</code></pre> + +<div class="line"><span class="js source"><span class="comment double-slash js line"><span class="comment definition js punctuation"><span>//</span></span><span>=> [1, 2, 3, 4, 5, 6, 7, 8, 9]</span></span></span></div> + +<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><a href="https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap"><code>Array.prototype.flatMap</code> proposal</a></td> + <td>Candidate (3)</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.flatMap")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.flat()")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("Array.prototype.reduce()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/foreach/index.html b/files/de/web/javascript/reference/global_objects/array/foreach/index.html new file mode 100644 index 0000000000..faba9795cb --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/foreach/index.html @@ -0,0 +1,303 @@ +--- +title: Array.prototype.forEach() +slug: Web/JavaScript/Reference/Global_Objects/Array/forEach +tags: + - Array + - ECMAScript 5 + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>forEach()</strong></code> Methode führt eine übergebene Funktion für jedes Element eines Arrays aus.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-foreach.html")}}</div> + + + +<p><span class="comment token">// a</span> <span class="comment token">// b</span> <span class="comment token">// c</span></p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.forEach(function <var>callback(currentValue [, index [, array]]) { + // Ihr Iterator +}</var>[, <var>thisArg</var>]);</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funktion, die auf jedes Element angewendet wird mit drei Argumenten:</dd> + <dd> + <dl> + <dt><code>currentValue</code></dt> + <dd>Der Wert des aktuellen Elements im Array.</dd> + <dt><code>index</code> {{optional_inline}}</dt> + <dd>Der Index des aktuellen Elements im Array.</dd> + <dt><code>array</code> {{optional_inline}}</dt> + <dd>Das Array, welches mit <code>forEach()</code> durlaufen wird.</dd> + </dl> + </dd> + <dt><code>thisArg</code> {{optional_inline}}</dt> + <dd>Wert der als <code>this</code> verwendet wird, wenn <code>callback</code> ausgeführt wird.</dd> + <dt> </dt> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>forEach()</code> ruft eine bereitgestellte <code>callback</code>-Funktion einmal für jedes Element in einem Array in aufsteigender Reihenfolge auf. Sie wird nicht für Elemente aufgerufen, die gelöscht oder nicht initialisiert wurden (d. h. Arrays mit leeren Elementen).</p> + +<p><code>callback</code> wird mit drei Argumenten aufgerufen:</p> + +<ol> + <li>Der Wert des Elements</li> + <li>Der Index des Elements</li> + <li>Das Array-Objekt, das durchlaufen wird</li> +</ol> + +<p>Falls der Parameter <code>thisArg</code> an <code>forEach()</code> übergeben wird, wird er als Wert für <code>this</code> innerhalb von <code>callback</code> verwendet. Andernfalls hat <code>this</code> den Wert {{jsxref("undefined")}}. Welchen Wert <code>callback</code> letztendlich in <code>this</code> sieht wird gemäß <a href="/de/docs/Web/JavaScript/Reference/Operators/this">der üblichen Regeln bestimmt, nach denen <code>this</code> für eine Funktion ermittelt wird</a>.</p> + +<p><code>forEach()</code> selbst verändert das Array nicht, auf dem es aufgerufen wird (das aufgerufene <code>callback</code> kann jedoch Änderungen vornehmen).</p> + +<p>Der Bereich der von <code>forEach()</code> verarbeiteten Elemente wird vor dem ersten Aufruf von <code>callback</code> festgelegt. Elemente, die nach Beginn des Aufrufs von <code>forEach()</code> an das Array angehängt werden, werden von <code>callback</code> nicht berücksichtigt. Wenn vorhandene Elemente des Arrays geändert werden, ist der Wert maßgeblich, den <code>forEach()</code> beim Erreichen eines Elements antrifft und dann an <code>callback</code> übergibt. Nachfolgende Elemente, die nach Beginn eines Durchlaufs von <code>forEach()</code> gelöscht werden (z. B. durch {{jsxref("Array.prototype.shift()", "shift()")}}), bevor sie eingelesen werden konnten, werden nicht mehr berücksichtigt (siehe Beispiel unten).</p> + +<p><code>forEach()</code> führt <code>callback</code> einmal für jedes Element im Array aus; im Gegensatz zu {{jsxref("Array.prototype.map()", "map()")}} oder {{jsxref("Array.prototype.reduce()", "reduce()")}} gibt es immer den Wert {{jsxref("undefined")}} zurück und ist nicht verknüpfbar. Der typische Anwendungsfall ist das Ausführen von Nebenwirkungen am Ende einer einer solchen Kette.</p> + +<div class="note"> +<p>Es gibt keine Möglichkeit eine <code>forEach()</code>-Schleife zu unterbrechen oder zu verlassen, außer durch das erzeugen einer Exception. Wird eine solche Möglichkeit jedoch benötigt, stellt <code>forEach()</code> das falsche Mittel dar.</p> + +<p>Vorzeitiges Verlassen ist verfügbar in:</p> + +<ul> + <li>Einer einfachen Schleife</li> + <li>Einer {{jsxref("statements/for...of", "for...of")}} Schleife</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.findIndex()")}}</li> +</ul> + +<p>Die anderen Array Methoden {{jsxref("Array.prototype.every()", "every()")}}, {{jsxref("Array.prototype.some()", "some()")}}, {{jsxref("Array.prototype.find()", "find()")}} und {{jsxref("Array.prototype.findIndex()", "findIndex()")}} prüfen die Elemente im Array auf eine Bedingung, die einen {{Glossary("Truthy")}}-Wert zurückgibt mit dem bestimmt wird, ob weitere Durchläufe nötig sind.</p> +</div> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="forEach()_statt_einer_for-Schleife"><code>forEach()</code> statt einer for-Schleife</h3> + +<pre class="brush: js">const items = ['item1', 'item2', 'item3']; +const copy = []; + +// Vorher +for (let i=0; i<items.length; i++) { + copy.push(items[i]); +} + +// Nachher +items.forEach(function(item){ + copy.push(item); +});</pre> + +<h3 id="Example:_Printing_the_contents_of_an_array" name="Example:_Printing_the_contents_of_an_array">Inhalte eines Arrays ausgeben</h3> + +<div class="blockIndicator note"> +<p><strong>Hinweis:</strong> Um den Inhalt eines Arrays vorformatiert auf der Konsole auszugeben können Sie auch {{jsxref("console.table()")}} verwenden. Dieses Beispiel zeigt eine weitere Möglichkeit mittels <code>forEach()</code>.</p> +</div> + +<p>Der folgende Code gibt eine Zeile pro Element des Arrays aus:</p> + +<pre class="brush:js">function logArrayElements(element, index, array) { + console.log('a[' + index + '] = ' + element); +} + +// Hinweis zur Auslassung: Es gibt keinen Eintrag mit dem Index 2 +// somit wird dieser übersprungen +[2, 5, , 9].forEach(logArrayElements); +// Ausgabe: +// a[0] = 2 +// a[1] = 5 +// a[3] = 9 +</pre> + +<h3 id="Verwendung_von_thisArg">Verwendung von <code>thisArg</code></h3> + +<p>Das folgende (fingierte) Beispiel aktualisiert die Eigenschaften eines Objekts eines jeden Eintrags im Array:</p> + +<pre class="brush:js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">Counter</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">this</span><span class="punctuation token">.</span>sum <span class="operator token">=</span> <span class="number token">0</span><span class="punctuation token">;</span> + <span class="keyword token">this</span><span class="punctuation token">.</span>count <span class="operator token">=</span> <span class="number token">0</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span> +Counter<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>add <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span>array<span class="punctuation token">)</span> <span class="punctuation token">{</span> + array<span class="punctuation token">.</span><span class="function token">forEach</span><span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span>entry<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">this</span><span class="punctuation token">.</span>sum <span class="operator token">+</span><span class="operator token">=</span> entry<span class="punctuation token">;</span> + <span class="operator token">++</span><span class="keyword token">this</span><span class="punctuation token">.</span>count<span class="punctuation token">;</span> + <span class="punctuation token">}</span><span class="punctuation token">,</span> <span class="keyword token">this</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="comment token">// ^---- Beachten</span> +<span class="punctuation token">}</span><span class="punctuation token">;</span> + +<span class="keyword token">var</span> obj <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Counter</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +obj<span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">2</span><span class="punctuation token">,</span> <span class="number token">5</span><span class="punctuation token">,</span> <span class="number token">9</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +obj<span class="punctuation token">.</span>count<span class="punctuation token">;</span> +<span class="comment token">// 3 </span> +obj<span class="punctuation token">.</span>sum<span class="punctuation token">;</span> +<span class="comment token">// 16</span></code></pre> + +<p>Da <code>forEach()</code> der Parameter <code>thisArg</code> (<code>this</code>) zur Verfügung steht, wird er bei jedem Aufruf an <code>callback</code> weitergegeben, um es als seinen <code>this</code>-Wert zu benutzen.</p> + +<div class="note"> +<p>Wenn das Funktionsargument durch die <a href="/de/docs/Web/JavaScript/Reference/Functions/Pfeilfunktionen">Pfeilnotation</a> angegeben wird, kann der Parameter <code>thisArg</code> weggelassen werden, da Pfeilfunktionen den {{jsxref("Operators/this", "this")}}-Wert lexikalisch vermerken.</p> +</div> + +<h3 id="Example:_An_object_copy_function" name="Example:_An_object_copy_function">Funktion zum Kopieren eines Objekts</h3> + +<p>Der folgende Code erzeugt eine Kopie des übergebenen Objekts. Es gibt verschiedene Möglichkeiten, ein Objekt zu kopieren. Die Folgende ist nur eine davon und dient zur Veranschaulichung, wie <code>Array.prototype.forEach()</code> funktioniert, indem ECMAScript 5 <code>Object.*</code> Meta-Funktionen genutzt werden.</p> + +<pre class="brush: js">function copy(o) { + var copy = Object.create(Object.getPrototypeOf(o)); + var propNames = Object.getOwnPropertyNames(o); + + propNames.forEach(function(name) { + var desc = Object.getOwnPropertyDescriptor(o, name); + Object.defineProperty(copy, name, desc); + }); + + return copy; +} + +var o1 = { a: 1, b: 2 }; +var o2 = copy(o1); // o2 sieht jetzt aus wie o1</pre> + +<h3 id="Wird_das_Array_während_des_Durchlaufes_modifiziert_könnten_andere_Elemente_übersprungen_werden.">Wird das Array während des Durchlaufes modifiziert, könnten andere Elemente übersprungen werden.</h3> + +<p>Das folgende Beispiel protokolliert "eins", "zwei", "vier". Wenn der Eintrag mit dem Wert "zwei" erreicht ist, wird der erste Eintrag des Arrays mit {{jsxref("Array.prototype.shift()", "shift()")}} entfernt, was dazu führt, dass alle übrigen Einträge um eine Position aufrücken. Weil Element "vier" jetzt an einer früheren Position im Array ist, wird "drei" übersprungen. <code>forEach()</code> erzeugt keine Kopie des Arrays vor dem Durchlauf.</p> + +<pre class="brush:js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> words <span class="operator token">=</span> <span class="punctuation token">[</span><span class="string token">'eins'</span><span class="punctuation token">,</span> <span class="string token">'zwei'</span><span class="punctuation token">,</span> <span class="string token">'drei'</span><span class="punctuation token">,</span> <span class="string token">'vier'</span><span class="punctuation token">]</span><span class="punctuation token">;</span> +words<span class="punctuation token">.</span><span class="function token">forEach</span><span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span>word<span class="punctuation token">)</span> <span class="punctuation token">{</span> + console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>word<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">if</span> <span class="punctuation token">(</span>word <span class="operator token">===</span> <span class="string token">'zwei'</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + words<span class="punctuation token">.</span><span class="function token">shift</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> +<span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// eins</span> +<span class="comment token">// zwei</span> +<span class="comment token">// vier</span></code></pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p><code>forEach()</code> wurde dem ECMA-262-Standard in der 5. Auflage hinzugefügt. Als solches ist es möglicherweise nicht in allen Implementierungen des Standards enthalten. Sie können dies umgehen, indem Sie den folgenden Code am Anfang Ihrer Skripte einfügen, um die Verwendung von <code>forEach()</code> in Implementierungen zu ermöglichen, die es nicht nativ unterstützen. Dieser Algorithmus entspricht dem in der 5. Auflage von ECMA-262 angegebenen Algorithmus, vorausgesetzt {{jsxref("Object")}} und {{jsxref("TypeError")}} haben ihre ursprünglichen Werte und <code>callback.call()</code> wird mit dem ursprünglichen Wert von {{jsxref("Function.prototype.call")}} ausgewertet.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.18 +// Reference: http://es5.github.io/#x15.4.4.18 +if (!Array.prototype.forEach) { + + Array.prototype.forEach = function(callback, thisArg) { + + var T, k; + + if (this === null) { + throw new TypeError(' this is null or not defined'); + } + + // 1. Let O be the result of calling ToObject passing the |this| value as the argument. + var O = Object(this); + + // 2. Let lenValue be the result of calling the Get internal method of O with the argument "length". + // 3. Let len be ToUint32(lenValue). + var len = O.length >>> 0; + + // 4. If IsCallable(callback) is false, throw a TypeError exception. + // See: http://es5.github.com/#x9.11 + if (typeof callback !== "function") { + throw new TypeError(callback + ' is not a function'); + } + + // 5. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 1) { + T = thisArg; + } + + // 6. Let k be 0 + k = 0; + + // 7. Repeat, while k < len + while (k < len) { + + var kValue; + + // a. Let Pk be ToString(k). + // This is implicit for LHS operands of the in operator + // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk. + // This step can be combined with c + // c. If kPresent is true, then + if (k in O) { + + // i. Let kValue be the result of calling the Get internal method of O with argument Pk. + kValue = O[k]; + + // ii. Call the Call internal method of callback with T as the this value and + // argument list containing kValue, k, and O. + callback.call(T, kValue, k, O); + } + // d. Increase k by 1. + k++; + } + // 8. return undefined + }; +} +</pre> + +<h2 id="Specifications" name="Specifications">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.18', 'Array.prototype.forEach')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browser-Kompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.forEach")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.findIndex()")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("Array.prototype.filter()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("Map.prototype.forEach()")}}</li> + <li>{{jsxref("Set.prototype.forEach()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/from/index.html b/files/de/web/javascript/reference/global_objects/array/from/index.html new file mode 100644 index 0000000000..dd254fec88 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/from/index.html @@ -0,0 +1,227 @@ +--- +title: Array.from() +slug: Web/JavaScript/Reference/Global_Objects/Array/from +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Method + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/from +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Array.from()</strong></code> Methode erstellt eine neue, oberflächlich kopierte Array Instanz von einem Array-ähnlichen oder iterierbaren Objekt.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-from.html")}}</div> + + + +<h2 id="Parameters" name="Parameters">Syntax</h2> + +<pre>Array.from(arrayLike[, mapFn[, thisArg]])</pre> + +<h3 id="Parameters" name="Parameters"><span>Parameter</span></h3> + +<dl> + <dt><code>arrayLike</code></dt> + <dd>Ein Array-ähnliches oder iterierbares Objekt, welches zu einem Array konvertiert wird.</dd> + <dt><code>mapFn</code>{{Optional_inline}}</dt> + <dd>Map Funktion, welche auf jedes Element des Arrays angewendet wird.</dd> + <dt><code>thisArg</code>{{Optional_inline}}</dt> + <dd>Wert, welcher als <code>this</code> beim Ausführen von <code>mapFn</code> genutzt wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine neue {{jsxref("Array")}} Instanz.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code><strong>Array.from()</strong></code> erstellt ein Array aus:</p> + +<ul> + <li>Array-ähnliche Objekte (Objekte mit einer <code>length</code> Eigenschaft und indexierten Elementen) oder</li> + <li><a href="/de/docs/Web/JavaScript/Guide/iterable">Iterierbare Objekte</a> (Objekte welche Elemente zurückgeben können, wie zum Beispiel {{jsxref("Map")}} und {{jsxref("Set")}}).</li> +</ul> + +<p><strong>Array.from() </strong>hat einen optionalen Parameter <code>mapFn</code>, welcher es erlaubt eine {{jsxref("Array.prototype.map", "map")}} Funktion auf jedem Element des Arrays (oder Subklassen) das erstellt wird, auszuführen. Genauer gesagt, ist <code>Array.from(obj, mapFn, thisArg)</code> dasselbe wie <code>Array.from(obj).map(mapFn, thisArg)</code>, mit dem Unterschied, dass kein Array als Zwischenergebnis produziert wird. Das ist besonders wichtig für Array Subklassen, wie <a href="/de/docs/Web/JavaScript/Typed_arrays">typed Arrays</a>. Das Array des Zwischenergebnisses<br> + würde sonst Werte kürzen, um dem zutreffenden Typ zu entsprechen.</p> + +<p>Die <code>length</code> Eigenschaft der <code>from()</code> Methode ist 1.</p> + +<p>In ES2015 erlaubt die class Syntax, Subklassen für eingebaute und benutzerdefinierte Klassen. Klassenseitige statische Methoden wie <code>Array.from()</code><strong> </strong>sind von der Subklasse <code>Array</code> vererbt und erzeugen eine neue Instanz der Subklasse und nicht von <code>Array</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Array_von_einem_String">Array von einem <code>String</code></h3> + +<pre class="brush: js">Array.from('foo'); +// ["f", "o", "o"];</pre> + +<h3 id="Array_von_einem_Set">Array von einem <code>Set</code></h3> + +<pre class="brush: js">var s = new Set(["foo", window]); +Array.from(s); +// ["foo", window]</pre> + +<h3 id="Array_von_einem_Map">Array von einem <code>Map</code></h3> + +<pre class="brush: js">var m = new Map([[1, 2], [2, 4], [4, 8]]); +Array.from(m); +// [[1, 2], [2, 4], [4, 8]] + +var mapper = new Map([['1', 'a'], ['2', 'b']]); +Array.from(mapper.values()); +// ['a', 'b']; + +Array.from(mapper.keys()); +// ['1', '2'];</pre> + +<h3 id="Array_von_einem_Array_ähnlichen_Objekt_(arguments)">Array von einem Array ähnlichen Objekt (<code>arguments</code>)</h3> + +<pre class="brush: js">function f() { + return Array.from(arguments); +} + +f(1, 2, 3); + +// [1, 2, 3]</pre> + +<h3 id="Einsatz_von_Arrow-Funktionen_und_Array.from">Einsatz von Arrow-Funktionen und <code>Array.from</code></h3> + +<pre class="brush: js">// Using an arrow function as the map function to +// manipulate the elements +Array.from([1, 2, 3], x => x + x); +// [2, 4, 6] + + +// Generate a sequence of numbers +// Since the array is initialized with `undefined` on each position, +// the value of `v` below will be `undefined` +Array.from({length: 5}, (v, i) => i); +// [0, 1, 2, 3, 4] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>Array.from()</code> wurde zum ECMA-262 Standard in der 6ten Version hinzugefügt. Es kann sein, dass diese in anderen Implementationen des Standards nicht verfügbar ist. Man kann das mit folgendem Code am Anfang eines Skriptes umgehen. Das Skript erlaubt das Benutzen von <code>Array.from()</code><strong> </strong>in Implementationen, welche Array.from() nicht nativ unterstützen. Dieser Algorithmus ist genau derselbe, welcher in EMCA-262, 6te Version implementiert ist, angenommen Object und TypeError haben ihre originalen Werte und <code>callback.call</code> evaluiert den Original Wert von {{jsxref("Function.prototype.call")}}. Außerdem können echte iterierbare Elemente nicht mit einem Polyfill implementiert werden. Diese Implementation unterstützt keine generischen iterierbaren Elemente so wie sie definiert sind in der 6ten Version von ECMA-262.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 6, 22.1.2.1 +if (!Array.from) { + Array.from = (function () { + var toStr = Object.prototype.toString; + var isCallable = function (fn) { + return typeof fn === 'function' || toStr.call(fn) === '[object Function]'; + }; + var toInteger = function (value) { + var number = Number(value); + if (isNaN(number)) { return 0; } + if (number === 0 || !isFinite(number)) { return number; } + return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); + }; + var maxSafeInteger = Math.pow(2, 53) - 1; + var toLength = function (value) { + var len = toInteger(value); + return Math.min(Math.max(len, 0), maxSafeInteger); + }; + + // The length property of the from method is 1. + return function from(arrayLike/*, mapFn, thisArg */) { + // 1. Let C be the this value. + var C = this; + + // 2. Let items be ToObject(arrayLike). + var items = Object(arrayLike); + + // 3. ReturnIfAbrupt(items). + if (arrayLike == null) { + throw new TypeError('Array.from requires an array-like object - not null or undefined'); + } + + // 4. If mapfn is undefined, then let mapping be false. + var mapFn = arguments.length > 1 ? arguments[1] : void undefined; + var T; + if (typeof mapFn !== 'undefined') { + // 5. else + // 5. a If IsCallable(mapfn) is false, throw a TypeError exception. + if (!isCallable(mapFn)) { + throw new TypeError('Array.from: when provided, the second argument must be a function'); + } + + // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 2) { + T = arguments[2]; + } + } + + // 10. Let lenValue be Get(items, "length"). + // 11. Let len be ToLength(lenValue). + var len = toLength(items.length); + + // 13. If IsConstructor(C) is true, then + // 13. a. Let A be the result of calling the [[Construct]] internal method + // of C with an argument list containing the single item len. + // 14. a. Else, Let A be ArrayCreate(len). + var A = isCallable(C) ? Object(new C(len)) : new Array(len); + + // 16. Let k be 0. + var k = 0; + // 17. Repeat, while k < len… (also steps a - h) + var kValue; + while (k < len) { + kValue = items[k]; + if (mapFn) { + A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k); + } else { + A[k] = kValue; + } + k += 1; + } + // 18. Let putStatus be Put(A, "length", len, true). + A.length = len; + // 20. Return A. + return A; + }; + }()); +} +</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-array.from', 'Array.from')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.from', 'Array.from')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.from")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("TypedArray.from()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/includes/index.html b/files/de/web/javascript/reference/global_objects/array/includes/index.html new file mode 100644 index 0000000000..64a51dfb73 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/includes/index.html @@ -0,0 +1,181 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/Array/includes +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>includes()</strong></code> Methode prüft, ob ein Array ein bestimmtes Element enthält, und gibt entsprechend <code>true</code> oder <code>false</code> aus. Es wird der selbe sameValueZero-Algorithmus benutzt, um ein gegebenes Element zu finden.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-includes.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.includes(<var>searchElement</var>[, <var>fromIndex</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Das zu suchende Element.</dd> + <dt><code>fromIndex </code> {{optional_inline}}</dt> + <dd>Die Position im Array, ab welcher die Suche nach <code>searchElement</code> beginnt. Bei einem negativen Wert fängt die Suche beim Index <code>array.length - fromIndex</code> an. Default ist 0.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<dl> + <dt> + <p>Ein {{jsxref("Boolean")}}.</p> + </dt> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">[1, 2, 3].includes(2); // true +[1, 2, 3].includes(4); // false +[1, 2, 3].includes(3, 3); // false +[1, 2, 3].includes(3, -1); // true +[1, 2, NaN].includes(NaN); // true +</pre> + +<h3 id="fromIndex_ist_größer_oder_gleich_der_Arraylänge"><code>fromIndex</code> ist größer oder gleich der Arraylänge</h3> + +<p>Wenn <code>fromIndex</code> größer oder gleich der Arraylänge ist, wird <code>false</code> zurückgegeben. Das Array wird nicht durchsucht.</p> + +<pre class="brush: js">var arr = ['a', 'b', 'c']; + +arr.includes('c', 3); // false +arr.includes('c', 100); // false +</pre> + +<h3 id="Berechneter_Index_ist_kleiner_als_0">Berechneter Index ist kleiner als 0</h3> + +<p>Wenn <code>fromIndex</code> negativ ist, wird der Index berechnet, an dem die Suche im Array nach <code>searchElement</code> beginnen soll. Wenn diese Berechnung einen Index kleiner als 0 ergibt, wird das ganze Array durchsucht.</p> + +<pre class="brush: js">// Arraylänge ist 3 +// fromIndex ist -100 +// Der berechnete Index ist 3 + (-100) = -97 + +var arr = ['a', 'b', 'c']; + +arr.includes('a', -100); // true +arr.includes('b', -100); // true +arr.includes('c', -100); // true +</pre> + +<h3 id="Einsatz_von_includes()_als_generische_Methode">Einsatz von <code>includes()</code> als generische Methode</h3> + +<p>Die <code>includes()</code>-Methode is absichtlich generisch. Die <code>this</code>-Referenz muss nicht auf ein Array-Objekt zeigen, so dass auch andere Objekte (z. B. Array-ähnliche Objekte) genutzt werden können. Das Beispiel zeigt, wie <code>includes()</code> auf den Parametern (<a href="/de/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>) einer Funktion aufgerufen wird.</p> + +<pre class="brush: js">(function() { + console.log([].includes.call(arguments, 'a')); // true + console.log([].includes.call(arguments, 'd')); // false +})('a', 'b', 'c') +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.includes +if (!Array.prototype.includes) { + Object.defineProperty(Array.prototype, 'includes', { + value: function(searchElement, fromIndex) { + + if (this == null) { + throw new TypeError('"this" is null or not defined'); + } + + // 1. Let O be ? ToObject(this value). + var o = Object(this); + + // 2. Let len be ? ToLength(? Get(O, "length")). + var len = o.length >>> 0; + + // 3. If len is 0, return false. + if (len === 0) { + return false; + } + + // 4. Let n be ? ToInteger(fromIndex). + // (If fromIndex is undefined, this step produces the value 0.) + var n = fromIndex | 0; + + // 5. If n ≥ 0, then + // a. Let k be n. + // 6. Else n < 0, + // a. Let k be len + n. + // b. If k < 0, let k be 0. + var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0); + + function sameValueZero(x, y) { + return x === y || (typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y)); + } + + // 7. Repeat, while k < len + while (k < len) { + // a. Let elementK be the result of ? Get(O, ! ToString(k)). + // b. If SameValueZero(searchElement, elementK) is true, return true. + if (sameValueZero(o[k], searchElement)) { + return true; + } + // c. Increase k by 1. + k++; + } + + // 8. Return false + return false; + } + }); +} +</pre> + +<p>Sollten Sie wirklich veraltete JavaScript-Engines unterstützen müssen, die ihrerseits {{jsxref("Object.defineProperty", "Object.defineProperty")}} nicht unterstützen, ist es ratsam, die <code>Array.prototype</code>-Methode nicht mit dem Polyfill zu erweitern, da man diese nicht unabzählbar (non-enumerable) machen kann.</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('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td> + <td>{{Spec2('ES7')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.includes")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("TypedArray.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.findIndex()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/index.html b/files/de/web/javascript/reference/global_objects/array/index.html new file mode 100644 index 0000000000..d60c037b82 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/index.html @@ -0,0 +1,460 @@ +--- +title: Array +slug: Web/JavaScript/Reference/Global_Objects/Array +tags: + - Array + - Example + - Global Objects + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array +--- +<div>{{JSRef}}</div> + +<p>Das JavaScript-<strong><code>Array</code></strong> ist ein globales Objekt und Konstruktor für das Erstellen von Arrays, welche listenähnliche Objekte sind.</p> + +<p><strong>Ein Array erstellen</strong></p> + +<pre class="brush: js">var fruits = ['Apple', 'Banana']; + +console.log(fruits.length); +// 2 +</pre> + +<p><strong>Zugriff auf ein Arrayelement (mit Index)</strong></p> + +<pre class="brush: js">var first = fruits[0]; +// Apple + +var last = fruits[fruits.length - 1]; +// Banana +</pre> + +<p><strong>Über ein Array Iterieren</strong></p> + +<pre class="brush: js">fruits.forEach(function(item, index, array) { + console.log(item, index); +}); +// Apple 0 +// Banana 1 +</pre> + +<p><strong>Ein Element am Ende des Arrays einfügen</strong></p> + +<pre class="brush: js">var newLength = fruits.push('Orange'); +// ["Apple", "Banana", "Orange"] +</pre> + +<p><strong>Ein Element am Ende des Arrays löschen</strong></p> + +<pre class="brush: js">var last = fruits.pop(); // remove Orange (from the end) +// ["Apple", "Banana"]; +</pre> + +<p><strong>Ein Element am Anfang des Arrays löschen</strong></p> + +<pre class="brush: js">var first = fruits.shift(); // remove Apple from the front +// ["Banana"]; +</pre> + +<p><strong>Ein Element am Anfang des Arrays einfügen</strong></p> + +<pre class="brush: js">var newLength = fruits.unshift('Strawberry') // add to the front +// ["Strawberry", "Banana"]; +</pre> + +<p><strong>Den Index eines Elements im Array ermitteln</strong></p> + +<pre class="brush: js">fruits.push('Mango'); +// ["Strawberry", "Banana", "Mango"] + +var pos = fruits.indexOf('Banana'); +// 1 +</pre> + +<p><strong>Ein Element mithilfe eines Index aus dem Array löschen</strong></p> + +<pre class="brush: js">var removedItem = fruits.splice(pos, 1); // this is how to remove an item + +// ["Strawberry", "Mango"]</pre> + +<p><strong>Elemente von einer Indexposition aus löschen</strong></p> + +<pre class="brush: js">var vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot']; +console.log(vegetables); +// ["Cabbage", "Turnip", "Radish", "Carrot"] + +var pos = 1, n = 2; + +var removedItems = vegetables.splice(pos, n); +// this is how to remove items, n defines the number of items to be removed, +// from that position(pos) onward to the end of array. + +console.log(vegetables); +// ["Cabbage", "Carrot"] (the original array is changed) + +console.log(removedItems); +// ["Turnip", "Radish"]</pre> + +<p><strong>Ein Array kopieren</strong></p> + +<pre class="brush: js">var shallowCopy = fruits.slice(); // this is how to make a copy +// ["Strawberry", "Mango"] +</pre> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>] +new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]]) +new Array(<var>arrayLength</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Ein JavaScript-Array wird mit den angegebenen Elementen initialisiert, es sei denn, an den <code>Array</code>-Konstruktor wird eine einzelne Zahl übergeben (siehe <code>arrayLength-</code>Parameter unten). Beachte, dass dieser Sonderfall nur für JavaScript-Arrays gilt, die mit dem <code>Array</code>-Konstruktor erstellt wurden, nicht für Array-Literale, die mit der Klammer-Syntax erstellt wurden.</dd> + <dt><code>arrayLength</code></dt> + <dd>Wenn lediglich eine Ganzzahl zwischen 0 und 2<sup>32</sup>-1 (inklusive) als Argument an den <code>Array</code>-Konstruktor übergeben wird, ist der Rückgabewert ein JavaScript Array, dessen <code>length</code>-Eigenschaft dieser Zahl entspricht. (<strong>Hinweis:</strong> Dies impliziert ein Array mit leeren Elementen einer Anzahl von <code>arrayLength</code>, nicht Elementen mit Wert <code>undefined</code>). Handelt es sich bei dem Argument um irgendeine andere Zah,l wird eine {{jsxref("Global_Objects/RangeError", "RangeError")}} Exception ausgelöst.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Arrays sind listenähnliche Objekte, dessen Prototyp Methoden für Durchlauf- und Mutationsoperationen besitzt. Weder die Länge eines JavaScript-Arrays noch die Typen seiner Elemente sind fix. Da sich die Länge eines Arrays jederzeit ändern kann und Daten an nicht zusammenhängenden Positionen im Array gespeichert werden können, ist nicht garantiert, dass JavaScript-Arrays verdichtet sind; dies hängt davon ab, wie der Programmierer sie benutzt. Im Allgemeinen sind dies praktische Merkmale; falls jedoch diese Funktionalität für Ihren Anwendungsfall nicht wünschenswert ist, sollten Sie in Betracht ziehen, typisierte Arrays zu verwenden.</p> + +<p>Arrays können keine Strings als Index benutzen (wie bei<a class="external" href="http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/"> assoziativen Arrays</a>), sondern müssen Ganzzahlen verwenden. Der Zugriff mit nicht-ganzzahligen Werten über die <a href="/de/docs/Web/JavaScript/Guide/Mit_Objekten_arbeiten#Objekte_und_Eigenschaften">Klammernotation</a> (oder <a href="/de/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Punktnotation</a>) bezieht sich nicht auf ein Element im Array, sondern legt eine Eigenschaft des Array-Objekts fest oder greift darauf zu. Die Eigenschaften des Array-Objekts und die Liste der Array-Elemente sind voneinander getrennt. Die <a href="/de/docs/Web/JavaScript/Guide/Indexed_collections#Array-Methoden">Durchlauf- und Mutationsoperationen</a> des Arrays können nicht auf diese benannten Eigenschaften angewendet werden.</p> + +<h3 id="Accessing_array_elements" name="Accessing_array_elements">Auf Elemente des Arrays zugreifen</h3> + +<p>JavaScript-Arrays sind nullindiziert: Das erste Element eines Arrays befindet sich am Index <code>0</code>, das letzte Element befindet sich an demjenigen Index, der dem Wert der Eigenschaft {{jsxref ("Array.length", "length")}} des Arrays minus 1 entspricht. Die Verwendung einer ungültigen Indexnummer gibt <code>undefined</code> zurück.</p> + +<pre class="brush: js">var arr = ['Das erste Element', 'Das zweite Element', 'Das letzte Element']; +console.log(arr[0]); // Ausgabe: 'Das erste Element' +console.log(arr[1]); // Ausgabe: 'Das zweite Element' +console.log(arr[arr.length - 1]); // Ausgabe: 'Das letzte Element' +</pre> + +<p>Array-Elemente sind Objekteigenschaften genau so wie <code>toString</code>. Wenn man jedoch wie folgt auf ein Element eines Arrays versucht zuzugreifen, wird ein Syntaxfehler ausgegeben, da der Name der Eigenschaft ungültig ist:</p> + +<pre class="brush: js">console.log(arr.0); // Syntaxfehler +</pre> + +<p>Es gibt nichts Besonderes an JavaScript-Arrays und den Eigenschaften, die dies verursachen. JavaScript-Eigenschaften, die mit einer Ziffer beginnen, können nicht mit Punktnotation referenziert werden und müssen über Klammernotation aufgerufen werden. Wenn man beispielsweise ein Objekt mit einer Eigenschaft namens <code>'3d'</code> hat, kann es nur in Klammern angegeben werden, z. B.:</p> + +<pre class="brush: js">var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010]; +console.log(years.0); // ein Syntaxfehler +console.log(years[0]); // funktioniert +</pre> + +<pre class="brush: js">renderer.3d.setTexture(model, 'character.png'); // ein Syntaxfehler +renderer['3d'].setTexture(model, 'character.png'); // works funktioniert +</pre> + +<p>Beachten Sie, dass im obigen Beispiel <code>'3d'</code> in Anführungszeichen gesetzt werden musste. Es ist auch möglich, die JavaScript-Array-Indizes in Anführungszeichen zu setzen (z. B. <code>years['2']</code> statt <code>years[2]</code>), obwohl dies nicht erforderlich ist. Die 2 in <code>years[2]</code> wird von der JavaScript-Engine durch eine implizite Konvertierung mittels <code>toString</code> zwingend in eine Zeichenfolge umgewandelt. Aus diesem Grund beziehen sich <code>'2'</code> und <code>'02'</code> auf zwei unterschiedliche Elemente des <code>years</code>-Objekts und das folgende Beispiel würde <code>true</code> ergeben:</p> + +<pre class="brush: js">console.log(years['2'] != years['02']); +</pre> + +<p>Ebenso kann auf Objekteigenschaften, die zufällig reservierte Wörter(!) sind, nur als Stringliterale in Klammern zugegriffen werden:</p> + +<pre class="brush: js">var promise = { + 'var' : 'text', + 'array': [1, 2, 3, 4] +}; + +console.log(promise['var']); +</pre> + +<h3 id="Relationship_between_length_and_numerical_properties" name="Relationship_between_length_and_numerical_properties">Beziehung zwischen <code>length</code> und numerischen Eigenschaften</h3> + +<p>Die Eigenschaft {{jsxref("Array.length", "length")}} eines JavaScript-Arrays und numerische Eigenschaften sind miteinander verbunden. Etliche der eingebauten Array-Methoden (z. B. {{jsxref("Array.join", "join()")}}, {{jsxref("Array.slice", "slice()")}}, {{jsxref("Array.indexOf", "indexOf()")}}, etc.) berücksichtigen den Wert der {{jsxref("Array.length", "length")}} Eigenschaft eines Arrays, wenn diese aufgerufen werden. Andere Methoden (z. B. {{jsxref("Array.push", "push()")}}, {{jsxref("Array.splice", "splice()")}}, etc.) bewirken ebenfalls eine Veränderung der Eigenschaft {{jsxref("Array.length", "length")}} eines Arrays.</p> + +<pre class="brush: js">var fruits = []; +fruits.push('banana', 'apple', 'peach'); + +console.log(fruits.length); // 3 +</pre> + +<p>Wird einem JavaScript-Array eine Eigenschaft zugewiesen, bei der es sich um einen gültigen Array-Index handelt und dieser Index außerhalb der aktuellen Grenzen des Arrays liegt, aktualisiert die Engine die Eigenschaft {{jsxref("Array.length", "length")}} des Arrays entsprechend:</p> + +<pre class="brush: js">fruits[5] = 'mango'; +console.log(fruits[5]); // 'mango' +console.log(Object.keys(fruits)); // ['0', '1', '2', '5'] +console.log(fruits.length); // 6 +</pre> + +<p>Beim Erhöhen von {{jsxref("Array.length", "length")}}.</p> + +<pre class="brush: js">fruits.length = 10; +console.log(Object.keys(fruits)); // ['0', '1', '2', '5'] +console.log(fruits.length); // 10 +</pre> + +<div> +<p>Beim Verringern von {{jsxref("Array.length", "length")}} werden jedoch Elemente gelöscht.</p> + +<pre class="brush: js">fruits.length = 2; +console.log(Object.keys(fruits)); // ['0', '1'] +console.log(fruits.length); // 2 +</pre> + +<p>Der Artikel zu {{jsxref("Array.length")}} geht genauer darauf ein.</p> +</div> + +<h3 id="Creating_an_array_using_the_result_of_a_match" name="Creating_an_array_using_the_result_of_a_match">Erstellen eines Arrays als Ergebnis einer Übereinstimmung</h3> + +<p>Das Ergebnis einer Übereinstimmung eines regulären Ausdrucks und einem String kann ein JavaScript-Array erstellen. Dieses Array verfügt über Eigenschaften und Elemente, die Informationen zur Übereinstimmung beinhalten. Solch ein Array wird von {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}} und {{jsxref("String.replace")}} zurückgegeben. Am folgenden Beispiel sollen diese Eigenschaften und Elemente erläutert werden, die Tabelle darunter enthält; weitere Informationen hierzu:</p> + +<pre class="brush: js">// Übereinstimmung eines d, gefolgt von einem oder mehreren b, gefolgt von einem d +// Übereinstimmende b's und die darauf folgenden d's merken +// Groß-/Kleinschreibung ignorieren + +var myRegEx = /d(b+)(d)/i; +var myArray = myRegEx.exec('cdbBdbsbz');</pre> + +<p>Die Eigenschaften und Elemente werden wie folgt zurückgegeben:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Eigenschaft/Element</td> + <td class="header">Beschreibung</td> + <td class="header">Beispiel</td> + </tr> + <tr> + <td><code>input</code></td> + <td> + <p>Eine schreibgeschützte Eigenschaft, die die ursprüngliche Zeichenfolge widerspiegelt, mit der der reguläre Ausdruck abgeglichen wurde.</p> + </td> + <td>cdbBdbsbz</td> + </tr> + <tr> + <td><code>index</code></td> + <td>Eine schreibgeschützte Eigenschaft, bei der es sich um den nullbasierten Index der Übereinstimmung in der Zeichenfolge handelt.</td> + <td>1</td> + </tr> + <tr> + <td><code>[0]</code></td> + <td>Ein schreibgeschütztes Element, das die zuletzt übereinstimmenden Zeichen angibt.</td> + <td>dbBd</td> + </tr> + <tr> + <td><code>[1], ...[n]</code></td> + <td>Schreibgeschützte Elemente, die die in Klammern gesetzten Unterzeichenfolgen angeben, sofern sie im regulären Ausdruck enthalten sind. Die Anzahl der möglichen geklammerten Teilzeichenfolgen ist unbegrenzt.</td> + <td>[1]: bB<br> + [2]: d</td> + </tr> + </tbody> +</table> + +<h2 id="Properties" name="Properties">Eigenschaften</h2> + +<dl> + <dt>Array.length</dt> + <dd>Die Eigenschaft <code>length</code> des <code>Array-</code>Konstruktors, deren Wert 1 ist.</dd> + <dt>{{jsxref("Array.@@species", "get Array[@@species]")}}</dt> + <dd>Die Konstruktorfunktion zum Erstellen abgeleiteter Objekte.</dd> + <dt>{{jsxref("Array.prototype")}}</dt> + <dd>Ermöglicht das Hinzufügen von Eigenschaften zu allen Array-Objekten.</dd> +</dl> + +<h2 id="Methods" name="Methods">Methoden</h2> + +<dl> + <dt>{{jsxref("Array.from()")}}</dt> + <dd>Erstellt eine neue <code>Array</code>-Instanz aus einem Array-ähnlichen oder iterierbaren Objekt.</dd> + <dt>{{jsxref("Array.isArray()")}}</dt> + <dd>Gibt <code>true</code> zurück, wenn eine Variable ein Array ist, andernfalls <code>false</code>.</dd> + <dt>{{jsxref("Array.of()")}}</dt> + <dd>Erstellt eine neue <code>Array</code>-Instanz mit einer variablen Anzahl von Argumenten, unabhängig von Anzahl oder Typ der Argumente.</dd> +</dl> + +<h2 id="Array_instances" name="Array_instances"><code>Array</code> Instanzen</h2> + +<p>Alle <code>Array</code>-Instanzen erben von {{jsxref("Array.prototype")}}. Das Prototypobjekt des <code>Array</code>-Konstruktors kann geändert werden, um alle <code>Array</code>-Instanzen zu beeinflussen.</p> + +<h3 id="Methods_of_array_instances" name="Methods_of_array_instances">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methods_of_array_instances" name="Methods_of_array_instances">Methoden</h3> + +<h4 id="Mutator_methods" name="Mutator_methods">Mutationsmethoden</h4> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutationsmethoden')}}</div> + +<h4 id="Accessor_methods" name="Accessor_methods">Zugriffsmethoden</h4> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Zugriffsmethoden')}}</div> + +<h4 id="Iteration_methods" name="Iteration_methods">Zählmethoden</h4> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Zählmethoden')}}</div> + +<h2 id="Array_generic_methods" name="Array_generic_methods">Generische <code>Array</code>-Methoden</h2> + +<div class="warning"> +<p><strong>Generische Array Methoden sind nicht standardisiert, veraltet und werden in naher Zukunft entfernt. </strong></p> +</div> + +<p>Manchmal möchte man Array-Methoden auf Strings oder andere Array-ähnliche Objekte anwenden (z. B. auf {{jsxref("Functions/arguments", "Argumente", "", 1)}} von Funktionen). Auf diese Weise behandelt man eine Zeichenfolge wie ein Array von Zeichen (oder ein nicht-Array wie ein Array). Um beispielsweise zu prüfen, ob jedes Zeichen in der Variablen <code><em>str</em></code> ein Buchstabe ist, würde man Folgendes schreiben:</p> + +<pre class="brush: js">function isLetter(character) { + return character >= 'a' && character <= 'z'; +} + +if (Array.prototype.every.call(str, isLetter)) { + console.log("The string '" + str + "' contains only letters!"); +}</pre> + +<p>Diese Schreibweise wurde in JavaScript 1.6 von einer kürzeren abgelöst:</p> + +<pre class="brush: js">if (Array.every(str, isLetter)) { + console.log("The string '" + str + "' contains only letters!"); +} +</pre> + +<p>{{jsxref("Global_Objects/String", "Generische Methoden", "#Generische_String-Methoden", 1)}} gibt es ebenfalls für {{jsxref("Global_Objects/String", "Strings")}}.</p> + +<p>Diese sind <strong>nicht</strong> Teil der ECMAScript-Standards und werden von nicht-Gecko-Browsern nicht unterstützt. Als Standardvariante können Sie Ihr Objekt mit {{jsxref("Array.from()")}} in ein richtiges Array konvertieren. Diese Methode wird in alten Browsern möglicherweise nicht unterstützt:</p> + +<pre class="brush: js">if (Array.from(str).every(isLetter)) { + console.log("The string '" + str + "' contains only letters!"); +} +</pre> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example_Creating_an_array" name="Example:_Creating_an_array">Erstellen eines Arrays</h3> + +<p>Das folgende Beispiel erzeugt ein Array <code>msgArray</code> mit der Länge 0, weist dann <code>msgArray[0]</code> und <code>msgArray[99]</code> Werte zu und ändert somit die Länge des Arrays auf 100.</p> + +<pre class="brush: js">var msgArray = []; +msgArray[0] = 'Hello'; +msgArray[99] = 'world'; + +if (msgArray.length === 100) { + console.log('Die Länge ist 100.'); +} +</pre> + +<h3 id="Example_Creating_a_two-dimensional_array" name="Example:_Creating_a_two-dimensional_array">Erstellen eines zweidimensionalen Arrays</h3> + +<p>Im Folgenden wird ein Schachbrett als zweidimensionales Array von Strings erzeugt. Der erste Zug erfolgt durch Kopieren des 'p' in (6,4) nach (4,4). Die alte Position (6,4) wird als leer markiert.</p> + +<pre class="brush: js">var board = [ + ['R','N','B','Q','K','B','N','R'], + ['P','P','P','P','P','P','P','P'], + [' ',' ',' ',' ',' ',' ',' ',' '], + [' ',' ',' ',' ',' ',' ',' ',' '], + [' ',' ',' ',' ',' ',' ',' ',' '], + [' ',' ',' ',' ',' ',' ',' ',' '], + ['p','p','p','p','p','p','p','p'], + ['r','n','b','q','k','b','n','r'] ]; + +console.log(board.join('\n') + '\n\n'); + +// Ziehe Bauern 2 Felder vorwärts +board[4][4] = board[6][4]; +board[6][4] = ' '; +console.log(board.join('\n')); +</pre> + +<p>Das ist die Ausgabe:</p> + +<pre class="eval">R,N,B,Q,K,B,N,R +P,P,P,P,P,P,P,P + , , , , , , , + , , , , , , , + , , , , , , , + , , , , , , , +p,p,p,p,p,p,p,p +r,n,b,q,k,b,n,r + +R,N,B,Q,K,B,N,R +P,P,P,P,P,P,P,P + , , , , , , , + , , , , , , , + , , , ,p, , , + , , , , , , , +p,p,p,p, ,p,p,p +r,n,b,q,k,b,n,r +</pre> + +<h3 id="Einsatz_eines_Arrays_um_Werte_tabellarisch_auszugeben">Einsatz eines Arrays, um Werte tabellarisch auszugeben</h3> + +<pre class="brush: js">values = []; +for (var x = 0; x < 10; x++){ + values.push([ + 2 ** x, + 2 * x ** 2 + ]) +}; +console.table(values)</pre> + +<p>Das Resultat ist:</p> + +<pre class="eval">0 1 0 +1 2 2 +2 4 8 +3 8 18 +4 16 32 +5 32 50 +6 64 72 +7 128 98 +8 256 128 +9 512 162</pre> + +<p>(Die erste Spalte ist der Index)</p> + +<h2 id="Specifications" name="Specifications">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4', 'Array')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Neue Methoden hinzugefügt: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array-objects', 'Array')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Neue Methoden hinzugefügt: {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}</td> + </tr> + <tr> + <td>{{SpecName('ES7', '#sec-array-objects', 'Array')}}</td> + <td>{{Spec2('ES7')}}</td> + <td>Neue Methode hinzugefügt: {{jsxref("Array.prototype.includes()")}}</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array-objects', 'Array')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Array")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Guide/Mit_Objekten_arbeiten#Indexing_object_properties">JavaScript Guide: “Indexing object properties”</a></li> + <li><a href="/de/docs/Web/JavaScript/Guide/Predefined_Core_Objects#Array_Object">JavaScript Guide: “Predefined Core Objects: <code>Array</code> Object”</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Array_comprehensions">Array comprehensions</a></li> + <li><a href="https://github.com/plusdude/array-generics">Polyfill für JavaScript 1.8.5 generische Arrays und ECMAScript 5 Array Extras</a></li> + <li><a href="/de/docs/JavaScript_typed_arrays">Typisierte Arrays</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/indexof/index.html b/files/de/web/javascript/reference/global_objects/array/indexof/index.html new file mode 100644 index 0000000000..1768427494 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/indexof/index.html @@ -0,0 +1,226 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/indexOf +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">Die Methode <code><strong>indexOf()</strong></code> gibt den Index zurück, an dem ein bestimmtes Element im Array zum ersten Mal auftritt oder -1 wenn es nicht vorhanden ist.</span></p> + +<div class="note"> +<p><strong>Hinweis:</strong> Für die String Methode, siehe {{jsxref("String.prototype.indexOf()")}}.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/array-indexof.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.indexOf(<var>searchElement[</var>, <var>fromIndex]</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Element, das im Array gefunden werden soll.</dd> + <dt><code>fromIndex</code> {{optional_inline}}</dt> + <dd>Der Index, an dem die Suche beginnen soll. Wenn dieser Index größer oder gleich der Länge des Arrays ist, wird -1 zurückgegeben, d. h. das Array wird nicht durchsucht. Ist der Startindex negativ, wird er als Versatz vom Ende des Arrays verstanden. Das Array wird dann immer noch von vorne nach hinten durchsucht.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Index, an dem das gefundene Element das erste Mal angetroffen wurde, andernfalls <strong>-1</strong> wenn nichts gefunden wurde.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>indexOf()</code> vergleicht <code>searchElement</code> mit Elementen des Arrays mittels <a href="/de/docs/Web/JavaScript/Reference/Operators/Vergleichsoperatoren#Die_Gleichheitsoperatoren_anwenden">strikter Gleichheit</a> (dieselbe Methode, die bei <code>===</code> angewendet wird).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_indexOf()">Verwendung von <code>indexOf()</code></h3> + +<p>Das folgende Beispiel nutzt <code>indexOf()</code> um Werte in einem Array zu ermitteln.</p> + +<pre class="brush: js">var array = [2, 9, 9]; +array.indexOf(2); // 0 +array.indexOf(7); // -1 +array.indexOf(9, 2); // 2 +array.indexOf(2, -1); // -1 +array.indexOf(2, -3); // 0 +</pre> + +<h3 id="Alle_Vorkommnisse_eines_Elements_ermitteln">Alle Vorkommnisse eines Elements ermitteln</h3> + +<pre class="brush: js">var indices = []; +var array = ['a', 'b', 'a', 'c', 'a', 'd']; +var element = 'a'; +var idx = array.indexOf(element); +while (idx != -1) { + indices.push(idx); + idx = array.indexOf(element, idx + 1); +} +console.log(indices); +// [0, 2, 4] +</pre> + +<h3 id="Ermitteln_ob_ein_Element_in_einem_Array_existiert_und_das_Array_aktualisieren">Ermitteln, ob ein Element in einem Array existiert und das Array aktualisieren</h3> + +<pre class="brush: js">function updateVegetablesCollection (veggies, veggie) { + if (veggies.indexOf(veggie) === -1) { + veggies.push(veggie); + console.log('New veggies collection is : ' + veggies); + } else if (veggies.indexOf(veggie) > -1) { + console.log(veggie + ' already exists in the veggies collection.'); + } +} + +var veggies = ['potato', 'tomato', 'chillies', 'green-pepper']; + +updateVegetablesCollection(veggies, 'spinach'); +// New veggies collection is : potato,tomato,chillies,green-pepper,spinach +updateVegetablesCollection(veggies, 'spinach'); +// spinach already exists in the veggies collection. +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>indexOf()</code> wurde dem ECMA-262-Standard in der 5. Auflage hinzugefügt. Als solches ist es möglicherweise nicht in allen Implementierungen des Standards enthalten. Sie können dies umgehen, indem Sie den folgenden Code am Anfang Ihrer Skripte einfügen, um die Verwendung von <code>indexOf()</code> in Implementierungen zu ermöglichen, die es nicht nativ unterstützen. Dieser Algorithmus entspricht dem in der 5. Auflage von ECMA-262 angegebenen Algorithmus, vorausgesetzt {{jsxref("TypeError")}} und {{jsxref("Math.abs()")}} haben ihre ursprünglichen Werte.</p> + +<pre class="brush: js">if (!Array.prototype.indexOf) Array.prototype.indexOf = (function(Object, max, min){ + "use strict"; + return function indexOf(member, fromIndex) { + if(this===null||this===undefined)throw TypeError("Array.prototype.indexOf called on null or undefined"); + + var that = Object(this), Len = that.length >>> 0, i = min(fromIndex | 0, Len); + if (i < 0) i = max(0, Len+i); else if (i >= Len) return -1; + + if(member===void 0){ for(; i !== Len; ++i) if(that[i]===void 0 && i in that) return i; // undefined + }else if(member !== member){ for(; i !== Len; ++i) if(that[i] !== that[i]) return i; // NaN + }else for(; i !== Len; ++i) if(that[i] === member) return i; // all else + + return -1; // if the value was not found, then return -1 + }; +})(Object, Math.max, Math.min); +</pre> + +<p>Wenn Sie sich jedoch mehr für all die kleinen technischen Elemente interessieren, die durch den ECMA-Standard definiert werden, und Leistung oder Prägnanz weniger von Belang sind, dann könnte diese erklärende Polyfill-Lösung nützlicher für Sie sein.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.14 +// Reference: http://es5.github.io/#x15.4.4.14 +if (!Array.prototype.indexOf) { + Array.prototype.indexOf = function(searchElement, fromIndex) { + + var k; + + // 1. Let o be the result of calling ToObject passing + // the this value as the argument. + if (this == null) { + throw new TypeError('"this" is null or not defined'); + } + + var o = Object(this); + + // 2. Let lenValue be the result of calling the Get + // internal method of o with the argument "length". + // 3. Let len be ToUint32(lenValue). + var len = o.length >>> 0; + + // 4. If len is 0, return -1. + if (len === 0) { + return -1; + } + + // 5. If argument fromIndex was passed let n be + // ToInteger(fromIndex); else let n be 0. + var n = fromIndex | 0; + + // 6. If n >= len, return -1. + if (n >= len) { + return -1; + } + + // 7. If n >= 0, then Let k be n. + // 8. Else, n<0, Let k be len - abs(n). + // If k is less than 0, then let k be 0. + k = Math.max(n >= 0 ? n : len - Math.abs(n), 0); + + // 9. Repeat, while k < len + while (k < len) { + // a. Let Pk be ToString(k). + // This is implicit for LHS operands of the in operator + // b. Let kPresent be the result of calling the + // HasProperty internal method of o with argument Pk. + // This step can be combined with c + // c. If kPresent is true, then + // i. Let elementK be the result of calling the Get + // internal method of o with the argument ToString(k). + // ii. Let same be the result of applying the + // Strict Equality Comparison Algorithm to + // searchElement and elementK. + // iii. If same is true, return k. + if (k in o && o[k] === searchElement) { + return k; + } + k++; + } + return -1; + }; +} +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.14', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.indexOf")}}</p> +</div> + +<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2> + +<ul> + <li>Ab Firefox 47 {{geckoRelease(47)}} gibt diese Methode nicht mehr -0 zurück, z. B. gibt <code>[0].indexOf(0, -0)</code> jetzt immer <code>+0</code> zurück ({{bug(1242043)}}).</li> +</ul> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/isarray/index.html b/files/de/web/javascript/reference/global_objects/array/isarray/index.html new file mode 100644 index 0000000000..2bdca7596a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/isarray/index.html @@ -0,0 +1,121 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Reference/Global_Objects/Array/isArray +tags: + - Array + - ECMAScript5 + - JavaScript + - Method + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Array.isArray()</strong></code> Funktion prüft, ob das übergebene Objekt ein {{jsxref("Array")}} ist.</p> + +<pre class="brush: js">Array.isArray([1, 2, 3]); // true +Array.isArray({foo: 123}); // false +Array.isArray('foobar'); // false +Array.isArray(undefined); // false +</pre> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Array.isArray(<var>obj</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Der zu überprüfende Wert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Wenn der Wert ein {{jsxref("Array")}} ist wird <code>true</code> zurückgegeben, andernfalls <code>false</code>.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Wenn der Wert ein {{jsxref("Array")}} ist, wir <code>true</code> zurückzugeben, andernfalls <code>false</code>.</p> + +<p>Eine detailliertere Beschreibung ist im Artikel <a href="http://web.mit.edu/jwalden/www/isArray.html">Determining with absolute accuracy whether or not a JavaScript object is an array</a> enthalten (auf Englisch). Wird eine {{jsxref("TypedArray")}}-Instanz geprüft, wird immer <code>false</code> zurückgegeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Array.isArray">Einsatz von Array.isArray</h3> + +<pre class="brush: js">// die folgenden Ausdrücke geben true zurück +Array.isArray([]); +Array.isArray([1]); +Array.isArray(new Array()); +Array.isArray(new Array('a', 'b', 'c', 'd')); +Array.isArray(new Array(3)); +// wenig bekannt: Array.prototype ist selbst ein Array. +Array.isArray(Array.prototype); + +// die folgenden Ausdrücke geben alle false zurück +Array.isArray(); +Array.isArray({}); +Array.isArray(null); +Array.isArray(undefined); +Array.isArray(17); +Array.isArray("Array"); +Array.isArray(true); +Array.isArray(false); +Array.isArray(new Uint8Array(32)); +Array.isArray({ __proto__ : Array.prototype }); +</pre> + +<h3 id="instanceof_vs_isArray"><code>instanceof</code> vs <code>isArray</code></h3> + +<p>Wenn auf eine <code>Array</code> Instanz geprüft wird, ist <code>Array.isArray</code> besser geeignet als <code>instanceof</code>, weil es auch mit <code>iframes</code> funktioniert.</p> + +<pre class="brush: js">var iframe = document.createElement('iframe'); +document.body.appendChild(iframe); +xArray = window.frames[window.frames.length-1].Array; +var arr = new xArray(1,2,3); // [1,2,3] + +// Richtiges Prüfen für Arrays +Array.isArray(arr); // true +// Als nicht richtig angesehen, weil es nicht mit iframes funktioniert +arr instanceof Array; // false +</pre> + +<h2 id="Compatibility" name="Compatibility">Polyfill</h2> + +<p>Der folgende Code implementiert die Methode, wenn <code>Array.isArray()</code> nicht nativ unterstützt wird.</p> + +<pre class="brush: js">if(!Array.isArray) { + Array.isArray = function (vArg) { + return Object.prototype.toString.call(vArg) === "[object Array]"; + }; +} +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.isarray', 'Array.isArray')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.isArray")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/join/index.html b/files/de/web/javascript/reference/global_objects/array/join/index.html new file mode 100644 index 0000000000..4e986bebda --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/join/index.html @@ -0,0 +1,114 @@ +--- +title: Array.prototype.join() +slug: Web/JavaScript/Reference/Global_Objects/Array/join +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/join +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">Die <code><strong>join()</strong></code> Methode verkettet alle Elemente eines Arrays (oder <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">Array-ähnlicher Objekte</a>) durch Kommata getrennt oder einem angegebenen Trennzeichen in einem String und gibt diesen zurück. Enthält das Array nur ein Element wird nur dieses ohne Trennzeichen zurückgegeben.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/array-join.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.join([<var>separator</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>separator</code> {{optional_inline}}</dt> + <dd>Gibt einen String an, um jedes Paar benachbarter Elemente des Arrays voneinander zu trennen. Das Trennzeichen wird bei Bedarf in einen String umgewandelt. Wenn nicht angegeben, werden die Array-Elemente durch ein Komma (",") getrennt. Wenn <code>separator</code> ein leerer String ist, werden alle Elemente ohne Trennzeichen miteinander verbunden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String in dem alle Arrayelemente verkettet sind. Wenn <code><em>arr</em>.length</code> gleich <code>0</code> ist, wird der leere String zurückgegeben.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Alle Elemente des Arrays werden in Strings umgewandelt und in einem String miteinander verkettet</p> + +<div class="warning"> +<p>Falls ein Element <code>undefined</code> oder <code>null</code> ist, wird es in einen leeren String umgewandelt.</p> +</div> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Joining_an_array_three_different_ways" name="Example:_Joining_an_array_three_different_ways">Einen Array auf vier verschiedene Arten zusammenführen</h3> + +<p>Im folgenden Beispiel wird ein Array <code>a</code> mit drei Elementen erstellt, das dann viermal mit miteinander verbunden wird: mit dem Standardtrennzeichen, einem Komma mit Leerzeichen, einem Pluszeichen und einem leeren String.</p> + +<pre class="brush: js">var a = ['Wind', 'Rain', 'Fire']; +a.join(); // 'Wind,Rain,Fire' +a.join(', '); // 'Wind, Rain, Fire' +a.join(' + '); // 'Wind + Rain + Fire' +a.join(''); // 'WindRainFire' +</pre> + +<h3 id="Zusammenführen_eines_Array-ähnlichen_Objekts">Zusammenführen eines Array-ähnlichen Objekts</h3> + +<p>Das Folgende Beispiel fügt ein Array-ähnliches Objekt ({{jsxref("Functions/arguments", "arguments")}}) zusammen, indem {{jsxref("Function.prototype.call", "call()")}} auf <code>Array.prototype.join</code> aufgerufen wird.</p> + +<pre class="brush: js">function f(a, b, c) { + var s = Array.prototype.join.call(arguments); + console.log(s); // '<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string">1,a,true'</span></span></span></span> +} +f(1, 'a', true); +// Erwartete Ausgabe: "1,a,true" +</pre> + +<h2 id="Specifications" name="Specifications">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.4.4.5', 'Array.prototype.join')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.join', 'Array.prototype.join')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.join', 'Array.prototype.join')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.join")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.toString()")}}</li> + <li>{{jsxref("TypedArray.prototype.join()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/keys/index.html b/files/de/web/javascript/reference/global_objects/array/keys/index.html new file mode 100644 index 0000000000..e809654bcc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/keys/index.html @@ -0,0 +1,76 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Reference/Global_Objects/Array/keys +tags: + - Array + - ECMAScript 2015 + - Iterator + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>keys()</strong></code> Methode gibt ein neues <code><strong>Array Iterator</strong></code> Objekt zurück, welches den Schlüssel für jeden Index des Arrays enthält.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-keys.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><var>arr</var>.keys()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues {{jsxref("Array")}} iterator-Objekt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Der_Key_Iterator_ignoriert_keine_Lücken">Der Key Iterator ignoriert keine Lücken</h3> + +<pre class="brush: js notranslate">var arr = ['a', , 'c']; +var sparseKeys = Object.keys(arr); +var denseKeys = [...arr.keys()]; +console.log(sparseKeys); // ['0', '2'] +console.log(denseKeys); // [0, 1, 2] +</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-array.prototype.keys', 'Array.prototype.keys')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.keys")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.values()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> + <li><a href="/de/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/de/web/javascript/reference/global_objects/array/lastindexof/index.html new file mode 100644 index 0000000000..7ad2b99661 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/lastindexof/index.html @@ -0,0 +1,168 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +tags: + - Array + - ECMAScript 5 + - JavaScript + - Method + - Prototype + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>lastIndexOf()</strong></code> Methode gibt den letzten Index zurück, an dem ein übergebenes Element im Array gefunden wurde, oder -1, wenn es nicht vorhanden ist. Das Array wird rückwärts durchsucht beginnend beim <code>fromIndex</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-lastindexof.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.lastIndexOf(<var>searchElement</var>) +<var>arr</var>.lastIndexOf(<var>searchElement</var>, <var>fromIndex</var>) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Element, nach dem im Feld gesucht wird.</dd> + <dt><code>fromIndex</code> {{optional_inline}}</dt> + <dd>Der Index an dem die Suche rückwärts begonnen wird. Der Standardwert ist die Arraylänge minus eins (<code>arr.length - 1</code>), d. h. das gesamte Feld wird durchsucht. Wenn der Index größer oder gleich der Länge des Arrays ist, wird das gesamte Array durchsucht. Ist der Index eine negative Zahl, wird er als Offset vom Ende des Arrays behandelt. Bei Verwendung eines negativen Index wird das Array trotzdem von hinten nach vorne durchsucht. Wenn der errechnete Index kleiner als 0 ist, wird -1 zurückgegeben, d.h. das Feld wird nicht durchsucht.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der letzte Index des gesuchten Elementes aus dem Feld. <strong>-1</strong> wenn keins gefunden wurde.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>lastIndexOf</code> vergleicht das <code>searchElement</code> mit den Elementen des Feldes und verwendet hierzu die <a href="/de/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Die_Gleichheitsoperatoren_anwenden">strikte Gleichheit</a> (Die gleiche Methode, die beim <code>===</code> Operator (triple-equals) angewendet wird.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="lastIndexOf_verwenden"><code>lastIndexOf</code> verwenden</h3> + +<p>Das folgende Beispiel verwendet <code>lastIndexOf</code>, um Werte in einem Array zu finden.</p> + +<pre class="brush: js">var numbers = [2, 5, 9, 2]; +numbers.lastIndexOf(2); // 3 +numbers.lastIndexOf(7); // -1 +numbers.lastIndexOf(2, 3); // 3 +numbers.lastIndexOf(2, 2); // 0 +numbers.lastIndexOf(2, -2); // 0 +numbers.lastIndexOf(2, -1); // 3 +</pre> + +<h3 id="Finde_jedes_Vorkommen_eines_Elementes">Finde jedes Vorkommen eines Elementes</h3> + +<p>Das folgende Beispiel benutzt <code>lastIndexOf</code>, um alle Indizes eines Elementes in einem Array zu finden, wobei sie mit Hilfe von {{jsxref("Array.prototype.push", "push")}} zu einem anderen Array hinzugefügt werden, sobald sie gefunden werden.</p> + +<pre class="brush: js">var indices = []; +var array = ['a', 'b', 'a', 'c', 'a', 'd']; +var element = 'a'; +var idx = array.lastIndexOf(element); +while (idx != -1) { + indices.push(idx); + idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1); +} + +console.log(indices); +// [4, 2, 0] +</pre> + +<p>Der Fall <code>idx == 0</code> muss hier separat behandelt werden, weil das Element immer gefunden wird, unabhängig vom <code>fromIndex</code> Parameter, falls es das erste Element im Feld ist. Das ist der Unterschieder zur {{jsxref("Array.prototype.indexOf", "indexOf")}} Methode.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>lastIndexOf</code> wurde dem ECMA-262-Standard in der fünften Edition hinzugefügt; sie könnte daher nicht in allen Browsern verfügbar sein. Der Fehler kann umgangen werden, indem der folgende Code zu Beginn eines Skriptes eingesetzt wird. Dies ermöglicht die Verwendung von <code>lastIndexOf</code>, auch wenn die Methode nativ nicht unterstützt wird. Dieser Algorithmus stimmt mit dem überein, was in ECMA-262 der 5. Edition, spezifiziert wurde, unter der Annahme, dass {{jsxref("Object")}}, {{jsxref("TypeError")}}, {{jsxref("Number")}}, {{jsxref("Math.floor")}}, {{jsxref("Math.abs")}}, und {{jsxref("Math.min")}} ihre originalen Werte haben.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.15 +// Reference: http://es5.github.io/#x15.4.4.15 +if (!Array.prototype.lastIndexOf) { + Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/) { + 'use strict'; + + if (this === void 0 || this === null) { + throw new TypeError(); + } + + var n, k, + t = Object(this), + len = t.length >>> 0; + if (len === 0) { + return -1; + } + + n = len - 1; + if (arguments.length > 1) { + n = Number(arguments[1]); + if (n != n) { + n = 0; + } + else if (n != 0 && n != (1 / 0) && n != -(1 / 0)) { + n = (n > 0 || -1) * Math.floor(Math.abs(n)); + } + } + + for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) { + if (k in t && t[k] === searchElement) { + return k; + } + } + return -1; + }; +} +</pre> + +<p>Erneute Anmerkung: Diese Implementation zielt auf eine absolute Kompatibilität von <code>lastIndexOf</code> mit Firefox und der SpiderMonkey JavaScript Umgebung aus, inklusive einigen Fällen, welche wohl Grenzfälle sind. Beim Vorhaben diese Funktion in eigenen Applikationen zu verwenden, ist eine Berechnung von <code>from</code> mit weniger komplizierten Code möglich, wenn diese Fälle ignoriert werden.</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('ES5.1', '#sec-15.4.4.15', 'Array.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.lastIndexOf")}}</p> +</div> + +<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2> + +<ul> + <li>Beginnend mit Firefox 47 {{geckoRelease(47)}}, gibt diese Methode nicht mehr <code>-0 zurück</code>. Zum Beispiel wird <code>[0].lastIndexOf(0, -0)</code> immer <code>+0</code> zurückgeben ({{bug(1242043)}}).</li> +</ul> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/length/index.html b/files/de/web/javascript/reference/global_objects/array/length/index.html new file mode 100644 index 0000000000..5357719669 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/length/index.html @@ -0,0 +1,149 @@ +--- +title: Array.prototype.length +slug: Web/JavaScript/Reference/Global_Objects/Array/length +tags: + - Array + - JavaScript + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/length +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>length</strong></code> Eigenschaft eines Objektes vom Typ <code>Array</code> setzt die Anzahl der Elemente in einem Array oder gibt diese Anzahl zurück. Der Wert ist eine vorzeichenlose, 32-Bit Ganzzahl, welche größer als der größte Index im Array ist.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-length.html")}}</div> + + + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Der Wert der <code>length</code> Eigenschaft ist ein positive, ganze Zahl und hat einen Wert kleiner als 2<sup>32</sup>.</p> + +<pre class="brush: js notranslate">var namelistA = new Array(4294967296); //4294967296 = 2<sup>32</sup> +var namelistC = new Array(-100) //negative sign + +console.log(namelistA.length); //RangeError: Invalid array length +console.log(namelistC.length); //RangeError: Invalid array length + + + +var namelistB = []; +namelistB.length = Math.pow(2,32)-1; //set array length less than 2 to the 32nd power +console.log(namelistB.length); + +//4294967295 +</pre> + +<p>Man kann die <code>length</code> Eigenschaft eines Array zu jeder Zeit ändern, um das Array zu kürzen. Wenn ein Array mit dem Ändern der <code>length</code> Eigenschaft vergrößert wird, erhöht sich die Anzahl der der tatsächlichen Elemente. Wenn z. B. <code>length</code> auf 3 gesetzt wird und die aktuelle länge 2 ist, dann enthält das Array 3 Elemente, wobei das dritte Element <code>undefined</code> ist.</p> + +<pre class="brush: js notranslate">var arr = [1, 2, 3]; +printEntries(arr); + +arr.length = 5; // set array length to 5 while currently 3. +printEntries(arr); + +function printEntries(arr) { + var length = arr.length; + for (var i = 0; i < length; i++) { + console.log(arr[i]); + } + console.log('=== printed ==='); +} + +// 1 +// 2 +// 3 +// === printed === +// 1 +// 2 +// 3 +// undefined +// undefined +// === printed ===</pre> + +<p>Jedoch sagt die <code>length</code> Eigenschaft nicht zwangsläufig etwas über die Anzahl der definierten Werte in einem Array aus. Mehr dazu im Artikel <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array#Relationship_between_length_and_numerical_properties" title="Relationship between length and numerical properties">Beziehung zwischen Längen und nummerischen Eigenschaften</a>.</p> + +<p>{{js_property_attributes(1, 0, 0)}}</p> + +<div> +<ul> + <li><code>Writable</code>: Wenn das Attribut auf <code>false</code> gesetzt ist, kann der Wert der Eigenschaft nicht mehr geändert werden.</li> + <li><code>Configurable</code>: Wenn das Attribut auf <code>false</code> gesetzt ist, wird jeder Versuch scheitern, die Werte der Attribute <code>Writable</code>, <code>Configurable<font face="Arial, x-locale-body, sans-serif"><span style="background-color: #ffffff;"> und </span></font></code><code>Enumerable </code>zu ändern.</li> + <li><code>Enumerable</code>: Wenn das Attribut auf <code>true</code> gesetzt ist, wird das Attribut während <a href="/de/docs/Web/JavaScript/Reference/Statements/for">for</a> oder <a href="/de/docs/Web/JavaScript/Reference/Statements/for...in">for..in</a> Schleifen iteriert.</li> +</ul> +</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Iterieren_über_ein_Array">Iterieren über ein Array</h3> + +<p>Im folgenden Beispiel wird über das <code>numbers</code> Array iteriert. Dabei wird die <code>length</code> Eigenschaft verwendet, um festzustellen, wie viele Elemente das Array enthält. Der Wert jedes Elements wird dabei verdoppelt.</p> + +<pre class="brush: js notranslate">var numbers = [1, 2, 3, 4, 5]; + +for (var i = 0; i < numbers.length; i++) { + numbers[i] *= 2; +} +// numbers enthält jetzt die Werte: [2, 4, 6, 8, 10] +</pre> + +<h3 id="Verkürzung_eines_Arrays">Verkürzung eines Arrays</h3> + +<p>Das folgende Beispiel verkürzt das Array <code>numbers</code> auf eine Länge von 3, wenn die Länge größer als 3 ist.</p> + +<pre class="brush: js notranslate">var numbers = [1, 2, 3, 4, 5]; + +if (numbers.length > 3) { + numbers.length = 3; +} + +console.log(numbers); // [1, 2, 3] +console.log(numbers.length); // 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">Komment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.5.2', 'Array.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-array-instances-length', 'Array.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-properties-of-array-instances-length', 'Array.length')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompabilität">Browserkompabilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.length")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/map/index.html b/files/de/web/javascript/reference/global_objects/array/map/index.html new file mode 100644 index 0000000000..8227658ca6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/map/index.html @@ -0,0 +1,337 @@ +--- +title: Array.prototype.map() +slug: Web/JavaScript/Reference/Global_Objects/Array/map +tags: + - Array + - ECMAScript 5 + - JavaScript + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/map +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">Die <strong><code>map()</code></strong> (engl. <em>abbilden</em>) Methode<strong> </strong>wendet auf jedes Element des Arrays die bereitgestellte Funktion an und gibt das Ergebnis in einem neuen Array zurück.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/array-map.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><var>var new_array = arr</var>.map(function <var>callback(currentValue[, index[, array]]) { + </var>// Zurückgegebenes Element für new_array<var> +}</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funktion, die ein Element für das neue Array erstellt und drei Argumente entgegennimmt:</dd> + <dd> + <dl> + <dt><code>currentValue</code></dt> + <dd>Das aktuelle Element, das im Array verarbeitet wird.</dd> + <dt><code>index</code>{{optional_inline}}</dt> + <dd>Der Index des aktuellen Elements, das im Array verarbeitet wird.</dd> + <dt><code>array</code>{{optional_inline}}</dt> + <dd>Das Array, welches mit <code>map()</code> durchlaufen wird.</dd> + </dl> + </dd> + <dt><code>thisArg</code>{{optional_inline}}</dt> + <dd>Wert, der als <code>this</code> verwendet wird, wenn <code>callback</code> ausgeführt wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues Array, von dem jedes Element das Ergebnis der Callback-Funktion ist.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>map()</code> ruft eine bereitgestellte <code>callback</code> Funktion <strong>für jedes Element</strong> in einem Array der Reihe nach auf und erstellt aus den Ergebnissen ein neues Array. <code>callback</code> wird nur für Indizes des Arrays aufgerufen, denen Werte zugewiesen wurden, einschließlich {{jsxref("undefined")}}. Es wird nicht für fehlende Elemente des Arrays aufgerufen (d. h. Indizes, die noch nie festgelegt, gelöscht oder denen noch kein Wert zugewiesen wurde).</p> + +<p><code>map()</code> zu benutzen, wenn das davon neu erstellte Array nicht benutzt wird, gilt als <a href="https://de.wikipedia.org/wiki/Anti-Pattern">Anti-Pattern</a>. Verwenden Sie stattdessen {{jsxref("Array/forEach", "forEach()")}} oder {{jsxref("statements/for...of", "for...of")}}.</p> + +<p>Sie sollten <code>map()</code> nicht verwenden, wenn:</p> + +<ul> + <li>Sie das Array, das zurückgegeben wird, nicht benötigen und/oder</li> + <li>Ihr Callback keinen Wert zurückgibt.</li> +</ul> + +<p><code>callback</code> wird mit drei Argumenten aufgerufen:</p> + +<ol> + <li>Der Wert des Elements</li> + <li>Der Index des Elements</li> + <li>Das Array-Objekt, das durchlaufen wird</li> +</ol> + +<p>Falls der Parameter <code>thisArg</code> an <code>map()</code> übergeben wird, wird er als Wert für <code>this</code> innerhalb von <code>callback</code> verwendet. Andernfalls hat <code>this</code> den Wert {{jsxref("undefined")}}. Welchen Wert <code>callback</code> letztendlich in <code>this</code> steht, wird gemäß <a href="/de/docs/Web/JavaScript/Reference/Operators/this">der üblichen Regeln bestimmt, nach denen <code>this</code> für eine Funktion ermittelt wird</a>.</p> + +<p><code>map()</code> selbst verändert das Array nicht, auf dem es aufgerufen wird (das aufgerufene <code>callback</code> kann jedoch Änderungen vornehmen).</p> + +<p>Der Bereich der von <code>map()</code> verarbeiteten Elemente wird vor dem ersten Aufruf von <code>callback</code> festgelegt. Elemente, die nach Beginn des Aufrufs von <code>map()</code> an das Array angehängt werden, werden von <code>callback</code> nicht berücksichtigt. Wenn vorhandene Elemente des Arrays geändert werden, ist der Wert maßgeblich, den <code>map()</code> beim Erreichen eines Elements antrifft und dann an <code>callback</code> übergibt. Nachfolgende Elemente, die nach Beginn eines Durchlaufs von <code>map()</code> gelöscht werden, bevor sie eingelesen werden konnten, werden nicht mehr berücksichtigt.</p> + +<p>Aufgrund des in der Spezifikation definierten Algorithmus haben Arrays mit vielen leeren Elementen auch nach einem Aufruf von <code>map()</code> immer noch leere Elemente, wobei die leeren Elemente an ihren Indizes verbleiben.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example_Mapping_an_array_of_numbers_to_an_array_of_square_roots" name="Example:_Mapping_an_array_of_numbers_to_an_array_of_square_roots">Erstellen eines Arrays mit Quadratwurzeln aus einem Array mit Zahlen</h3> + +<p>Der folgende Code verwendet ein Array mit Zahlen und erstellt ein neues Array, das die Quadratwurzeln der Zahlen im ersten Array enthält.</p> + +<pre class="brush: js notranslate">var numbers = [1, 4, 9]; +var roots = numbers.map(Math.sqrt); +// roots ist jetzt [1, 2, 3] +// numbers ist immer noch [1, 4, 9] +</pre> + +<h3 id="Objekte_innerhalb_eines_Arrays_mit_map_neu_formatieren">Objekte innerhalb eines Arrays mit <code>map()</code> neu formatieren</h3> + +<p>Der folgende Code nimmt ein Array mit Objekten und erstellt daraus ein neues Array, in dem die Objekte neu formatiert wurden.</p> + +<pre class="brush: js notranslate">var kvArray = [{key: 1, value: 10}, + {key: 2, value: 20}, + {key: 3, value: 30}]; + +var reformattedArray = kvArray.map(obj => { + var rObj = {}; + rObj[obj.key] = obj.value; + return rObj; +}); +// reformattedArray ist jetzt [{1: 10}, {2: 20}, {3: 30}], + +// kvArray ist immer noch: +// [{key: 1, value: 10}, +// {key: 2, value: 20}, +// {key: 3, value: 30}]</pre> + +<h3 id="Example_Mapping_an_array_of_numbers_using_a_function_containing_an_argument" name="Example:_Mapping_an_array_of_numbers_using_a_function_containing_an_argument">Erstellen eines Arrays mit Zahlen mithilfe einer Funktion, die ein Argument entgegennimmt</h3> + +<p>Der folgende Code zeigt, wie <code>map()</code> im Zusammenhang mit einer Funktion arbeitet, welche ein Argument entgegennimmt. Dem Argument wird automatisch der Wert des aktuellen Elements des Arrays zugewiesen, das von <code>map()</code> durchlaufen wird.</p> + +<pre class="brush: js notranslate">var numbers = [1, 4, 9]; +var doubles = numbers.map(function(num) { + return num * 2; +}); + +// doubles ist jetzt [2, 8, 18] +// numbers ist immer noch [1, 4, 9]</pre> + +<h3 id="Example_using_map_generically" name="Example:_using_map_generically">Generischer Einsatz von <code>map()</code></h3> + +<p>In diesem Beispiel wird veranschaulicht, wie <code>map()</code> auf einen {{jsxref("Global_Objects/String", "String")}} angewendet wird, um ein Array mit Bytes zu erhalten, welche den jewiligen Zeichenwerten im <a href="https://de.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange#ASCII-Tabelle">ASCII-Zeichensatz</a> entsprechen:</p> + +<pre class="brush: js notranslate">var map = Array.prototype.map; +var a = map.call('Hello World', function(x) { + return x.charCodeAt(0); +}); +// a now equals [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100] +</pre> + +<h3 id="Example_using_map_generically_querySelectorAll" name="Example:_using_map_generically_querySelectorAll">Generischer Einsatz von <code>map()</code> zusammen mit <code>querySelectorAll()</code></h3> + +<p>In diesem Beispiel wird gezeigt, wie Sie eine Sammlung von Objekten durchlaufen, die von {{domxref("document.querySelectorAll()", "querySelectorAll()")}} erfasst wurde. Dies liegt daran, dass {{domxref("document.querySelectorAll()", "querySelectorAll()")}} eine {{domxref("NodeList")}} zurückgibt, bei der es sich um eine Auflistung von Objekten handelt. In diesem Fall geben wir alle Werte der ausgewählten Optionen auf dem Bildschirm zurück:</p> + +<pre class="brush: js notranslate">var elems = document.querySelectorAll('select option:checked'); +var values = Array.prototype.map.call(elems, function(obj) { + return obj.value; +}); +</pre> + +<p>Einfacher wäre die Methode {{jsxref("Array.from()")}}.</p> + +<h3 id="Example_Tricky_use_case" name="Example:_Tricky_use_case">Verzwickter Anwendungsfall</h3> + +<p><a href="http://www.wirfs-brock.com/allen/posts/166">(Inspiriert von diesem Blogpost)</a></p> + +<p>Üblicherweise wird die <code>callback</code> Funktion mit nur einem Argument benutzt. Das trifft auch für bestimmte andere Funktionen zu obwohl diese weitere optionale Argumente akzeptieren. Dies kann jedoch zu verwirrendem Verhalten führen.</p> + +<p>Betrachten wir folgendes Beispiel:</p> + +<pre class="brush: js notranslate">['1', '2', '3'].map(parseInt); + +// Man würde erwarten [1, 2, 3] +// Tatsächlich ist das Ergebnis aber [1, NaN, NaN] + +// parseInt wird oft nur mit einem Argument aufgerufen, akzeptiert aber zwei. +// Der erste ist ein Ausdruck und der zweite ist die Basis. + +// Array.prototype.map übergibt 3 Argumente an die Callback-Funktion: +// das Element, den Index, das Array + +// Das dritte Argument wird von parseInt ignoriert, das zweite jedoch nicht, +// was verwirrend sein kann. Siehe den Blogpost für weitere Details + +// Falls der Link nicht funktioniert: +// ein kurzes Beispiel der Durchläufe: +// parseInt(string, radix) -> map(parseInt(value, index)) +// erster Durchlauf (Index ist 0): parseInt('1', 0) // führt zu parseInt('1', 0) -> 1 +// zweiter Durchlauf (Index ist 1): parseInt('2', 1) // führt zu parseInt('2', 1) -> NaN +// dritter Durchlauf (Index ist 2): parseInt('3', 2) // führt zu parseInt('3', 2) -> NaN + +function returnInt(element) { + return parseInt(element, 10); +} + +['1', '2', '3'].map(returnInt); // [1, 2, 3] +// Tatsächliches Ergebnis ist ein Array mit Nummern (wie erwartet) + +// Wie oben, jedoch unter Verwendung der kurzen Funktionssyntax mit Pfeil +['1', '2', '3'].map( str => parseInt(str) ); + +// Eine einfachere Methode, um selbiges zu erreichen, während Fallstricke vermieden werden: +['1', '2', '3'].map(Number); // [1, 2, 3] + +// Im Gegensatz zu `parseInt` werden jedoch auch Fließkommazahlen oder (aufgelöste) Exponentialnotationen zurückgegeben: +['1.1', '2.2e2', '3e300'].map(Number); // [1.1, 220, 3e+300]</pre> + +<p>Eine alternative Ausgabe der <code>map()</code> Methode, welche mit {{jsxref("Global_Objects/parseInt", "parseInt()")}} als Parameter aufgerufen wird, funktioniert wie folgt:</p> + +<pre class="brush: js notranslate">var xs = ['10', '10', '10']; + +xs = xs.map(parseInt); + +console.log(xs); +// Das tatsächliche Ergebnis von [ 10, NaN, 2 ] kann aufgrund der obigen Beschreibung unerwartet sein</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p><code>map()</code> wurde dem ECMA-262-Standard in der 5. Auflage hinzugefügt. Als solches ist es möglicherweise nicht in allen Implementierungen des Standards enthalten. Sie können dies umgehen, indem Sie den folgenden Code am Anfang Ihrer Skripte einfügen, um die Verwendung von <code>map()</code> in Implementierungen zu ermöglichen, die es nicht nativ unterstützen. Dieser Dieser Algorithmus entspricht dem in der 5. Auflage von ECMA-262 angegebenen Algorithmus, vorausgesetzt {{jsxref("Object")}}, {{jsxref("TypeError")}} und {{jsxref("Array")}} haben ihre ursprünglichen Werte und <code>callback.call()</code> wird mit dem ursprünglichen Wert von {{jsxref("Function.prototype.call()")}} ausgewertet.</p> + +<pre class="brush: js notranslate">// Production steps of ECMA-262, Edition 5, 15.4.4.19 +// Reference: http://es5.github.io/#x15.4.4.19 +if (!Array.prototype.map) { + + Array.prototype.map = function(callback, thisArg) { + + var T, A, k; + + if (this == null) { + throw new TypeError(' this is null or not defined'); + } + + // 1. Let O be the result of calling ToObject passing the |this| + // value as the argument. + var O = Object(this); + + // 2. Let lenValue be the result of calling the Get internal + // method of O with the argument "length". + // 3. Let len be ToUint32(lenValue). + var len = O.length >>> 0; + + // 4. If IsCallable(callback) is false, throw a TypeError exception. + // See: http://es5.github.com/#x9.11 + if (typeof callback !== 'function') { + throw new TypeError(callback + ' is not a function'); + } + + // 5. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 1) { + T = thisArg; + } + + // 6. Let A be a new array created as if by the expression new Array(len) + // where Array is the standard built-in constructor with that name and + // len is the value of len. + A = new Array(len); + + // 7. Let k be 0 + k = 0; + + // 8. Repeat, while k < len + while (k < len) { + + var kValue, mappedValue; + + // a. Let Pk be ToString(k). + // This is implicit for LHS operands of the in operator + // b. Let kPresent be the result of calling the HasProperty internal + // method of O with argument Pk. + // This step can be combined with c + // c. If kPresent is true, then + if (k in O) { + + // i. Let kValue be the result of calling the Get internal + // method of O with argument Pk. + kValue = O[k]; + + // ii. Let mappedValue be the result of calling the Call internal + // method of callback with T as the this value and argument + // list containing kValue, k, and O. + mappedValue = callback.call(T, kValue, k, O); + + // iii. Call the DefineOwnProperty internal method of A with arguments + // Pk, Property Descriptor + // { Value: mappedValue, + // Writable: true, + // Enumerable: true, + // Configurable: true }, + // and false. + + // In browsers that support Object.defineProperty, use the following: + // Object.defineProperty(A, k, { + // value: mappedValue, + // writable: true, + // enumerable: true, + // configurable: true + // }); + + // For best browser support, use the following: + A[k] = mappedValue; + } + // d. Increase k by 1. + k++; + } + + // 9. return A + return A; + }; +} +</pre> + +<h2 id="Specifications" name="Specifications">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('ES5.1', '#sec-15.4.4.19', 'Array.prototype.map')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.map', 'Array.prototype.map')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.map', 'Array.prototype.map')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.map")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Map")}}-Objekt</li> + <li>{{jsxref("Array.from()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/observe/index.html b/files/de/web/javascript/reference/global_objects/array/observe/index.html new file mode 100644 index 0000000000..2926d777fc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/observe/index.html @@ -0,0 +1,91 @@ +--- +title: Array.observe() +slug: Web/JavaScript/Reference/Global_Objects/Array/observe +tags: + - Array + - JavaScript + - Method + - Obsolete +translation_of: Archive/Web/JavaScript/Array.observe +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p>Die <strong><code>Array.observe()</code></strong> Methode wurde für das asynchrone Beobachten von Veränderungen von Arrays benutzt, ähnlich wie {{jsxref("Object.observe()")}} für Objekte. Sie stellt einen Stream von Änderungen in der Reihenfolge, in denen sie auftreten, zur Verfügung.<br> + Equivalent zu <code>Object.observe()</code> und wird ausgeführt mit der Liste <code>["add", "update", "delete", "splice"]</code>. Diese Funktion wurde als deprecated markiert und bereits aus einigen Browsern entfernt. Man kann stattdessen das allgemeinere {{jsxref("Proxy")}} Objekt verwenden.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Array.observe(<var>arr</var>, <var>callback</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>arr</code></dt> + <dd> Das Array, welches beobachtet wird.</dd> + <dt><code>callback</code></dt> + <dd>Die Funktion, welche bei jeder Änderung mit folgenden Argumenten aufgerufen wird: + <dl> + <dt><code>changes</code></dt> + <dd>Ein Array aus Objekten. Jedes repräsentiert eine Änderung. Die Eigenschaften dieser change Objekte sind: + <ul> + <li><strong><code>name</code></strong>: Der Name der Eigenschaft, welche geändert wurde.</li> + <li><strong><code>object</code></strong>: Das veränderte Array, nachdem die Änderung stattfand.</li> + <li><strong><code>type</code></strong>: Ein String, welcher den Typ der Änderung darstellt. Er hat den Wert "add", "update", "delete", oder "splice".</li> + <li><strong><code>oldValue</code></strong>: Nur für "update" und "delete" Typ. Der Wert vor der Änderung.</li> + <li><strong><code>index</code></strong>: Nur für "splice" Typ. Der Index, an welchem die Änderung stattfand.</li> + <li><strong><code>removed</code></strong>: Nur für "splice" Typ. Ein Array aus den gelöschten Elementen.</li> + <li><strong><code>addedCount</code></strong>: Nur für "splice" Typ. Die Anzahl an Elementen, welche hinzugefügt wurden.</li> + </ul> + </dd> + </dl> + </dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>callback</code> Funktion wird jedes mal aufgerufen, wenn eine Änderung in arr stattfindet mit einem Array von allen Änderungen in der Reihenfolge in der sie auftreten</p> + +<div class="note"> +<p>Änderungen über die Array Methoden, wie zum Beispiel <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array/pop"><code>Array.prototype.pop()</code></a>, werden als "splice" "changes" dargestellt.<br> + Index Änderungen, welche die Länge des Arrays nicht verändern, werden als "update" "changes" dargestellt.</p> +</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Aufzeichnung_verschiedener_change_Typen">Aufzeichnung verschiedener change Typen</h3> + +<pre class="brush: js">var arr = ['a', 'b', 'c']; + +Array.observe(arr, function(changes) { + console.log(changes); +}); + +arr[1] = 'B'; +// [{type: 'update', object: <arr>, name: '1', oldValue: 'b'}] + +arr[3] = 'd'; +// [{type: 'splice', object: <arr>, index: 3, removed: [], addedCount: 1}] + +arr.splice(1, 2, 'beta', 'gamma', 'delta'); +// [{type: 'splice', object: <arr>, index: 1, removed: ['B', 'c', 'd'], addedCount: 3}] +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p><a href="https://github.com/arv/ecmascript-object-observe">Strawman proposal specification</a>.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.observe")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="//stackoverflow.com/q/29269057/778272">Under what condition would Array.observe's “add” event trigger?</a></li> + <li>{{jsxref("Array.unobserve()")}} {{experimental_inline}}</li> + <li>{{jsxref("Object.observe()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/of/index.html b/files/de/web/javascript/reference/global_objects/array/of/index.html new file mode 100644 index 0000000000..e0e69d50f5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/of/index.html @@ -0,0 +1,102 @@ +--- +title: Array.of() +slug: Web/JavaScript/Reference/Global_Objects/Array/of +tags: + - Array + - ECMAScript 2015 + - JavaScript + - Method + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/of +--- +<div>{{JSRef}}</div> + +<div>Die <code><strong>Array.of()</strong></code> Methode erstellt eine neue {{jsxref("Array")}} Instanz aus einer variablen Anzahl an Argumenten, ohne Rücksicht auf die Anzahl oder den Typ der Argumente.</div> + +<div> </div> + +<div>Der Unterschied zwischen <code><strong>Array.of()</strong></code> und dem <code><strong>Array</strong></code> Konstruktor ist die Behandlung von ganzen Zahlen als Argumente: <code><strong>Array.of(7)</strong></code> erstellt ein Array mit einem Element, <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">7</span></font>. <code><strong>Array(7)</strong></code> hingegen erstellt ein leeres Array, bei dem die Eigenschaft <code>length<span style='background-color: #ffffff; font-family: "Open Sans",arial,x-locale-body,sans-serif;'> </span></code>den Wert <code>7</code> gesetzt ist (<strong>Bemerkung:</strong> das impliziert ein Array mit <code>7</code> leeren Elementen, bei dem alle Elemente <code>undefined</code> sind).</div> + +<div> </div> + +<pre class="brush: js"><code>Array.of(7); // [7] +Array.of(1, 2, 3); // [1, 2, 3] + +Array(7); // [ , , , , , , ] +Array(1, 2, 3); // [1, 2, 3]</code> +</pre> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Array.of(<var>element0</var>[, <var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Elemente, welche sich im neu erzeugten Array befinden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine neue {{jsxref("Array")}} Instanz.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Funktion ist Teil des EMCAScript 2015 Standards. Für mehr Information siehe <a href="https://gist.github.com/rwaldron/1074126"><code>Array.of</code> and <code>Array.from</code> </a>und <a href="https://gist.github.com/rwaldron/3186576"><code>Array.of</code> polyfill</a>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Array.of(1); // [1] +Array.of(1, 2, 3); // [1, 2, 3] +Array.of(undefined); // [undefined] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Wird der nachfolgende Code vor jedem anderen Code eingefügt, so wird Array.of() verfügbar, falls es nicht nativ implementiert ist.</p> + +<pre class="brush: js">if (!Array.of) { + Array.of = function() { + return Array.prototype.slice.call(arguments); + }; +} +</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-array.of', 'Array.of')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.of', 'Array.of')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompabilität">Browser Kompabilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.of")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.from()")}}</li> + <li>{{jsxref("TypedArray.of()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/pop/index.html b/files/de/web/javascript/reference/global_objects/array/pop/index.html new file mode 100644 index 0000000000..33274647f5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/pop/index.html @@ -0,0 +1,98 @@ +--- +title: Array.prototype.pop() +slug: Web/JavaScript/Reference/Global_Objects/Array/pop +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<p>Die <code><strong>pop()</strong></code> Methode entfernt das <strong>letzte</strong> Element eines Arrays und gibt dieses zurück. Diese Methode ändert die Länge des Arrays.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-pop.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.pop()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das entfernte Element aus dem Array; {{jsxref("undefined")}} wenn das Array leer ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>pop</code>-Methode entfernt das letzte Element eines Arrays und gibt dieses zurück.</p> + +<p><code>pop</code> ist bewusst generisch gehalten. DIese Methode kann mit {{jsxref("Function.call", "called", "", 1)}} oder {{jsxref("Function.apply", "applied", "", 1)}} auf einem Objekten aufgerufen werden, welches Arrays ähneln ist. <span id="result_box" lang="de"><span>Objekte, die keine </span></span><code>length</code> Eigenschaft <span lang="de"><span>enthalten, welches das letzt Element in dem Objekt markieren oder keine nullbasierten numerischen Eigenschaften widerspiegelt, verhalten sich möglicherweise nicht in einer Weise.</span></span></p> + +<p>Wenn <code>pop()</code> auf einem leeren Array aufgerufen wird, so wird <code>undefined</code> zurückgegeben.</p> + +<h2 id="Example" name="Example">Beispiele</h2> + +<h3 id="Example:_Removing_the_last_element_of_an_array" name="Example:_Removing_the_last_element_of_an_array">Entfernen des letzten Elements eines Arrays</h3> + +<p>Der folgende Code erzeugt ein Array <code>myFish</code>, das aus vier Elementen besteht. Im Anschluss daran wird das letzte Element entfernt.</p> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'mandarin', 'sturgeon']; + +var popped = myFish.pop(); + +console.log(myFish); // ['angel', 'clown', 'mandarin' ] + +console.log(popped); // 'sturgeon'</pre> + +<h2 id="Specifications" name="Specifications">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>ECMAScript 3rd Edition</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert mit JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browser-Kompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.pop")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> + <li>{{jsxref("Array.prototype.splice()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/prototypen/index.html b/files/de/web/javascript/reference/global_objects/array/prototypen/index.html new file mode 100644 index 0000000000..dcab74024e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/prototypen/index.html @@ -0,0 +1,183 @@ +--- +title: Array.Prototypen +slug: Web/JavaScript/Reference/Global_Objects/Array/Prototypen +tags: + - Array + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Array.prototype (Anordnung.Muster) </code></strong>Eigenschaft repräsentiert eine Schablone (Prototypen) des {{jsxref("Array")}} Konstrukteurs und erlaubt dir neue Eigenschaften und Methoden zu allen Array Objekten hinzuzufügen.</p> + +<pre class="brush: js">// Wenn JavaScript eine first() Methode vom Grundsatz nicht unterstützt +// füge eine neue Methode als Rückgabewert des ersten Elements als Array zurück + +if (!Array.prototype.first) { + Array.prototype.first = function() { + return this[0]; + } +}</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("Array")}} Instanzen erben vom <code>Array.prototype.</code> Wie mit allen Konstrukteuren kannst du das Konstrukteur Protoypen Objekt ändern, um alle {{jsxref("Array")}} Instanzen zu verändern. Ein Beispiel: du kannst neue Methoden und Eigenschaften zu allen Array-Objekten hinzufügen und diese damit erweitern. Dies wird zum Beispiel für {{Glossary("Polyfill", "polyfilling")}} genutzt.</p> + +<p>Ganz nebenbei: ein Array-Protoyp selbst ist ein {{jsxref("Array")}}:</p> + +<pre class="brush: js">Array.isArray(Array.prototype); // true +</pre> + +<p>{{js_property_attributes(0, 0, 0)}}</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Array.prototype.constructor</code></dt> + <dd>Beschreibt die Funktion um ein Objekt-Prototypen zu erstellen.</dd> + <dt>{{jsxref("Array.prototype.length")}}</dt> + <dd>Gibt die Nummer an Elementen in einem Array wieder.</dd> + <dt>{{jsxref("Array.@@unscopables", "Array.prototype[@@unscopables]")}}</dt> + <dd>Eine Symbol-beinhaltende Eigenschaft beschreibt das ausschließen von einem mit <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> eingebundenden Geltungsbereich.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<h3 id="Mutationsmethoden">Mutationsmethoden</h3> + +<p>Diese Methoden verändern ein Array:</p> + +<dl> + <dt>{{jsxref("Array.prototype.copyWithin()")}}</dt> + <dd>Kopiert einen Teil eines Array Elements innerhalb eines Array.</dd> + <dt>{{jsxref("Array.prototype.fill()")}}</dt> + <dd>Füllt alle Elemente eines Arrays von einem Start-Index zu einem Ende-Index mit einem festen Wert.</dd> + <dt>{{jsxref("Array.prototype.pop()")}}</dt> + <dd>Entfernt das letzte Element von einem Array und gibt dieses Element als Rückgabewert aus.</dd> + <dt>{{jsxref("Array.prototype.push()")}}</dt> + <dd>Fügt eins oder mehrere Elemente zu dem Ende des Arrays hinzu und gibt die neue Länge des Arrays zurück</dd> + <dt>{{jsxref("Array.prototype.reverse()")}}</dt> + <dd>Dreht die Reihenfolge der Elemente in einem Array um - das erste Element wird das letzte und das letzte Element wird das erste.</dd> + <dt>{{jsxref("Array.prototype.shift()")}}</dt> + <dd>Entfernt das erste Element innerhalb eines Array und gibt das Element als Rückgabewert aus.</dd> + <dt>{{jsxref("Array.prototype.sort()")}}</dt> + <dd>Sortiert innerhalb eines Arrays die Elemente und gibt das sortierte Array aus.</dd> + <dt>{{jsxref("Array.prototype.splice()")}}</dt> + <dd>Fügt Elemente von einem Array hinzu und/oder entfernt diese.</dd> + <dt>{{jsxref("Array.prototype.unshift()")}}</dt> + <dd>Fügt ein oder mehr Elemente an erster Stelle eines Array hinzu und gibt die Länge des neuen Arrays zurück.</dd> +</dl> + +<h3 id="Zugriffsmethoden">Zugriffsmethoden</h3> + +<p>Diese Methoden verändern das Array nicht und geben als Rückgabewert eine Darstellung des Arrays an.</p> + +<dl> + <dt>{{jsxref("Array.prototype.concat()")}}</dt> + <dd>Gibt ein neues Array zusammengestellt von diesem Array und verknüpft mit anderen/ mehreren Array(s) und/ oder einem/ mehreren Wert(en).</dd> + <dt>{{jsxref("Array.prototype.includes()")}}</dt> + <dd>Überprüft, ob ein Array ein bestimmtes Element enthält und gibt als Rückgabewert <code>true</code> oder <code>false</code> an.</dd> + <dt>{{jsxref("Array.prototype.indexOf()")}}</dt> + <dd>Gibt die erste Stelle (Index) eines einzelnen, dem beschriebenen, Elements innerhalb eines Array an. Wenn das Element nicht gefunden wurde gibt er -1 zurück.</dd> + <dt>{{jsxref("Array.prototype.join()")}}</dt> + <dd>Verbindet alle Elemente eines Arrays zu einem String.</dd> + <dt>{{jsxref("Array.prototype.lastIndexOf()")}}</dt> + <dd>Gibt den letzten (höchsten) Index des beschriebenen Elements innerhalb eines Arrays aus, oder -1, wenn nichts gefunden wurde.</dd> + <dt>{{jsxref("Array.prototype.slice()")}}</dt> + <dd>Extrahiert einen Teil eines Arrays und gibt diesen als neues Array aus.</dd> + <dt>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Gibt ein Array-Literal des beschriebenen Arrays zurück; du kannst diesen Wert nutzen um ein neues Array zu erstellen. Überschreibt die {{jsxref("Object.prototype.toSource()")}} Methode.</dd> + <dt>{{jsxref("Array.prototype.toString()")}}</dt> + <dd>Gibt einen String zurück, welcher das Array und seine Elemente beinhaltet. Überschreibt die {{jsxref("Object.prototype.toString()")}} Methode.</dd> + <dt>{{jsxref("Array.prototype.toLocaleString()")}}</dt> + <dd>Gibt einen lokalen String zurück, welcher das Array und seine Elemente beschreibt. Überschreibt die {{jsxref("Object.prototype.toLocaleString()")}} Methode.</dd> +</dl> + +<h3 id="Zählmethoden">Zählmethoden</h3> + +<p>Einige Methoden nehmen als Argument eine Funktion an und führen diese während des Aufrufs des Arrays aus. Wenn diese Methoden aufgerufen werden, wird die Länge (<code>length)</code> des Arrays abgetastet und jedes Element außerhalb der dieser Länge innerhalb eines nicht aufgerufenen Callbacks hinzugefügt. Andere Änderungen zu einem Array (setzen eines Wertes oder das Löschen eines Elements) könnten Auswirkungen auf das Ergebnis der Operation haben, wenn die Methode das veränderte Element im Nachhinein besucht. Während das spezielle Verhalten dieser Methoden in einem solchen Fall gut definiert sind, solltest du dich dennoch nicht darauf verlassen, damit du andere, die deinen möglicherweise lesen - nicht verwirrt werden. Wenn du das Array verändern musst, solltest du das veränderte Array in ein neu erstelltes Array packen.</p> + +<dl> + <dt>{{jsxref("Array.prototype.entries()")}}</dt> + <dd>Gibt ein neues Array Zähl Objekt <code>(Array Iterator Object) </code>zurück, welches das key/value Paar für jeden Index in dem Array innehält.</dd> + <dt>{{jsxref("Array.prototype.every()")}}</dt> + <dd>Gibt <code>true</code> zurück, wenn alle Elemente in diesem Array die zu testende Funktion bestehen.</dd> + <dt>{{jsxref("Array.prototype.filter()")}}</dt> + <dd>Erstellt ein neues Array mit allen Elementen dieses Arrays für welches die Filter-Funktion innerhalb den Rückgabewert <code>true</code> benutzt.</dd> + <dt>{{jsxref("Array.prototype.find()")}}</dt> + <dd>Gibt den ersten gefundenen Wert innerhalb eines Arrays wieder, wenn ein Element innerhalb des Arrays die definierte Test-Funktion besteht oder <code>undefined </code>wenn nichts gefunden wurde.</dd> + <dt>{{jsxref("Array.prototype.findIndex()")}}</dt> + <dd>Gibt den gefundenen Index im Array an, wenn ein Element in dem Array die angegebene Test-Funktion besteht - oder -1, wenn nichts gefunden wurde.</dd> + <dt>{{jsxref("Array.prototype.forEach()")}}</dt> + <dd>Ruft eine Funktion für jedes Element in einem Array auf.</dd> + <dt>{{jsxref("Array.prototype.keys()")}}</dt> + <dd> + <p>Gibt einen neuen <code>Array Iterator (Zeiger)</code> aus, welcher die Schlüssel für jeden Index innerhalb des Arrays beinhaltet.</p> + </dd> + <dt>{{jsxref("Array.prototype.map()")}}</dt> + <dd>Erstellt ein neues Array mit den Ergebnissen der ausgeführten definierten Funktion an jedem Element in diesem Array.</dd> + <dt>{{jsxref("Array.prototype.reduce()")}}</dt> + <dd>Reduziert das Array auf einen einzigen Wert, indem es jeweils zwei Elemente durch die angegebene Funktion ausführt. Optional: als zweiten Paramater einen Startwert angeben.</dd> + <dt>{{jsxref("Array.prototype.reduceRight()")}}</dt> + <dd>Reduziert das Array auf einen einzigen Wert, indem es jeweils zwei Elemente durch die angegebene Funktion ausführt (von rechts nach links). Optional: als zweiten Paramater einen Startwert angeben.</dd> + <dt>{{jsxref("Array.prototype.some()")}}</dt> + <dd> + <pre class="syntaxbox">Gibt <code>true</code> zurück, wenn mindestens ein Element in diesem Array den Test der definierten Funktion besteht.</pre> + </dd> + <dt>{{jsxref("Array.prototype.values()")}}</dt> + <dd>Gibt einen neues <code>Array Iterator</code> Objekt zurück, welches die Werte für jeden Index in dem Array beinhaltet.</dd> + <dt>{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}}</dt> + <dd>Gibt einen neues <code>Array Iterator</code> Objekt zurück, welches die Werte für jeden Index in dem Array beinhaltet.</dd> +</dl> + +<h3 id="Generische_Methoden_(kein_Standard)">Generische Methoden (kein Standard)</h3> + +<p>Vielen Methoden von den JavaScript Array Objekten sind für die allgemeine Anwendung an allem Objekten entwickelt wurden, welche "aussehen wie" Arrays. Der Grund ist, dass sie an allen Objekten angewandt werden könne, welche eine Längen-Eigenschaft besitzen, und welche nützlicherweise eine numerische Eigenschaft benennen (wie mit der <code>array[5]</code> Indizierung). Einige Methoden, solche wie<code> </code>{{jsxref("Array.join", "join")}}, lesen nur die Länge (<code>length)</code> und numerische Eigenschaften von dem Objekt an welches sie angewandt werden. Andere, wie {{jsxref("Array.reverse", "reverse")}}, erfordern eine Veränderung der numerischen Objekt- und Längen-Eigenschaften; diese Methoden können deshalb nicht von Objekten wie {{jsxref("String")}} aufgerufen werden, welche das künstliche Setzen ihrer Längen- (<code>length)</code> oder numerischen Eigenschaft nicht erlauben.</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>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype', 'Array.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Hinzugefügt der <code>copyWithin()</code>, <code>fill()</code>, <code>entries()</code>, <code>keys()</code>, <code>values()</code>, <code>find()</code>, <code>findIndex()</code> Methoden.</td> + </tr> + <tr> + <td>{{SpecName('ES7', '#sec-array.prototype', 'Array.prototype')}}</td> + <td>{{Spec2('ES7')}}</td> + <td>Hinzugefügt der <code>includes()</code> Methode.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.prototype")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/push/index.html b/files/de/web/javascript/reference/global_objects/array/push/index.html new file mode 100644 index 0000000000..986fcf944b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/push/index.html @@ -0,0 +1,141 @@ +--- +title: Array.prototype.push() +slug: Web/JavaScript/Reference/Global_Objects/Array/push +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/push +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>push()</strong></code> Methode fügt ein oder mehr Elemente am Ende eines Arrays hinzu und gibt die neue Länge des Arrays zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-push.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.push(<var>element1</var> [, ... [, <var>elementN]]</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Die Elemente, die am Ende des Arrays eingefügt werden.</dd> +</dl> + +<h3 id="Returns" name="Returns">Rückgabewert</h3> + +<p>Den neuen Wert der {{jsxref("Array.length", "length")}} Eigenschaft (Länge des Arrays), nachdem die Methode ausgeführt wurde.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>push</code> Methode fügt Werte an das Ende eines Arrays an.</p> + +<p class="p1"><code>push</code> ist absichtlich generisch gehalten. Die Methode kann mit Hilfe von {{jsxref("Function.call", "call()")}} und {{jsxref("Function.apply", "apply()")}} auch auf Array ähnliche Objekte angewendet werden. Die Methode wählt anhand der <code>length</code> Eigenschaft den Punkt aus, an dem die Werte eingefügt werden. Falls die <code>length</code> Eigenschaft nicht in eine Zahl umgewandelt werden kann, wird 0 als Index verwendet. Das gilt auch für den Fall, dass die <code>length</code> Eigenschaft nicht vorhanden ist. Die <code>length</code> Eigenschaft wird daraufhin erstellt.</p> + +<p class="p2">Obwohl {{jsxref("Global_Objects/String", "Strings", "", 1)}} native, Array-ähnliche Objekte sind, sind sie in Anwendungen dieser Methode nicht geeignet, da Strings unveränderlich sind. Gleiches gilt für das native, Array-ähnliche Objekt {{jsxref("Functions/arguments", "arguments", "", 1)}}.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Adding_elements_to_an_array" name="Example:_Adding_elements_to_an_array">Elemente zu einem Array hinzufügen</h3> + +<p>Der folgende Quelltext erstellt ein <code>sports</code> Array mit zwei Elementen und fügt anschließend zwei weitere Elemente hinzu. Die Variable <code>total</code> enthält die neue Länge des Arrays.</p> + +<pre class="brush: js">var sports = ['soccer', 'baseball']; +var total = sports.push('football', 'swimming'); + +console.log(sports); // ['soccer', 'baseball', 'football', 'swimming'] +console.log(total); // 4 +</pre> + +<h3 id="Zwei_Arrays_zusammenführen">Zwei Arrays zusammenführen</h3> + +<p>Dieses Beispiel benutzt {{jsxref("Function.apply", "apply()")}}, um alle Elemente eines zweiten Arrays hinzuzufügen.</p> + +<p>Diese Methode sollte <em>nicht</em> benutzt werden, wenn das zweite Array (<code>moreVegs</code> in diesem Beispiel) sehr lang ist, weil die maximale Anzahl der Parametern, die eine Funktion haben kann, in der Praxis limitiert ist. Siehe {{jsxref("Function.apply", "apply()")}} für mehr Details.</p> + +<pre>var vegetables = ['parsnip', 'potato']; +var moreVegs = ['celery', 'beetroot']; + +// Fügt das zweite Array an das erste Array an +// Equivalent zu vegetables.push('celery', 'beetroot'); +Array.prototype.push.apply(vegetables, moreVegs); + +console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']</pre> + +<h3 id="Objekte_wie_ein_Array_behandeln">Objekte wie ein Array behandeln</h3> + +<p>Wie oben angedeutet ist, ist <code>push</code> extra generisch gehalten, was man zu seinem Vorteil nutzen kann. <code>Array.prototype.push</code> kann gut auf ein Objekt angewendet werden, wie das Beispiel zeigt. Zu beachten ist, dass kein Array erstellt wird, um eine Menge von Objekten zu speichern. Stattdessen werden die Objekte in dem Objekt selbst gespeichern, indem wir <code>call</code> auf der <code>Array.prototype.push</code> Methode einsetzen, um die Methode glauben zu lassen, wir arbeiten mit einem Array. Es funktioniert einfach, dank der Art und Weise, wie JavaScript es uns erlaubt, den Ausführungskontext nach Belieben festzulegen.</p> + +<pre class="brush: js">var obj = { + length: 0, + + addElem: function addElem(elem) { + // obj.length wird automatisch erhöht, + // wenn ein Objekt hinzugefügt wird + [].push.call(this, elem); + } +}; + +// ein paar leere Objekte zu Illustrationszwecken hinzufügen +obj.addElem({}); +obj.addElem({}); +console.log(obj.length); +// → 2 +</pre> + +<p>Zu beachten ist, dass <code>obj</code> kein Array ist. Die Methode <code>push</code> erhöht erfolgreich die <code>length</code> Eigenschaft von <code>obj</code>, so als würde sie mit einem Array arbeiten.</p> + +<h2 id="Specifications" name="Specifications">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.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.7', 'Array.prototype.push')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.push', 'Array.prototype.push')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.push', 'Array.prototype.push')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.push")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/reduce/index.html b/files/de/web/javascript/reference/global_objects/array/reduce/index.html new file mode 100644 index 0000000000..bbb3e4d57c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/reduce/index.html @@ -0,0 +1,564 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce +tags: + - Array + - ECMAScript 5 + - JavaScript + - Method + - Prototype + - Reduce + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>reduce()</strong></code>-Methode reduziert ein Array auf einen einzigen Wert, indem es jeweils zwei Elemente (von links nach rechts) durch eine gegebene Funktion reduziert.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-reduce.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.reduce(<var>callback[, </var><var>initialValue]</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funktion, welche auf jeden Wert im Array angewandet wird und vier Argumente hat: + <dl> + <dt><code>accumulator</code></dt> + <dd>Der kumulierte Wert ist der Rückgabewert von <code>callback</code>; der in der zuvor zurückgegebene Wert des letzten Aufrufes von <code>callback</code> oder <code>initialValue</code> werden verwendet.</dd> + <dt><code>currentValue</code></dt> + <dd>Das aktuell zu verarbeitende Element des Arrays.</dd> + <dt><code>currentIndex</code>{{optional_inline}}</dt> + <dd>Der Index des aktuellen Elements des Arrays. Beginnt mit dem Index 0, falls <code>initialValue</code> angegeben wurde, ansonsten mit Index 1.</dd> + <dt><code>array</code>{{optional_inline}}</dt> + <dd>Das Array, auf dem <code>reduce</code> abgerufen wird.</dd> + </dl> + </dd> + <dt><code>initialValue</code>{{optional_inline}}</dt> + <dd>Der Wert des ersten Arguments, der bei dem ersten Aufruf in <code>callback</code> zu benutzt wird. Wenn kein Initialwert angegeben wird, wird das erste Element des Arrays benutzt. Das Aufrufen von <code>reduce()</code> auf einem leeren Array ohne Initialwerts führt zu einem Fehler.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Ergebniswert der Reduzierung.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>reduce()</code> führt die <code>callback</code>-Funktion für jedes existierende Element in dem Array aus, Ausnahme sind nicht gesetzte Werte. <code>callback</code> hat vier Parameter:</p> + +<ul> + <li><code>accumulator</code></li> + <li><code>currentValue</code></li> + <li><code>currentIndex</code></li> + <li><code>array</code></li> +</ul> + +<p>Beim ersten Aufruf von <code>callback</code> sind die Werte von <code>accumulator</code> und <code>currentValue</code> in Abhängigkeit vom Parameter <code>initialValue</code> wie folgt:</p> + +<ul> + <li>Wenn <code>initialValue</code> beim Aufruf von <code>reduce()</code> angegeben wird, ist <code>accumulator</code> gleich dem <code>initialValue</code> und <code>currentValue</code> ist gleich dem ersten Wert im Array.</li> + <li>Wenn kein <code>initialValue</code> angegeben wird, ist <code>accumulator</code> gleich mit dem ersten Wert im Array und <code>currentValue</code> wird gleich dem zweiten Wert im Array sein.</li> +</ul> + +<div class="note"> +<p><strong>Hinweis:</strong> Wenn <code>initialValue</code> nicht angegeben wird, wird <code>reduce()</code> die <code>callback</code>-Funktion startend beim Index 1 aufrufen, der erste Index wird übersprungen. Wenn <code>initialValue</code> angegeben ist, wird bei Index 0 begonnen.</p> +</div> + +<p>Wenn das Array leer ist und kein <code>initialValue</code> angegeben ist, wird ein {{jsxref("TypeError")}} erzeugt. Wenn das Array nur ein Element hat (die Position ist egal) und kein <code>initialValue</code> angegeben ist oder wenn <code>initialValue</code> angegeben ist und das Array leer ist, wird der einzelne Wert sofort zurückgegeben, ohne <code>callback</code> aufzurufen.</p> + +<p>Es ist immer sicherer <code>initialValue</code> anzugeben, weil es drei mögliche Ergebnisse ohne <code>initialValue</code> gibt, wie es im folgenden Beispiel gezeigt ist.</p> + +<pre class="brush: js">var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x ); +var maxCallback2 = ( max, cur ) => Math.max( max, cur ); + +// reduce() without initialValue +[ { x: 22 }, { x: 42 } ].reduce( maxCallback ); // 42 +[ { x: 22 } ].reduce( maxCallback ); // { x: 22 } +[ ].reduce( maxCallback ); // TypeError + +// map/reduce; better solution, also works for empty or larger arrays +[ { x: 22 }, { x: 42 } ].map( el => el.x ) + .reduce( maxCallback2, -Infinity ); +</pre> + +<h3 id="Wie_reduce_funktioniert">Wie reduce() funktioniert</h3> + +<p>Angenommen die folgende <code>reduce()</code> Funktion wird genutzt:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduce(function (<code>accumulator,</code> <code>currentValue</code>, <code>currentIndex</code>, array) { + return <code>accumulator</code> + currentValue; +}); +</pre> + +<p>Die <code>callback</code>-Funktion wird viermal aufgerufen, mit den Parametern und Rückgabewert für jeden Aufruf wir folgend beschrieben:</p> + +<table> + <thead> + <tr> + <th scope="col"><code>callback</code></th> + <th scope="col"><code>accumulator</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>currentIndex</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">Rückgabewert</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">1. Aufruf</th> + <td><code>0</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>1</code></td> + </tr> + <tr> + <th scope="row">2. Aufruf</th> + <td><code>1</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>3</code></td> + </tr> + <tr> + <th scope="row">3. Aufruf</th> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>6</code></td> + </tr> + <tr> + <th scope="row">4. Aufruf</th> + <td><code>6</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + </tbody> +</table> + +<p>Der zurückgegebene Wert von <code>reduce()</code> ist der Rückgabewert der letzten <code>callback</code>-Funktion (<code>10</code>).</p> + +<p>Es ist zusätzlich möglich eine {{jsxref("Functions/Arrow_functions", "Arrow-Funktion","",1)}} statt einer ganzen Funktion zu benutzen. Der folgende Quelltext erzeugt die gleiche Ausgabe wie der Vorherige:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduce( (prev, curr) => prev + curr ); +</pre> + +<p>Wenn als zweiter Parameter von <code>reduce()</code> <code>initialValue</code> angegeben ist, wird das Ergebnis wie folgt aussehen:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduce((<code>accumulator</code>, currentValue, currentIndex, array) => { + return <code>accumulator</code> + currentValue; +}, 10); +</pre> + +<table> + <thead> + <tr> + <th scope="col"><code>callback</code></th> + <th scope="col"><code>accumulator</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>currentIndex</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">Rückgabewert</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">1. Aufruf</th> + <td><code>10</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + <tr> + <th scope="row">2. Aufruf</th> + <td><code>10</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>11</code></td> + </tr> + <tr> + <th scope="row">3. Aufruf</th> + <td><code>11</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>13</code></td> + </tr> + <tr> + <th scope="row">4. Aufruf</th> + <td><code>13</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>16</code></td> + </tr> + <tr> + <th scope="row">5. Aufruf</th> + <td><code>16</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + </tbody> +</table> + +<p>Der von <code>reduce()</code> zurückgegebene Wert ist in diesem Fall <code>20</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Alle_Elemente_eines_Arrays_summieren">Alle Elemente eines Arrays summieren</h3> + +<pre class="brush: js">var sum = [0, 1, 2, 3].reduce(function (accumulator, currentValue) { + return accumulator + currentValue; +}, 0); +// sum is 6 +</pre> + +<p>Alternativ als Arrow-Funktion geschrieben:</p> + +<pre class="brush: js">var total = [ 0, 1, 2, 3 ].reduce( + ( accumulator, currentValue ) => accumulator + currentValue, + 0 +);</pre> + +<h3 id="Summe_von_Werten_in_einem_Objektarray">Summe von Werten in einem Objektarray</h3> + +<p>Um in einem Array von Objekten Werte aufzusummieren, <strong>muss</strong> ein Initialwert angegeben werden, so dass jedes Element in der Funktion durchlaufen wird.</p> + +<pre class="brush: js">var initialValue = 0; +var sum = [{x: 1}, {x:2}, {x:3}].reduce(function (accumulator, currentValue) { + return accumulator + currentValue.x; +},initialValue) + +console.log(sum) // logs 6 +</pre> + +<p>Alternativ als Arrow-Funktion geschrieben:</p> + +<pre class="brush: js">var initialValue = 0; +var sum = [{x: 1}, {x:2}, {x:3}].reduce( + (accumulator, currentValue) => accumulator + currentValue.x + ,initialValue +); + +console.log(sum) // logs 6</pre> + +<h3 id="Geschachtelte_Arrays_zu_einem_flachen_Array_machen">Geschachtelte Arrays zu einem flachen Array machen</h3> + +<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduce( + function(accumulator, currentValue) { + return accumulator.concat(currentValue); + }, + [] +); +// flattened is [0, 1, 2, 3, 4, 5] +</pre> + +<p>Alternativ als Arrow-Funktion geschrieben:</p> + +<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduce( + ( accumulator, currentValue ) => accumulator.concat(currentValue), + [] +); +</pre> + +<h3 id="Zählen_von_Instanzen_eines_Wertes_in_einem_Objekt">Zählen von Instanzen eines Wertes in einem Objekt</h3> + +<pre class="brush: js">var names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice']; + +var countedNames = names.reduce(function (allNames, name) { + if (name in allNames) { + allNames[name]++; + } + else { + allNames[name] = 1; + } + return allNames; +}, {}); +// countedNames is: +// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 } +</pre> + +<h3 id="Objekte_nach_einer_Eigenschaft_gruppieren">Objekte nach einer Eigenschaft gruppieren</h3> + +<pre class="brush: js">var people = [ + { name: 'Alice', age: 21 }, + { name: 'Max', age: 20 }, + { name: 'Jane', age: 20 } +]; + +function groupBy(objectArray, property) { + return objectArray.reduce(function (acc, obj) { + var key = obj[property]; + if(!acc[key]) { + acc[key] = []; + } + acc[key].push(obj); + return acc; + }, {}); +} + +var groupedPeople = groupBy(people, 'age'); +// groupedPeople is: +// { +// 20: [ +// { name: 'Max', age: 20 }, +// { name: 'Jane', age: 20 } +// ], +// 21: [{ name: 'Alice', age:21 }] +// } +</pre> + +<h3 id="Verbinden_von_Arrays_in_einem_Array_von_Objekten_mithilfe_des_Spread-Operators_und_von_initialValue"><span id="result_box" lang="de"><span>Verbinden von Arrays in einem Array von Objekten mithilfe des Spread-Operators und von <code>initialValue</code></span></span></h3> + +<pre class="brush: js">// friends - an array of objects +// where object field "books" - list of favorite books +var friends = [{ + name: 'Anna', + books: ['Bible', 'Harry Potter'], + age: 21 +}, { + name: 'Bob', + books: ['War and peace', 'Romeo and Juliet'], + age: 26 +}, { + name: 'Alice', + books: ['The Lord of the Rings', 'The Shining'], + age: 18 +}]; + +// allbooks - list which will contain all friends' books + +// additional list contained in initialValue +var allbooks = friends.reduce(function(accumulator, currentValue) { + return [...accumulator, ...currentValue.books]; +}, ['Alphabet']); + +// allbooks = [ +// 'Alphabet', 'Bible', 'Harry Potter', 'War and peace', +// 'Romeo and Juliet', 'The Lord of the Rings', +// 'The Shining' +// ]</pre> + +<h3 id="Duplikate_in_einem_Array_entfernen">Duplikate in einem Array entfernen</h3> + +<pre class="brush: js">let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4]; +let result = arr.sort().reduce((accumulator, current) => { + const length = accumulator.length; + if (length === 0 || accumulator[length - 1] !== current) { + accumulator.push(current); + } + return accumulator; +}, []); +console.log(result); //[1,2,3,4,5] +</pre> + +<h3 id="Sequenzielle_Abarbeitung_von_Promises">Sequenzielle Abarbeitung von Promises</h3> + +<pre class="brush: js">/** + * Runs promises from array of functions that can return promises + * in chained manner + * + * @param {array} arr - promise arr + * @return {Object} promise object + */ +function runPromiseInSequence(arr, input) { + return arr.reduce( + (promiseChain, currentFunction) => promiseChain.then(currentFunction), + Promise.resolve(input) + ); +} + +// promise function 1 +function p1(a) { + return new Promise((resolve, reject) => { + resolve(a * 5); + }); +} + +// promise function 2 +function p2(a) { + return new Promise((resolve, reject) => { + resolve(a * 2); + }); +} + +// function 3 - will wrapped in a resolved promise by .then() +function f3(a) { + return a * 3; +} + +// promise function 4 +function p4(a) { + return new Promise((resolve, reject) => { + resolve(a * 4); + }); +} + +const promiseArr = [p1, p2, f3, p4]; +runPromiseInSequence(promiseArr, 10) + .then(console.log); // 1200 +</pre> + +<h3 id="Funktionskomposition_ermöglicht_Pipelining">Funktionskomposition ermöglicht Pipelining</h3> + +<pre class="brush: js">// Building-blocks to use for composition +const double = x => x + x; +const triple = x => 3 * x; +const quadruple = x => 4 * x; + +// Function composition enabling pipe functionality +const pipe = (...functions) => input => functions.reduce( + (acc, fn) => fn(acc), + input +); + +// Composed functions for multiplication of specific values +const multiply6 = pipe(double, triple); +const multiply9 = pipe(triple, triple); +const multiply16 = pipe(quadruple, quadruple); +const multiply24 = pipe(double, triple, quadruple); + +// Usage +multiply6(6); // 36 +multiply9(9); // 81 +multiply16(16); // 256 +multiply24(10); // 240 +</pre> + +<h3 id="Mapfunktion_mit_reduce">Mapfunktion mit reduce</h3> + +<pre class="brush: js">if (!Array.prototype.map) { + Array.prototype.map = function(callback, thisArg) { + return this.reduce(function(mappedArray, currentValue, index, array) { + mappedArray[index] = callback.call(thisArg, currentValue, index, array); + return mappedArray; + }, []); + }; +} + +[1, 2, , 3].map( + (currentValue, index, array) => currentValue + index + array.length +); // [5, 7, , 10] + +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.21 +// Reference: http://es5.github.io/#x15.4.4.21 +// https://tc39.github.io/ecma262/#sec-array.prototype.reduce +if (!Array.prototype.reduce) { + Object.defineProperty(Array.prototype, 'reduce', { + value: function(callback /*, initialValue*/) { + if (this === null) { + throw new TypeError( 'Array.prototype.reduce ' + + 'called on null or undefined' ); + } + if (typeof callback !== 'function') { + throw new TypeError( callback + + ' is not a function'); + } + + // 1. Let O be ? ToObject(this value). + var o = Object(this); + + // 2. Let len be ? ToLength(? Get(O, "length")). + var len = o.length >>> 0; + + // Steps 3, 4, 5, 6, 7 + var k = 0; + var value; + + if (arguments.length >= 2) { + value = arguments[1]; + } else { + while (k < len && !(k in o)) { + k++; + } + + // 3. If len is 0 and initialValue is not present, + // throw a TypeError exception. + if (k >= len) { + throw new TypeError( 'Reduce of empty array ' + + 'with no initial value' ); + } + value = o[k++]; + } + + // 8. Repeat, while k < len + while (k < len) { + // a. Let Pk be ! ToString(k). + // b. Let kPresent be ? HasProperty(O, Pk). + // c. If kPresent is true, then + // i. Let kValue be ? Get(O, Pk). + // ii. Let accumulator be ? Call( + // callbackfn, undefined, + // « accumulator, kValue, k, O »). + if (k in o) { + value = callback(value, o[k], k, o); + } + + // d. Increase k by 1. + k++; + } + + // 9. Return accumulator. + return value; + } + }); +} +</pre> + +<p>Wenn es wirklich notwendig ist veraltete JavaScript-Umgebungen zu benutzen, die <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty()</a></code> nicht unterstützen, ist es besser <code>Array.prototype</code> nicht komplett zu ersetzen, weil man es nicht non-enumerable machen kann.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezification</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce()')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.8.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce()')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.reduce', 'Array.prototype.reduce()')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.reduce")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduceRight()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/reduceright/index.html b/files/de/web/javascript/reference/global_objects/array/reduceright/index.html new file mode 100644 index 0000000000..dfcb7e3a0b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/reduceright/index.html @@ -0,0 +1,334 @@ +--- +title: Array.prototype.reduceRight() +slug: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +tags: + - Array + - ECMAScript 5 + - JavaScript + - Method + - Prototype + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>reduceRight()</strong></code> Methode wendet eine Funktion gegen einen Akkumulator auf jeden Wert des Arrays (von rechts nach links) auf und reduziert es um einen einzelnen Wert.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-reduce-right.html")}}</div> + + + +<p>Siehe auch {{jsxref("Array.prototype.reduce()")}} für links nach rechts Reduzierung.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.reduceRight(<var>callback</var>[, <var>initialValue</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funktion, welche für jeden Wert im Array aufgerufen wird und vier Argumente hat: + <dl> + <dt><code>previousValue</code></dt> + <dd>Der zuvor im letzten Aufruf des Rückrufs zurückgegebene Wert, oder <code>initialValue</code>, wenn unterstützt. (siehe unten)</dd> + <dt><code>currentValue</code></dt> + <dd>Das derzeitige zu verarbeitende Element in dem Array.</dd> + <dt><code>index</code>{{optional_inline}}</dt> + <dd>Der Index des derzeitigen zu verarbeitenden Elements in dem Array.</dd> + <dt><code>array</code>{{optional_inline}}</dt> + <dd>Das Arrayobjekt, in dem das Element enthalten ist.</dd> + </dl> + </dd> + <dt><code>initialValue</code>{{optional_inline}}</dt> + <dd>Objekt, welches beim ersten Aufruf der <code>callback</code> Funktion initial benutzt wird. Wenn kein Initialwert angegeben ist wird das letzte Element aus dem Array benutzt. Der aufruf auf einem leeren Array ohne angabe von <code>initialValue</code> führt zu einem Fehler.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Wert, der aus der Reduktion resultiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>reduceRight</code> Führt die Rückruffunktion einmal für jedes im Array vorhandene Element aus, ohne Löcher im Array, wobei vier Argumente empfangen werden: der Initialwert (<code>initialValue)</code> (oder Wert des vorherigen <code>callback</code> Aufrufes), der Wert des derzeitigen Elements, der derzeitige Index, und das Array auf welches der Durchlauf stattfindet.</p> + +<p>Der Aufruf des reduceRight <code>callback</code> würde ungefähr so aussehen:</p> + +<pre class="brush: js">array.reduceRight(function(previousValue, currentValue, index, array) { + // ... +}); +</pre> + +<p>Wenn die Funktion das erste Mal ausgeführt wird, kann der vorherige Wert (<code>previousValue)</code> und der derzeitige Wert (<code>currentValue)</code> eines von zwei Werten sein. Wenn ein Initialwert (<code>initialValue)</code> der Callback-Funktion zu <code>reduceRight</code> mitgegeben wird, dann wird der <code>previousValue</code> und <code>der initialValue</code> gleich dem <code>initialValue</code> in dem Array. Wenn kein <code>initialValue</code> mitgegeben wird, dann ist der <code>previousValue</code> gleich dem Wert in dem Array und <code>currentValue</code> wird gleich zu dem geich dem zweiten bis letzten Wert.</p> + +<p>Wenn das Array leer ist und kein <code>initialValue</code> angegeben ist wird ein {{jsxref("TypeError")}} erzeugt. Wenn das Array nur ein Element hat (die Position ist egal) und kein <code>initialValue</code> angegeben ist oder wenn <code>initialValue</code> angegeben ist und das Array leer ist, wird der einzelne Wert zurückgegeben ohne <code>callback</code> aufzurufen.</p> + +<p><span id="result_box" lang="de"><span>Einige Beispieldurchläufe der Funktion würden wie folgt aussehen:</span></span></p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) { + return previousValue + currentValue; +}); +</pre> + +<p>Die <code>callback</code> Funktion wird vier mal aufgerufen. Die Parameter und der Rückgabewert dieser Funktion sind wie folgt:</p> + +<table> + <thead> + <tr> + <th scope="col"><code>callback</code></th> + <th scope="col"><code>previousValue</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">Rückgabewert</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">1. Aufruf</th> + <td><code>4</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>7</code></td> + </tr> + <tr> + <th scope="row">2. Aufruf</th> + <td><code>7</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>9</code></td> + </tr> + <tr> + <th scope="row">3. Aufruf</th> + <td><code>9</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + <tr> + <th scope="row">4. Aufruf</th> + <td><code>10</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + </tbody> +</table> + +<p>Der Wert, der von <code>reduceRight</code> zurückgegeben wird, ist der Rückgabewert der letzen <code>callback</code> Funktion (<code>10</code>).</p> + +<p>Wenn ein <code>initialValue</code> angegeben wird, sieht das Resultat folgendermaßen aus:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) { + return previousValue + currentValue; +}, 10); +</pre> + +<table> + <thead> + <tr> + <th scope="col"><code>callback</code></th> + <th scope="col"><code>previousValue</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">Rückgabewert</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">1. Aufruf</th> + <td><code>10</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>14</code></td> + </tr> + <tr> + <th scope="row">2. Aufruf</th> + <td><code>14</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>17</code></td> + </tr> + <tr> + <th scope="row">3. Aufruf</th> + <td><code>17</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>19</code></td> + </tr> + <tr> + <th scope="row">4. Aufruf</th> + <td><code>19</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + <tr> + <th scope="row">5. Aufruf</th> + <td><code>20</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + </tbody> +</table> + +<p>Der von <code>reduceRight</code> zurückgegebene Wert ist in diesem Fall <code>20</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Alle_Elemente_in_einem_Array_summieren">Alle Elemente in einem Array summieren</h3> + +<pre class="brush: js">var sum = [0, 1, 2, 3].reduceRight(function(a, b) { + return a + b; +}); +// sum is 6 +</pre> + +<h3 id="Ein_Array_von_Arrays_in_ein_flaches_Array_schreiben">Ein Array von Arrays in ein flaches Array schreiben</h3> + +<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) { + return a.concat(b); +}, []); +// flattened is [4, 5, 2, 3, 0, 1] +</pre> + +<h3 id="Eine_Liste_von_asynchronen_Funktionen_mit_Callbacks_hintereinander_laufen_lassen_so_dass_das_Resultat_der_vorherigen_der_nächsten_übergeben_wird">Eine Liste von asynchronen Funktionen mit Callbacks hintereinander laufen lassen, so dass das Resultat der vorherigen der nächsten übergeben wird</h3> + +<pre class="brush: js">const waterfall = (...functions) => (callback, ...args) => + functions.reduceRight( + (composition, fn) => (...results) => fn(composition, ...results), + callback + )(...args); + +const randInt = max => Math.floor(Math.random() * max) + +const add5 = (callback, x) => { + setTimeout(callback, randInt(1000), x + 5); +}; +const mult3 = (callback, x) => { + setTimeout(callback, randInt(1000), x * 3); +}; +const sub2 = (callback, x) => { + setTimeout(callback, randInt(1000), x - 2); +}; +const split = (callback, x) => { + setTimeout(callback, randInt(1000), x, x); +}; +const add = (callback, x, y) => { + setTimeout(callback, randInt(1000), x + y); +}; +const div4 = (callback, x) => { + setTimeout(callback, randInt(1000), x / 4); +}; + +const computation = waterfall(add5, mult3, sub2, split, add, div4); +computation(console.log, 5) // -> 14 + +// same as: + +const computation2 = (input, callback) => { + const f6 = x=> div4(callback, x); + const f5 = (x, y) => add(f6, x, y); + const f4 = x => split(f5, x); + const f3 = x => sub2(f4, x); + const f2 = x => mult3(f3, x); + add5(f2, input); +}</pre> + +<h3 id="Unterschied_zwischen_reduce_und_reduceRight">Unterschied zwischen <code>reduce</code> und <code>reduceRight</code></h3> + +<pre class="brush: js">var a = ['1', '2', '3', '4', '5']; +var left = a.reduce(function(prev, cur) { return prev + cur; }); +var right = a.reduceRight(function(prev, cur) { return prev + cur; }); + +console.log(left); // "12345" +console.log(right); // "54321"</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>reduceRight</code> wurde im ECMA-262 Standard in der 5. Edition hinzugefügt. Aus diesem Grund ist es in manchen Implementierungen nicht vorhanden. Dieses Problem kann beheben werden indem folgender Quelltext am Anfang des Skripts eingefügt werden, wodurch <code>reduceRight</code> auch in solchen Implementierungen unterstützt werden kann.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.22 +// Reference: http://es5.github.io/#x15.4.4.22 +if ('function' !== typeof Array.prototype.reduceRight) { + Array.prototype.reduceRight = function(callback /*, initialValue*/) { + 'use strict'; + if (null === this || 'undefined' === typeof this) { + throw new TypeError('Array.prototype.reduce called on null or undefined'); + } + if ('function' !== typeof callback) { + throw new TypeError(callback + ' is not a function'); + } + var t = Object(this), len = t.length >>> 0, k = len - 1, value; + if (arguments.length >= 2) { + value = arguments[1]; + } else { + while (k >= 0 && !(k in t)) { + k--; + } + if (k < 0) { + throw new TypeError('Reduce of empty array with no initial value'); + } + value = t[k--]; + } + for (; k >= 0; k--) { + if (k in t) { + value = callback(value, t[k], k, t); + } + } + return 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('ES5.1', '#sec-15.4.4.22', 'Array.prototype.reduceRight')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.8.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.reduceRight")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduce()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/reverse/index.html b/files/de/web/javascript/reference/global_objects/array/reverse/index.html new file mode 100644 index 0000000000..84560faacb --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/reverse/index.html @@ -0,0 +1,92 @@ +--- +title: Array.prototype.reverse() +slug: Web/JavaScript/Reference/Global_Objects/Array/reverse +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>reverse()</strong></code> Methode kehrt die Reihenfolge der Arrayelemente <em><a href="https://de.wikipedia.org/wiki/In-place">in-place</a></em> um. Das erste Element wird zum letzen und das letzte wird zum ersten.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-reverse.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.reverse()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das umgedrehte Array.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die <code>reverse</code> Methode kehrt die Reihenfolge der Elemente des angegebenen Arrays in-place um, ändert das Array und gibt eine Referenz zu diesem zurück.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Reversing_the_elements_in_an_array" name="Example:_Reversing_the_elements_in_an_array">Elemente in einem Array umkehren</h3> + +<p>Das folgende Beispiel erzeugt ein Array <code>a</code> mit 3 Elementen und kehrt die Reihenfolge des Arrays um. Der Aufruf von <code>reverse()</code> gibt eine Referenz zum umgekehrten Array <code>a</code> zurück.</p> + +<pre class="brush: js">var a = [1, 2, 3]; + +console.log(a) // [1, 2, 3] + +a.reverse(); + +console.log(a) // [3, 2, 1] +</pre> + +<h2 id="Specifications" name="Specifications">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.4.4.8', 'Array.prototype.reverse')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.reverse")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.join()")}}</li> + <li>{{jsxref("Array.prototype.sort()")}}</li> + <li>{{jsxref("TypedArray.prototype.reverse()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/shift/index.html b/files/de/web/javascript/reference/global_objects/array/shift/index.html new file mode 100644 index 0000000000..e576e1bfec --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/shift/index.html @@ -0,0 +1,111 @@ +--- +title: Array.prototype.shift() +slug: Web/JavaScript/Reference/Global_Objects/Array/shift +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift +--- +<div>{{JSRef}}</div> + +<p>Die Methode <code><strong>shift()</strong></code> entfernt das <strong>erste</strong> Element eines Arrays und gibt dieses Element zurück. Diese Methode verändert die Länge des Arrays.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-shift.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.shift()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das vom Array entfernte Element; {{jsxref("undefined")}} wenn das Array leer ist.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die Methode <code>shift</code> entfernt das Element an der nullten Stelle, verschiebt die übrigen Elemente um einen Index nach unten und gibt den Wert des entfernten Elementes zurück. Ist die {{jsxref("Array.length", "length")}} Eigenschaft gleich 0, wird {{jsxref("undefined")}} zurückgegeben.</p> + +<p><code>shift</code> ist absichtlich generisch; diese Methode kann auf Array ähnlichen Objekten mit {{jsxref("Function.call", "call", "", 1)}} oder {{jsxref("Function.apply", "applied", "", 1)}} genutzt werden. <span id="result_box" lang="de"><span>Objekte, die keine </span></span><code>length</code> E<span lang="de"><span>igenschaft enthalten, die die letzte in einer Reihe von aufeinanderfolgenden, nullbasierten numerischen Eigenschaften widerspiegelt, verhalten sich möglicherweise nicht in einer sinnvollen Weise</span></span>.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Removing_an_element_from_an_array" name="Example:_Removing_an_element_from_an_array">Ein Element eines Arrays entfernen</h3> + +<p>Das folgende Skript zeigt das Array <code>myFish</code> bevor und nachdem das erste Element dieses Arrays entfernt wurde. Anschließend wird das entfernte Element angezeigt:</p> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'mandarin', 'surgeon']; + +console.log('myFish before: ' + myFish); +// myFish before: ['angel', 'clown', 'mandarin', 'surgeon'] + +var shifted = myFish.shift(); + +console.log('myFish after: ' + myFish); +// myFish after: ['clown', 'mandarin', 'surgeon'] + +console.log('Removed this element: ' + shifted); +// Removed this element: angel</pre> + +<h3 id="Einsatz_von_shift()_in_einer_while-Schleife">Einsatz von <code>shift()</code> in einer <code>while</code>-Schleife</h3> + +<p>Die shift() Methode wird oft in der Bedingung in einer <code>while</code> Schleife verwendet. Im folgenden Beispiel wird in jeder Iteration das nächste Element vom Array entfernt, bis das Array leer ist.</p> + +<pre class="brush: js">var names = ["Andrew", "Edward", "Paul", "Chris" ,"John"]; + +while( (i = names.shift()) !== undefined ) { + console.log(i); +} +// Andrew, Edward, Paul, Chris, John +</pre> + +<h2 id="Specifications" name="Specifications">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.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.9', 'Array.prototype.shift')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.shift', 'Array.prototype.shift')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.shift', 'Array.prototype.shift')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.shift")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/slice/index.html b/files/de/web/javascript/reference/global_objects/array/slice/index.html new file mode 100644 index 0000000000..75ad6c4a25 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/slice/index.html @@ -0,0 +1,244 @@ +--- +title: Array.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/Array/slice +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>slice()</code></strong> Methode schreibt eine flache Kopie von einem Teil des Arrays in ein neues Array-Objekt von <code>begin</code> bis <code>end</code> (<code>end</code> nicht enthalten). Das originale Array wird nicht verändert.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-slice.html")}}</div> + +<p class="hidden">The source for this interactive demo is stored in a GitHub repository. If you'd like to contribute to the interactive demo project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.slice([<var>begin</var>[, <var>end</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>begin</code>{{optional_inline}}</dt> + <dd>Null-basierter Index, an welcher die Extraktion beginnt.</dd> + <dd>Bei einem negativen Index kennzeichnet <code>begin</code> einen Versatz vom Ende der Sequenz. <code>slice(-2)</code> extrahiert die letzten zwei Elemente der Sequenz.</dd> + <dd>Wenn <code>begin</code> undefiniert ist, beginnt <code>slice</code> bei Index <code>0</code>.</dd> + <dd>Wenn <code>begin</code> größer als die Länge der Sequenz ist, wird ein leeres Array zurückgegeben.</dd> + <dt><code>end</code> {{optional_inline}}</dt> + <dd>Null-basierter Index bevor die Extraktion endet. <code>slice</code> extrahiert bis zu, aber nicht inklusive <code>end</code>.</dd> + <dd><code>slice(1,4)</code> extrahiert vom zweiten bis zum vierten Element (Elemente sind indexiert als 1, 2 und 3).</dd> + <dd>Bei einem negativen Index kennzeichnet <code>end</code> einen Versatz vom Ende der Sequenz. <code>slice(2, -1)</code> extrahiert vom dritten bis zum vorletzten Element der Sequenz.</dd> + <dd>Wenn auf <code>end</code> weggelassen wird, extrahiert <code>slice</code> bis zum Ende der Sequenz (<code>arr.length</code>).</dd> + <dd>Wenn <code>end</code> größer als die Länge der Sequenz ist, extrahiert <code>slice</code> bis zum Ende der Sequenz (<code>arr.length</code>)</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues Array, welches die extrahierten Elemente enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>slice</code> verändert das originale Array nicht. Es gibt eine Schattenkopie der Elemente des Arrays zurück. Elemente des original Arrays werden folgendermaßen in das zurückgegeben Array kopiert:</p> + +<ul> + <li>Für Objektreferenzen (nicht das aktuelle Objekt) kopiert <code>slice</code> die Objektreferenz in das neue Array. Beide, das originale und das neue Array, referenzieren das selbe Objekt. Wenn sich ein referenziertes Objekt ändert, ist die Änderungen beim neue und beim originalen Array zu sehen.</li> + <li>Für die Typen string, number und boolean (nicht {{jsxref("String")}}, {{jsxref("Number")}} und {{jsxref("Boolean")}} Objekte) kopiert <code>slice</code> den Wert in das neue Array. Änderungen an string, number oder boolean in einem Array haben keine Auswirkung auf das andere Array.</li> +</ul> + +<p>Wenn ein neues Element zu einem Array hinzugefügt wird, hat es keine Auswirkung auf das andere Array.</p> + +<h2 id="Beispiel">Beispiel</h2> + +<h3 id="Gibt_einen_Teil_eines_existierenden_Arrays_zurück.">Gibt einen Teil eines existierenden Arrays zurück.</h3> + +<pre class="brush: js">var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']; +var citrus = fruits.slice(1, 3); + +// fruits enthält ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'] +// citrus enthält ['Orange','Lemon'] +</pre> + +<h3 id="Einsatz_von_slice">Einsatz von <code>slice</code></h3> + +<p>Im folgenden Beispiel erzeugt <code>slice</code> ein neues Array, <code>newCar</code>, von <code>myCar</code>.<br> + Beide haben eine Referenz zu dem Objekt <code>myHonda</code>. Wenn sich die Farbe von <code>myHonda</code> zu lila ändert, dann ist die Änderung in beiden Arrays sichtbar.</p> + +<pre class="brush: js">// Using slice, create newCar from myCar. +var myHonda = { color: 'red', wheels: 4, engine: { cylinders: 4, size: 2.2 } }; +var myCar = [myHonda, 2, 'cherry condition', 'purchased 1997']; +var newCar = myCar.slice(0, 2); + +// Display the values of myCar, newCar, and the color of myHonda +// referenced from both arrays. +console.log('myCar = ' + myCar.toSource()); +console.log('newCar = ' + newCar.toSource()); +console.log('myCar[0].color = ' + myCar[0].color); +console.log('newCar[0].color = ' + newCar[0].color); + +// Change the color of myHonda. +myHonda.color = 'purple'; +console.log('The new color of my Honda is ' + myHonda.color); + +// Display the color of myHonda referenced from both arrays. +console.log('myCar[0].color = ' + myCar[0].color); +console.log('newCar[0].color = ' + newCar[0].color); +</pre> + +<p>Dieses Skript schreibt:</p> + +<pre class="brush: js">myCar = [{color:'red', wheels:4, engine:{cylinders:4, size:2.2}}, 2, + 'cherry condition', 'purchased 1997'] +newCar = [{color:'red', wheels:4, engine:{cylinders:4, size:2.2}}, 2] +myCar[0].color = red +newCar[0].color = red +The new color of my Honda is purple +myCar[0].color = purple +newCar[0].color = purple +</pre> + +<h2 id="Array-ähnliche_Objekte">Array-ähnliche Objekte</h2> + +<p>Die <code>slice</code> Methode kann auch verwendete werden, um Array-ähnliche Objekte bzw. Collections in Arrays zu konvertieren. Man muss nur die Methode an das Objekt binden.<br> + Die {{jsxref("Functions/arguments", "arguments")}} Variable innerhalb einer Funktion ist ein Beispiel für ein Array-ähnliches Objekte.</p> + +<pre class="brush: js">function list() { + return Array.prototype.slice.call(arguments); +} + +var list1 = list(1, 2, 3); // [1, 2, 3] +</pre> + +<p>Das Binden von Methoden funktioniert mit der <code>.call</code> Funktion von {{jsxref("Function.prototype")}} und der Aufruf kann reduziert werden zu <code>[].slice.call(arguments)</code> anstatt <code>Array.prototype.slice.call</code>. Mit der {{jsxref("Function.prototype.bind", "bind")}} Funktion kann der Aufruf immer vereinfacht werden.</p> + +<pre class="brush: js">var unboundSlice = Array.prototype.slice; +var slice = Function.prototype.call.bind(unboundSlice); + +function list() { + return slice(arguments); +} + +var list1 = list(1, 2, 3); // [1, 2, 3] +</pre> + +<h2 id="Cross-Browser-Verhalten">Cross-Browser-Verhalten</h2> + +<p>Obwohl host Objekte (wie das DOM Objekt) laut Spezifikation nicht dem Mozilla Verhalten beim Konvertieren mit <code>Array.prototype.slice</code> folgen muss und IE < 9 dies auch nicht tut, erlauben Versionen ab IE 9 dieses. “shimming” kann eine sicheres cross-browser Verhalten ermöglichen. So lange andere moderne Browser weiterhin dieses Verhalten unterstützen, sowie zur Zeit IE, Mozilla, Chrome, Safari und Opera es tun, werden Entwickler beim Lesen von (DOM unterstützendem) slice Code, basierend auf diesem Schema, von der Semantik nicht in die Irre geführt.Sie können mit Sicherheit auf die Semantik vertrauen um das de facto Standard Verhalten sicherzustellen. (Dieser shim ermöglicht es auch, dass IE mit dem zweiten Argument von slice() ein explizites {{jsxref("null")}}/{{jsxref("undefined")}}) als Wert verwendet. Bei älteren Versionen des IE war dies nicht erlaubt, jedoch funktioniert es bei allen modernen Browsern inklusive IE >= 9.)</p> + +<pre class="brush: js">/** + * Shim for "fixing" IE's lack of support (IE < 9) for applying slice + * on host objects like NamedNodeMap, NodeList, and HTMLCollection + * (technically, since host objects have been implementation-dependent, + * at least before ES6, IE hasn't needed to work this way). + * Also works on strings, fixes IE < 9 to allow an explicit undefined + * for the 2nd argument (as in Firefox), and prevents errors when + * called on other DOM objects. + */ +(function () { + 'use strict'; + var _slice = Array.prototype.slice; + + try { + // Can't be used with DOM elements in IE < 9 + _slice.call(document.documentElement); + } catch (e) { // Fails in IE < 9 + // This will work for genuine arrays, array-like objects, + // NamedNodeMap (attributes, entities, notations), + // NodeList (e.g., getElementsByTagName), HTMLCollection (e.g., childNodes), + // and will not fail on other DOM objects (as do DOM elements in IE < 9) + Array.prototype.slice = function(begin, end) { + // IE < 9 gets unhappy with an undefined end argument + end = (typeof end !== 'undefined') ? end : this.length; + + // For native Array objects, we use the native slice function + if (Object.prototype.toString.call(this) === '[object Array]'){ + return _slice.call(this, begin, end); + } + + // For array like object we handle it ourselves. + var i, cloned = [], + size, len = this.length; + + // Handle negative value for "begin" + var start = begin || 0; + start = (start >= 0) ? start : Math.max(0, len + start); + + // Handle negative value for "end" + var upTo = (typeof end == 'number') ? Math.min(end, len) : len; + if (end < 0) { + upTo = len + end; + } + + // Actual expected size of the slice + size = upTo - start; + + if (size > 0) { + cloned = new Array(size); + if (this.charAt) { + for (i = 0; i < size; i++) { + cloned[i] = this.charAt(start + i); + } + } else { + for (i = 0; i < size; i++) { + cloned[i] = this[start + i]; + } + } + } + + return cloned; + }; + } +}()); +</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.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.10', 'Array.prototype.slice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.slice")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.splice()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Function.prototype.bind()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/some/index.html b/files/de/web/javascript/reference/global_objects/array/some/index.html new file mode 100644 index 0000000000..0fe959b0d7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/some/index.html @@ -0,0 +1,209 @@ +--- +title: Array.prototype.some() +slug: Web/JavaScript/Reference/Global_Objects/Array/some +tags: + - Array + - ECMAScript5 + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/some +--- +<div>{{JSRef}}</div> + +<p>Die Methode <code><strong>some()</strong></code> überprüft ob mindestens ein Element des Arrays den als Funktion übergebenen Kriterien entspricht.</p> + +<div class="note"> +<p><strong>Hinweis:</strong> Diese Methode gibt <code>false</code> für jede Bedingung auf einem leeren Array zurück.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/array-some.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.some(<var>callback</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funktion die jedes Element überprüft, nimmt drei Argumente entgegen: + <dl> + <dt><code>currentValue</code></dt> + <dd>Das aktuell zu verarbeitende Element des Arrays.</dd> + <dt><code>index</code>{{Optional_inline}}</dt> + <dd>Der Index des aktuell zu verarbeitenden Elementes im Array.</dd> + <dt><code>array</code>{{Optional_inline}}</dt> + <dd>Die Arrayinstanz auf welcher die <code>some()</code> Methode aufgerufen wurde.</dd> + </dl> + </dd> + <dt><code>thisArg</code>{{Optional_inline}}</dt> + <dd>Wert der über das <code>this</code> Schüsselwort innerhalb von <code>callback</code> verfügbar ist.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><code><strong>true</strong></code> wenn die callback Methode ein positives ({{Glossary("truthy")}}) Ergebnis für eines der Elemente im array ermittelt hat; Andernfalls, <code><strong>false</strong></code>.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>some()</code> führt die <code>callback</code> Funktion einmal für jedes Element innerhalb des Arrays aus, bis ein Element gefunden wird, bei dem <code>callback</code> einen <em>truthy</em> Wert (<em>e</em>in Wert der durch die Konvertierung zu boolean true ergibt) zurückgibt. Wird ein solches Element gefunden, gibt <code>some()</code> sofort <code>true</code> zurück. <code>callback</code> wird nur für Elemente des Arrays ausgeführt, die einen zugewiesenen Wert haben; Für undefinierte oder gelöschte Elemente des Arrays wird <code>callback</code> nicht ausgeführt.</p> + +<p><code>callback</code> wird mit drei Argumenten aufgerufen: Dem Wert des Elementes, dem Index des Elementes und dem zugrundeliegenden <code>Array</code>.</p> + +<p>WIrd ein <code>thisArg</code> Parameter an die <code>some()</code> Methode übergeben, wird dieser als <code>this</code> bei der <code>callback</code> Funtion benutzt. Andernfalls wird der Wert {{jsxref("undefined")}} als <code>this</code> benutzt. Der tatsächliche Wert von <code>this</code> wird entsprechend der <a href="/de/docs/Web/JavaScript/Reference/Operators/this">generellen Regeln zur Belegung des this Schlüsselwortes innerhalb von Funktionen </a>gesetzt.</p> + +<p><code>some()</code> verändert nicht das Array auf dem die Methode aufgerufen wurde.</p> + +<p>Die von <code>some()</code> zu verarbeitenden Elemente werden vor dem ersten Aufruf von <code>callback</code> ermittelt. Elemente, die nach dem Aufruf von <code>some()</code> zum Array hinzugefügt werden, werden nicht mit <code>callback</code> aufgerufen. <span id="result_box" lang="de"><span>Wird ein noch nicht besuchtes Element des Arrays durch </span></span><code>callback</code><span lang="de"><span> geändert, wird sein Wert, der an </span></span><code>callback</code><span lang="de"><span> </span></span><span lang="de"><span> übermittelt wird, der Wert zu dem Zeitpunkt, zu dem <code>some()</code> den Index besucht, sein.</span></span> Wird ein Element aus dem Array gelöscht, wird es nicht betrachtet.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Werte_eines_Arrays_überprüfen">Werte eines Arrays überprüfen</h3> + +<p>Die folgenden Beispiele prüfen ob es ein Element größer als 10 im Array gibt.</p> + +<pre class="brush: js">function isBiggerThan10(element, index, array) { + return element > 10; +} + +[2, 5, 8, 1, 4].some(isBiggerThan10); // false +[12, 5, 8, 1, 4].some(isBiggerThan10); // true +</pre> + +<h3 id="Werte_eines_Arrays_mit_arrow_functions_überprüfen">Werte eines Arrays mit arrow functions überprüfen</h3> + +<p><a href="/de/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Arrow Funktionen</a> ermöglichen eine kürzere Schreibweise für die gleiche Logik.</p> + +<pre class="brush: js">[2, 5, 8, 1, 4].some(x => x > 10); // false +[12, 5, 8, 1, 4].some(x => x > 10); // true +</pre> + +<h3 id="Prüfen_ob_ein_Element_in_einem_Array_existiert">Prüfen ob ein Element in einem Array existiert</h3> + +<p>Um die Methode <code>includes()</code> nachzuahmen, gibt die folgende Funktion <code>true</code> zurück, wenn das Element im Array existiert:</p> + +<pre class="brush: js">var fruits = ['apple', 'banana', 'mango', 'guava']; + +function checkAvailability(arr, val) { + return arr.some(function(arrVal) { + return val === arrVal; + }); +} + +checkAvailability(fruits, 'kela'); // false +checkAvailability(fruits, 'banana'); // true</pre> + +<h3 id="Prüfen_ob_ein_Element_in_einem_Array_existiert_mit_einer_arrow_function">Prüfen ob ein Element in einem Array existiert mit einer arrow function</h3> + +<pre class="brush: js">var fruits = ['apple', 'banana', 'mango', 'guava']; + +function checkAvailability(arr, val) { + return arr.some(arrVal => val === arrVal); +} + +checkAvailability(fruits, 'kela'); // false +checkAvailability(fruits, 'banana'); // true</pre> + +<h3 id="Jeden_Wert_in_einen_boolschen_Wert_konvertieren">Jeden Wert in einen boolschen Wert konvertieren</h3> + +<pre class="brush: js">var TRUTHY_VALUES = [true, 'true', 1]; + +function getBoolean(a) { + 'use strict'; + + var value = a; + + if (typeof value === 'string') { + value = value.toLowerCase().trim(); + } + + return TRUTHY_VALUES.some(function(t) { + return t === value; + }); +} + +getBoolean(false); // false +getBoolean('false'); // false +getBoolean(1); // true +getBoolean('true'); // true</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>some()</code> wurde im Rahmen des ECMA-262 Standards in der 5. Edition hinzugefügt. Daher kann es sein, dass es nicht in allen Implementierungen des Standards enthalten ist. Diese Problem kann behoben werden, indem folgenden Quelltext vor Ihren Skripten eingefügt wird, wodurch Sie die <code>some()</code> Methode in Ihrem Programmcode verwenden können. Die nachfolgende Implementierung ist eine exakte Abdeckung der ECMA-262 Spezifikation in der 5. Edition, basierend auf der Annahme dass {{jsxref("Object")}} und {{jsxref("TypeError")}} Originalwerte aufweisen und dass <code>fun.call</code> den Originalwert von {{jsxref("Function.prototype.call()")}} liefert.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.17 +// Reference: http://es5.github.io/#x15.4.4.17 +if (!Array.prototype.some) { + Array.prototype.some = function(fun/*, thisArg*/) { + 'use strict'; + + if (this == null) { + throw new TypeError('Array.prototype.some called on null or undefined'); + } + + if (typeof fun !== 'function') { + throw new TypeError(); + } + + var t = Object(this); + var len = t.length >>> 0; + + var thisArg = arguments.length >= 2 ? arguments[1] : void 0; + for (var i = 0; i < len; i++) { + if (i in t && fun.call(thisArg, t[i], i, t)) { + return true; + } + } + + return false; + }; +} +</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('ES5.1', '#sec-15.4.4.17', 'Array.prototype.some')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.some', 'Array.prototype.some')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.some', 'Array.prototype.some')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.some")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("TypedArray.prototype.some()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/sort/index.html b/files/de/web/javascript/reference/global_objects/array/sort/index.html new file mode 100644 index 0000000000..a59d8ff2c6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/sort/index.html @@ -0,0 +1,264 @@ +--- +title: Array.prototype.sort() +slug: Web/JavaScript/Reference/Global_Objects/Array/sort +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>sort()</strong></code> Methode sortiert die Elemente eines Arrays {{interwiki("wikipedia","in-place")}} und gibt das Array zurück. Standardmäßig werden alle Elemente in Strings umgewandelt und dann anhand ihrer UTF-16 Codepoints miteinander verglichen.</p> + +<p>Die Zeit- und Speicherkomplexität des Sortierens kann nicht garantiert werden, weil sie implementierungsabhängig ist.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-sort.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.sort([<var>compareFunction</var>]) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>compareFunction</code> {{optional_inline}}</dt> + <dd>Gibt eine Funktion an, die die Sortierreihenfolge definiert. Wenn nicht angegeben, wird das Array nach dem <a href="/de/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Unicode">Unicode</a>-Codepoint jedes Zeichens entsprechend der Stringumwandlung jedes Elements sortiert. + <dl> + <dt><code>firstEl</code></dt> + <dd>Das erste Element zum Vergleich.</dd> + <dt><code>secondEl</code></dt> + <dd>Das zweite Element zum Vergleich.</dd> + </dl> + </dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das sortierte Array. Beachten Sie, dass das Array {{interwiki("wikipedia","in-place")}} sortiert und keine Kopie angelegt wird.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn <code>compareFunction</code> nicht angegeben wird, werden alle Arrayelemente, die nicht <code>undefined</code> sind, sortiert indem sie in Strings konvertiert werden und in UTF-16-Code-Unit-Reihenfolge verglichen werden. Zum Beispiel steht "banana" vor "cherry". Bei einer numerischen Sortierung kommt 9 vor 80, aber weil Zahlen in Strings konvertiert werden, kommt "80" in Unicode vor "9". Alle Elemente die <code>undefined</code> sind werden ans Ende des Arrays sortiert.</p> + +<div class="blockIndicator note"> +<p>Hinweis: In UTF-16 werden Unicode-Zeichen über <code>\uFFFF</code> als zwei Ersatzcodeeinheiten im Bereich <code>\uD800</code> - <code>\ uDFFF</code> codiert. Der Wert jeder Codeeinheit wird für den Vergleich gesondert berücksichtigt. Daher wird das durch das Ersatzpaar <code>\uD655</code> <code>\uDE55</code> gebildete Zeichen vor dem Zeichen <code>\uFF3A</code> sortiert.</p> +</div> + +<p>Wenn <code>compareFunction</code> angegeben wird, werden alle Arrayelemente, die nicht <code>undefined</code> sind, nach dem Rückgabewert der Vergleichsfunktion sortiert (alle Elemente die <code>undefined</code> sind werden ans Ende des Arrays sortiert, ohne Aufruf von <code>compareFunction</code>). Wenn <code>a</code> und <code>b</code> zwei zu vergleichende Elemente sind, gilt Folgendes:</p> + +<ul> + <li>Ist <code>compareFunction(a, b)</code> kleiner als 0, sortiere <code>a</code> auf einen niedrigeren Index als <code>b</code>, d. h. <code>a</code> kommt zuerst.</li> + <li>Ist <code>compareFunction(a, b)</code> gleich 0, bleibt die Reihenfolge von <code>a</code> und <code>b</code> in Bezug zueinander unverändert, werden aber im Vergleich zu den restlichen Elementen des Arrays einsortiert. Hinweis: Der ECMAscript Standard garantiert dieses Verhalten nicht. Demzufolge berücksichtigen dies nicht alle Browser (z. B. Mozilla Versionen von 2003 und älter).</li> + <li>Ist <code>compareFunction(a, b)</code> größer als 0, sortiere <code>b</code> auf einen niedrigeren Index als <code>a</code>, d. h. <code>b</code> kommt zuerst.</li> + <li><code>compareFunction(a, b)</code> muss immer denselben Wert zurückgeben, wenn dasselbe Paar an Argumenten <code>a</code> und <code>b</code> übergeben wird. Werden inkonsistente Ergebnisse zurückgegeben, ist die Sortierreihenfolge undefiniert.</li> +</ul> + +<p>Die Vergleichsfunktion hat die Form:</p> + +<pre class="brush: js">function compare(a, b) { + if (a ist kleiner als b anhand von Sortierkriterien) { + return -1; + } + if (a ist größer als b anhand der Sortierkriterien) { + return 1; + } + // a muss gleich b sein + return 0; +} +</pre> + +<p>Um Nummern anstatt Strings zu vergleichen, kann die Vergleichsfunktion einfach <code>b</code> von <code>a</code> subtrahieren. Die folgende Funktion sortiert ein Array aufsteigend (sofern kein <code>Infinity</code> und <code>NaN</code> enthalten):</p> + +<pre class="brush: js">function compareNumbers(a, b) { + return a - b; +} +</pre> + +<p>Die <code>sort</code> Methode kann bequem mit {{jsxref("Operators/function", "Funktionsausdrücken", "", 1)}} benutzt werden:</p> + +<pre class="brush: js">var numbers = [4, 2, 5, 1, 3]; +numbers.sort(function(a, b) { + return a - b; +}); +console.log(numbers); + +// [1, 2, 3, 4, 5] +</pre> + +<p>ES2015 bietet {{jsxref("Functions/Arrow_functions", "Pfeilfunktionen", "", 1)}} mit noch kürzerer Syntax.</p> + +<pre class="brush: js">let numbers = [4, 2, 5, 1, 3]; +numbers.sort((a, b) => a - b); +console.log(numbers); + +// [1, 2, 3, 4, 5]</pre> + +<p>Objekte können anhand der Werte eines ihrer Eigenschaften sortiert werden.</p> + +<pre class="brush: js">var items = [ + { name: 'Edward', value: 21 }, + { name: 'Sharpe', value: 37 }, + { name: 'And', value: 45 }, + { name: 'The', value: -12 }, + { name: 'Magnetic', value: 13 }, + { name: 'Zeros', value: 37 } +]; + +// Sortieren nach Wert +items.sort(function (a, b) { + return a.value - b.value; +}); + +// Sortieren nach Wert +items.sort(function(a, b) { + var nameA = a.name.toUpperCase(); // Groß-/Kleinschreibung ignorieren + var nameB = b.name.toUpperCase(); // Groß-/Kleinschreibung ignorieren + if (nameA < nameB) { + return -1; + } + if (nameA > nameB) { + return 1; + } + + // Namen müssen gleich sein + return 0; +});</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Erstellen_Anzeigen_und_Sortieren_eines_Arrays">Erstellen, Anzeigen und Sortieren eines Arrays</h3> + +<p>Im folgenden Beispiel werden vier Arrays erstellt, das ursprüngliche Array angezeigt, danach die sortierten Arrays. Die numerischen Arrays werden erst ohne, dann mit Vergleichsfunktion sortiert.</p> + +<pre class="brush: js">var stringArray = ['Blue', 'Humpback', 'Beluga']; +var numericStringArray = ['80', '9', '700']; +var numberArray = [40, 1, 5, 200]; +var mixedNumericArray = ['80', '9', '700', 40, 1, 5, 200]; + +function compareNumbers(a, b) { + return a - b; +} + +console.log('stringArray:', stringArray.join()); +console.log('Sorted:', stringArray.sort()); + +console.log('numberArray:', numberArray.join()); +console.log('Sorted without a compare function:', numberArray.sort()); +console.log('Sorted with compareNumbers:', numberArray.sort(compareNumbers)); + +console.log('numericStringArray:', numericStringArray.join()); +console.log('Sorted without a compare function:', numericStringArray.sort()); +console.log('Sorted with compareNumbers:', numericStringArray.sort(compareNumbers)); + +console.log('mixedNumericArray:', mixedNumericArray.join()); +console.log('Sorted without a compare function:', mixedNumericArray.sort()); +console.log('Sorted with compareNumbers:', mixedNumericArray.sort(compareNumbers));</pre> + +<p>Dieses Beispiel erzeugt die folgende Ausgabe. Wie die Ausgabe zeigt, werden Zahlen bei Verwendung einer Vergleichsfunktion korrekt sortiert, ob es sich um Zahlen oder numerische Strings handelt.</p> + +<pre>stringArray: Blue,Humpback,Beluga +Sorted: Beluga,Blue,Humpback + +numberArray: 40,1,5,200 +Sorted without a compare function: 1,200,40,5 +Sorted with compareNumbers: 1,5,40,200 + +numericStringArray: 80,9,700 +Sorted without a compare function: 700,80,9 +Sorted with compareNumbers: 9,80,700 + +mixedNumericArray: 80,9,700,40,1,5,200 +Sorted without a compare function: 1,200,40,5,700,80,9 +Sorted with compareNumbers: 1,5,9,40,80,200,700</pre> + +<h3 id="Sortierung_von_nicht-ASCII_Zeichen">Sortierung von nicht-ASCII Zeichen</h3> + +<p>Zum Sortieren von Strings mit Nicht-ASCII-Zeichen, d. h. Zeichenfolgen mit Akzentzeichen (e, é, è, a, ä, etc.), Zeichenfolgen aus anderen Sprachen als Englisch: Verwenden Sie {{jsxref("String.localeCompare")}}. Diese Funktion kann diese Zeichen vergleichen, damit sie in der richtigen Reihenfolge angezeigt werden.</p> + +<pre class="brush: js">var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu']; +items.sort(function (a, b) { + return a.localeCompare(b); +}); + +// items is ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']</pre> + +<h3 id="Sortieren_mit_map()">Sortieren mit <code>map()</code></h3> + +<p>Die <code>compareFunction</code> kann mehrmals pro Element innerhalb des Arrays aufgerufen werden. Abhängig von der Beschaffenheit von <code>compareFunction</code> kann dies zu einem hohen Overhead führen. Je mehr Arbeit eine <code>compareFunction</code> erledigt und je mehr Elemente zu sortieren sind, desto sinnvoller ist es die Verwendung von {{jsxref("Array.prototype.map()", "map()")}} zum Sortieren in Betracht zu ziehen. Die Idee ist, das Array einmal zu durchlaufen, um die tatsächlichen Werte für das Sortieren in ein temporäres Array zu extrahieren, das temporäre Array zu sortieren und dann das temporäre Array zu durchlaufen, um die richtige Reihenfolge zu erreichen.</p> + +<pre class="brush: js">// Das zu sortierende Array +var list = ['Delta', 'alpha', 'CHARLIE', 'bravo']; + +// Temporäres Array enthält Objekte mit Position und Sortierwert +var mapped = list.map(function(el, i) { + return { index: i, value: el.toLowerCase() }; +}) + +// Sortieren des gemappten Arrays mit den reduzierten Werten +mapped.sort(function(a, b) { + if (a.value > b.value) { + return 1; + } + if (a.value < b.value) { + return -1; + } + return 0; +}); + +// Behälter für die sich ergebende Reihenfolge +var result = mapped.map(function(el){ + return list[el.index]; +});</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.11', 'Array.prototype.sort')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.sort', 'Array.prototype.sort')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.sort', 'Array.prototype.sort')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.sort")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.reverse()")}}</li> + <li>{{jsxref("String.prototype.localeCompare()")}}</li> + <li><a href="https://v8.dev/blog/array-sort">Informationen zur Stabilität des von der V8-Engine verwendeten Algorithmus</a> (Englisch)</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/splice/index.html b/files/de/web/javascript/reference/global_objects/array/splice/index.html new file mode 100644 index 0000000000..f77aab6bb1 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/splice/index.html @@ -0,0 +1,162 @@ +--- +title: Array.prototype.splice() +slug: Web/JavaScript/Reference/Global_Objects/Array/splice +tags: + - Array + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>splice()</strong></code> Methode ändert den Inhalt eines Arrays durch das Entfernen vorhandener Elemente und/oder Hinzufügen neuer Elemente.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-splice.html")}}</div> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>array</var>.splice(<var>start[</var>, <var>deleteCount[</var>, <var>item1[</var>, <var>item2[</var>, <em>...]]]]</em>) +</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>start</code></dt> + <dd>Index ab welchem das Array geändert werden soll. Falls <code>start</code> größer als die Länge des Arrays ist, wird <code>start</code> auf die Länge des Arrays gesetzt.</dd> + <dd>Falls <code>start</code> negativ ist, beginnt die Änderung entsprechend viele Stellen rückwärts vom Ende des Arrays (d.h. hat <code>start</code> den Wert -n ist dies gleichbedeutend mit <code>array.length - n</code>) und wird auf 0 gesetzt wenn der absolute Wert von <code>start</code> größer als die Länge des Arrays ist.</dd> + <dt><code>deleteCount</code> {{optional_inline}}</dt> + <dd>Gibt die Anzahl der zu entfernenden alten Array Elemente an.</dd> + <dd>Wenn <code>deleteCount</code> weggelassen wird oder wenn der Wert größer oder gleich <code>array.length - start</code> ist (d. h. wenn der Wert größer oder gleich der Anzahl der von <code>start</code> aus verbleibenden Elemente ist), wird das ganze Array ab dem Index <code>start</code> gelöscht.</dd> + <dd>Wenn <code>deleteCount</code> 0 oder negativ ist, werden keine Elemente entfernt. In diesem Fall sollte man mindestens ein neues Element als weiteren Parameter übergeben, da das Array sonst nicht geändert wird.</dd> + <dt><code>item1, item2, ...</code> {{optional_inline}}</dt> + <dd>Die Elemente, die dem Array ab dem Index <code>start</code> hinzugefügt werden sollen. Falls keine Elemente angegeben werden, entfernt <code>splice</code> lediglich Elemente des Arrays.</dd> +</dl> + +<h3 id="Returns" name="Returns">Rückgabewert</h3> + +<p>Ein Array, welches die entfernten Elemente enthält. Wenn nur ein Element entfernt wurde, wird ein Array mit nur einem Element zurückgegeben. Wenn kein Element entfernt wurde, wird ein leeres Array zurückgegeben.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Wenn die Anzahl der neu hinzugefügten Elemente ungleich der Anzahl der entfernten Elemente ist, wird die Länge des Arrays geändert. Bei gleicher Anzahl werden vorhandene Elemente sozusagen ersetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Example_Using_splice" name="Example:_Using_splice">Entfernen von 0 (null) Elementen bei Index 2 und Einfügen von "drum"</h3> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'mandarin', 'sturgeon']; +var removed = myFish.splice(2, 0, 'drum'); + +// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"] +// removed is [], no elements removed</pre> + +<h3 id="Entfernen_von_o_(null)_Elementen_bei_Index_2_und_Einfügen_von_drum_und_guitar">Entfernen von o (null) Elementen bei Index 2 und Einfügen von "drum" und "guitar"</h3> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'mandarin', 'sturgeon']; +var removed = myFish.splice(2, 0, 'drum', 'guitar'); + +// myFish is ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"] +// removed is [], no elements removed</pre> + +<h3 id="Entfernen_von_1_Element_bei_Index_3">Entfernen von 1 Element bei Index 3</h3> + + + +<pre class="brush: js">var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon']; +var removed = myFish.splice(3, 1); + +// removed is ["mandarin"] +// myFish is ["angel", "clown", "drum", "sturgeon"]</pre> + + + +<h3 id="Entfernen_von_1_Element_bei_Index_2_und_Einfügen_von_trumpet">Entfernen von 1 Element bei Index 2 und Einfügen von "trumpet"</h3> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'drum', 'sturgeon']; +var removed = myFish.splice(2, 1, 'trumpet'); + +// myFish is ["angel", "clown", "trumpet", "sturgeon"] +// removed is ["drum"] +</pre> + +<h3 id="Entfernen_von_2_Elementen_bei_Index_0_und_Einfügen_von_parrot_anemone_und_blue">Entfernen von 2 Elementen bei Index 0 und Einfügen von "parrot", "anemone" und "blue"</h3> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'trumpet', 'sturgeon']; +var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue'); + +// myFish is ["parrot", "anemone", "blue", "trumpet", "sturgeon"] +// removed is ["angel", "clown"]</pre> + +<h3 id="Entfernen_von_2_Elementen_vom_Index_2">Entfernen von 2 Elementen vom Index 2</h3> + +<pre class="brush: js">var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon']; +var removed = myFish.splice(myFish.length - 3, 2); + +// myFish is ["parrot", "anemone", "sturgeon"] +// removed is ["blue", "trumpet"]</pre> + +<h3 id="Entfernen_von_einem_Element_bei_Index_-2">Entfernen von einem Element bei Index -2</h3> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'mandarin', 'sturgeon']; +var removed = myFish.splice(-2, 1); + +// myFish is ["angel", "clown", "sturgeon"] +// removed is ["mandarin"]</pre> + +<h3 id="Entfernen_von_allen_Elementen_nach_Index_2_(inklusiv)">Entfernen von allen Elementen nach Index 2 (inklusiv)</h3> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'mandarin', 'sturgeon']; +var removed = myFish.splice(2); + +// myFish is ["angel", "clown"] +// removed is ["mandarin", "sturgeon"]</pre> + +<h2 id="Specifications" name="Specifications">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommenter</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.12', 'Array.prototype.splice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.splice', 'Array.prototype.splice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.splice', 'Array.prototype.splice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.splice")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()", "push()")}} / {{jsxref("Array.prototype.pop()", "pop()")}} — hinzufügen/entfernen von Elementen vom Ende des Arrays</li> + <li>{{jsxref("Array.prototype.unshift()", "unshift()")}} / {{jsxref("Array.prototype.shift()", "shift()")}} — hinzufügen/entfernen von Elementen vom Beginn eines Arrays</li> + <li>{{jsxref("Array.prototype.concat()", "concat()")}} — gibt ein neues Array bestehend aus dem aktuellen Array kombiniert mit anderen Arrays und oder Werten</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/tolocalestring/index.html b/files/de/web/javascript/reference/global_objects/array/tolocalestring/index.html new file mode 100644 index 0000000000..ef5c1883b5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/tolocalestring/index.html @@ -0,0 +1,183 @@ +--- +title: Array.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +tags: + - Array + - Internationalization + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +--- +<div>{{JSRef}}</div> + +<p>Die Methode <code><strong>toLocaleString()</strong></code> gibt als Rückgabewert einen String zurück, welcher die Elemente des Arrays darstellt. Die Array-Elemente werden mittels ihrer <code>toLocaleString</code> Methode in Strings umgewandelt und durch einen sprachspezifischen String (wie zum Beispiel ein Kommazeichen “,”) separiert.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-tolocalestring.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.toLocaleString([locales [, options]]); +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>locales</code> {{optional_inline}}</dt> + <dd>Ein String mit einem Language-Tag nach BCP 47 oder ein Array solcher Strings. Für die allgemeine Art und Interpretation des <code>locales</code> Parameters, siehe Seite {{jsxref("Intl")}}.</dd> + <dt><code>options</code> {{optional_inline}}</dt> + <dd>Ein Objekt mit konfigurierbaren Eigenschaften, für Numbers siehe {{jsxref("Number.prototype.toLocaleString()")}}, und für Datumsangaben siehe {{jsxref("Date.prototype.toLocaleString()")}}.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein einzelner String der die Elemente des Arrays darstellt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_locales_und_options">Verwendung von <code>locales</code> und <code>options</code></h3> + +<p>Die Elemente des Arrays werden mittels der <code>toLocaleString</code> Methode in einen String umgewandelt.</p> + +<ul> + <li><code>Object</code>: {{jsxref("Object.prototype.toLocaleString()")}}</li> + <li><code>Number</code>: {{jsxref("Number.prototype.toLocaleString()")}}</li> + <li><code>Date</code>: {{jsxref("Date.prototype.toLocaleString()")}}</li> +</ul> + +<p>Jedem Strings und Numbers Element im Array <code>prices</code> die Währung zuordnen:</p> + +<pre class="brush: js">var prices = ['￥7', 500, 8123, 12]; +prices.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' }); + +// "￥7,￥500,￥8,123,￥12" +</pre> + +<p>Für weitere Beispiele, siehe auch {{jsxref("Global_Objects/Intl","Intl")}}, {{jsxref("Global_Objects/NumberFormat","NumberFormat")}} und {{jsxref("Global_Objects/DateTimeFormat","DateTimeFormat")}}.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">// https://tc39.github.io/ecma402/#sup-array.prototype.tolocalestring +if (!Array.prototype.toLocaleString) { + Object.defineProperty(Array.prototype, 'toLocaleString', { + value: function(locales, options) { + // 1. Let O be ? ToObject(this value). + if (this == null) { + throw new TypeError('"this" is null or not defined'); + } + + var a = Object(this); + + // 2. Let len be ? ToLength(? Get(A, "length")). + var len = a.length >>> 0; + + // 3. Let separator be the String value for the + // list-separator String appropriate for the + // host environment's current locale (this is + // derived in an implementation-defined way). + // NOTE: In this case, we will use a comma + var separator = ','; + + // 4. If len is zero, return the empty String. + if (len === 0) { + return ''; + } + + // 5. Let firstElement be ? Get(A, "0"). + var firstElement = a[0]; + // 6. If firstElement is undefined or null, then + // a.Let R be the empty String. + // 7. Else, + // a. Let R be ? + // ToString(? + // Invoke( + // firstElement, + // "toLocaleString", + // « locales, options » + // ) + // ) + var r = firstElement == null ? + '' : firstElement.toLocaleString(locales, options); + + // 8. Let k be 1. + var k = 1; + + // 9. Repeat, while k < len + while (k < len) { + // a. Let S be a String value produced by + // concatenating R and separator. + var s = r + separator; + + // b. Let nextElement be ? Get(A, ToString(k)). + var nextElement = a[k]; + + // c. If nextElement is undefined or null, then + // i. Let R be the empty String. + // d. Else, + // i. Let R be ? + // ToString(? + // Invoke( + // nextElement, + // "toLocaleString", + // « locales, options » + // ) + // ) + r = nextElement == null ? + '' : nextElement.toLocaleString(locales, options); + + // e. Let R be a String value produced by + // concatenating S and R. + r = s + r; + + // f. Increase k by 1. + k++; + } + + // 10. Return R. + return r; + } + }); +} +</pre> + +<p>Für die Unterstützung von veralteten JavaScript Engines, die <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code> nicht kennen, sollte kein Polyfill für <code>Array.prototype</code> Methoden eingesetzt werden, da sie auf diese Weise nicht mehr nicht-durchzählbar gemacht werden können.</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('ESDraft', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition war in ECMAScript 3.</td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>Diese Definition ersetzt die Definition aus ECMA-262.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.toLocaleString")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.toString()")}}</li> + <li>{{jsxref("Global_Objects/Intl","Intl")}}</li> + <li>{{jsxref("Object.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Number.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/tosource/index.html b/files/de/web/javascript/reference/global_objects/array/tosource/index.html new file mode 100644 index 0000000000..0e7dd02745 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/tosource/index.html @@ -0,0 +1,69 @@ +--- +title: Array.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Array/toSource +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <code><strong>toSource()</strong></code> Methode gibt einen String zurück, welcher den Quelltext des Arrays repräsentiert.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.toSource()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der den Quelltext des Array repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toSource</code> Methode gibt folgende Werte zurück:</p> + +<ul> + <li>Für das eingebaute {{jsxref("Array")}} Objekt gibt <code>toSource</code> den folgenden String zurück, um anzudeuten, dass der Quelltext nicht verfügbar ist: + + <pre class="brush: js">function Array() { + [native code] +} +</pre> + </li> + <li>Für Instanzen von {{jsxref("Array")}} gibt <code>toSource</code> einen String zurück, welcher den Quelltext des Arrays repräsentiert.</li> +</ul> + +<p>Diese Methode wird für gewöhnlich von JavaScript intern aufgerufen und nicht explizit in einem QUelltext. Man kann <code>toSource</code> beim Debuggen aufrufen, um den Inhalt eines Arrays abzufragen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Untersuchen_des_Quelltextes_eines_Arrays">Untersuchen des Quelltextes eines Arrays</h3> + +<p><span class="short_text" id="result_box" lang="de"><span>Um den Quellcode eines Arrays zu untersuchen:</span></span></p> + +<pre class="brush: js">var alpha = new Array('a', 'b', 'c'); + +alpha.toSource(); +//returns ['a', 'b', 'c'] +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>In keiner Spezifikation enthalten. Implementiert in JavaScript 1.3.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.toSource")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("Array.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/tostring/index.html b/files/de/web/javascript/reference/global_objects/array/tostring/index.html new file mode 100644 index 0000000000..0d8d1da3e6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/tostring/index.html @@ -0,0 +1,80 @@ +--- +title: Array.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toString +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>toString()</strong></code> Methode gibt einen String zurück, der das Array und seine Elemente repräsentiert.</p> + +<p>{{EmbedInteractiveExample("pages/js/array-tostring.html")}}</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.toString()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der die Elemente des Arrays repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das {{jsxref("Array")}} Objekt überschreibt die <code>toString</code> Methode von {{jsxref("Object")}}. Für Arrayobjekte fügt die <code>toString</code> Methode das Array zu einem String zusammen, der jedes Element des Arrayelemente durch Kommata getrennt enthält.</p> + +<p>JavaScript ruft die <code>toString</code> Methode automatisch auf wenn ein Array als Text repräsentiert wird oder wenn ein Array in einer Stringkonkatenation verwendet wird.</p> + +<h3 id="ECMAScript_5_Semantik">ECMAScript 5 Semantik</h3> + +<p>Beginnend mt JavaScript 1.8.5 (Firefox 4), und mit der Semantik des ECMAScript der 5. Edition, ist die <code>toString()</code> Methode generisch und kann mit jeglichen Objekten verwendet werden. {{jsxref("Object.prototype.toString()")}} wird aufgerufen und der resultierende Wert wird zurückgegeben.</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>Initiale Definition. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.2', 'Array.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.tostring', 'Array.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.tostring', 'Array.prototype.toString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.toString")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.join()")}}</li> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/unobserve/index.html b/files/de/web/javascript/reference/global_objects/array/unobserve/index.html new file mode 100644 index 0000000000..fd31177c3a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/unobserve/index.html @@ -0,0 +1,88 @@ +--- +title: Array.unobserve() +slug: Web/JavaScript/Reference/Global_Objects/Array/unobserve +tags: + - Array + - JavaScript + - Method + - Obsolete +translation_of: Archive/Web/JavaScript/Array.unobserve +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p>Die Array<strong>.unobserve()</strong> Methode wird eingesetzt um Observers die mit {{jsxref("Array.observe()")}} eingestellt wurden zu entfernen, jedoch ist dieses veraltet und wurde schon von Browsern entfernt. Man kann einen allgemeineres {{jsxref("Proxy")}} Objekt benutzen.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Array.unobserve(<var>arr</var>, <var>callback</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>arr</code></dt> + <dd>Das Array, welches nicht mehr Überwacht werden soll.</dd> + <dt><code>callback</code></dt> + <dd>Die Referenz zu dem Observer, die mit der Überwachung von Änderungen auf dem Array <strong>arr</strong> aufhören soll.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>Array.unobserve()</code> sollt nach {{jsxref("Array.observe()")}} aufgerufen werden, um einen Observer von einem Array zu entfernen.</p> + +<p><strong>callback</strong> sollte eine Referenz auf eine Funktion sein und nicht einen anonyme Funktion sein, weil diese Referenz genutzt wird um den Observer zu entfernen. Es ist nicht zulässig <strong>Array.unobserve()</strong> mit einer anonymen Funktion aufzurufen, weil dadurch kein Observer entfernt wird.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Observer_von_Array_entfernen">Observer von Array entfernen</h3> + +<pre class="brush: js">var arr = [1, 2, 3]; + +var observer = function(changes) { + console.log(changes); +} + +Array.observe(arr, observer); + +arr.push(4); +// [{type: "splice", object: <arr>, index: 3, removed:[], addedCount: 1}] + +Array.unobserve(arr, observer); + +arr.pop(); +// The callback wasn't called</pre> + +<h3 id="Einsatz_einer_anonymen_Funktion">Einsatz einer anonymen Funktion</h3> + +<pre class="brush: js">var persons = ['Khalid', 'Ahmed', 'Mohammed']; + +Array.observe(persons, function (changes) { + console.log(changes); +}); + +persons.shift(); +// [{type: "splice", object: <arr>, index: 0, removed: [ "Khalid" ], addedCount: 0 }] + +Array.unobserve(persons, function (changes) { + console.log(changes); +}); + +persons.push('Abdullah'); +// [{type: "splice", object: <arr>, index: 2, removed: [], addedCount: 1 }] +// The callback will always be called +</pre> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.unobserve")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.observe()")}} {{obsolete_inline}}</li> + <li>{{jsxref("Object.observe()")}} {{obsolete_inline}}</li> + <li>{{jsxref("Object.unobserve()")}} {{obsolete_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/unshift/index.html b/files/de/web/javascript/reference/global_objects/array/unshift/index.html new file mode 100644 index 0000000000..2960b03cbb --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/unshift/index.html @@ -0,0 +1,99 @@ +--- +title: Array.prototype.unshift() +slug: Web/JavaScript/Reference/Global_Objects/Array/unshift +tags: + - Array + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>unshift()</strong></code> Methode fügt ein oder mehrere Elemente am Anfang eines Array hinzu und gibt die neue Länge des Arrays zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-unshift.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>arr</var>.unshift(<var>element1</var>[, ...[, <var>elementN</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Die Elemente die am Anfang des Arrays hinzugefügt werden sollen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die neue {{jsxref("Array.length", "length")}} Eigenschaft des Arrays auf dem die Methode aufgerufen wurde.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>unshift</code> Methode fügt die gegeben Elemente am Anfang eines Arrays ähnlichen Objektes hinzu.</p> + +<p><code>unshift</code> ist extra generisch gehalten. Diese Methode kann mit {{jsxref("Function.call", "call", "", 1)}} oder {{jsxref("Function.apply", "apply", "", 1)}} auf einem Array ähnlichen Objekt angewendet werden. Objekte, die nicht über die Eigenschaft <code>length</code> verfügen, welche nicht das letzte in einer Reihe aufeinander folgenden, null-basierenden nummerische Werten repräsentieren, können sinnlose Ergebnisse liefern.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var arr = [1, 2]; + +arr.unshift(0); // result of call is 3, the new array length +// arr is [0, 1, 2] + +arr.unshift(-2, -1); // = 5 +// arr is [-2, -1, 0, 1, 2] + +arr.unshift([-3]); +// arr is [[-3], -2, -1, 0, 1, 2] +</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.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.13', 'Array.prototype.unshift')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.unshift', 'Array.prototype.unshift')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.unshift', 'Array.prototype.unshift')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.unshift")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/array/values/index.html b/files/de/web/javascript/reference/global_objects/array/values/index.html new file mode 100644 index 0000000000..3736af04f8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/array/values/index.html @@ -0,0 +1,86 @@ +--- +title: Array.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Array/values +tags: + - Array + - ECMAScript 2015 + - Iterator + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/values +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>values()</code></strong> Methode gibt ein neues <strong><code>Iterator</code></strong> Objekt des Arrays zurück, welches die Werte für jeden Eintrag im Array enthält.</p> + +<p>{{EmbedInteractiveExample("pages/js/array-values.html")}}</p> + +<pre class="brush: js">var a = ['w', 'y', 'k', 'o', 'p']; +var iterator = a.values(); + +console.log(iterator.next().value); // w +console.log(iterator.next().value); // y +console.log(iterator.next().value); // k +console.log(iterator.next().value); // o +console.log(iterator.next().value); // p</pre> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>.values()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues {{jsxref("Iterator")}} Objekt von dem Array.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_der_for...of_loop">Benutzung der <code><a href="/de/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code> loop</h3> + +<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p']; +var iterator = arr.values(); + +for (let letter of iterator) { + console.log(letter); +} +</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-array.prototype.values', 'Array.prototype.values')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.values', 'Array.prototype.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.values")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/arraybuffer/@@species/index.html b/files/de/web/javascript/reference/global_objects/arraybuffer/@@species/index.html new file mode 100644 index 0000000000..896576bf2e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/arraybuffer/@@species/index.html @@ -0,0 +1,72 @@ +--- +title: 'get ArrayBuffer[@@species]' +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/@@species +tags: + - ArrayBuffer + - JavaScript + - Property + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/@@species +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>ArrayBuffer[@@species]</strong></code> Zugriffseigenschaft gibt den Konstruktor des <code>ArrayBuffer </code>zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">ArrayBuffer[Symbol.species] +</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>species</code> Zugriffseigenschaft gibt den Standard-Konstruktor für <code>ArrayBuffer</code> Objekte zurück. Konstruktoren von Unterklassen überschreiben dieses, um die Konstruktorzuweisung zu ändern.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Die <code>species</code> Eigenschaft gibt die Standard-Konstruktorfunktion zurück, welche der <code>ArrayBuffer</code> Konstruktor für <code>ArrayBuffer</code> Objekte ist:</p> + +<pre class="brush: js">ArrayBuffer[Symbol.species]; // function ArrayBuffer()</pre> + +<p>In einem abgeleiteten Collection Objket (z. B. ein benutzerdefinierter Buffer <code>MyArrayBuffer</code>), ist der <code>MyArrayBuffer</code> species der <code>MyArrayBuffer</code> Konstruktor. Immer, wenn dieser überschrieben werden soll, um zum Beispiel das Eltern <code>ArrayBuffer</code> Objekt in der abgeleiteten Klassenmethode zurückzugeben:</p> + +<pre class="brush: js">class MyArrayBuffer extends ArrayBuffer { + // Overwrite MyArrayBuffer species to the parent ArrayBuffer constructor + static get [Symbol.species]() { return ArrayBuffer; } +}</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-get-arraybuffer-@@species', 'get ArrayBuffer [ @@species ]')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-arraybuffer-@@species', 'get ArrayBuffer [ @@species ]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.ArrayBuffer.@@species")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("Symbol.species")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/arraybuffer/bytelength/index.html b/files/de/web/javascript/reference/global_objects/arraybuffer/bytelength/index.html new file mode 100644 index 0000000000..aa346bcba5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/arraybuffer/bytelength/index.html @@ -0,0 +1,70 @@ +--- +title: ArrayBuffer.prototype.byteLength +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/byteLength +tags: + - ArrayBuffer + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/byteLength +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>byteLength</strong></code> Zugriffseigenschaft repräsentiert die Länge eines {{jsxref("ArrayBuffer")}} in Bytes.</p> + +<div>{{EmbedInteractiveExample("pages/js/arraybuffer-bytelength.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>arr</var>aybuffer.byteLength</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>byteLength</code> Eigenschaft ist eine Zugriffseigenschaft, wessen set-Funktion <code>undefined</code> ist, was bedeutet, dass diese nur gelesen werden kann. Der Wert wird ermittelt, wenn das Array erstellt wird und kann nicht geändert werden. Diese Eigenschaft gibt 0 zurück, wenn der <code>ArrayBuffer</code> detached ist.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +buffer.byteLength; // 8 +</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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt in ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-get-arraybuffer.prototype.bytelength', 'ArrayBuffer.prototype.byteLength')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition im ECMA Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-arraybuffer.prototype.bytelength', 'ArrayBuffer.prototype.byteLength')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.ArrayBuffer.byteLength")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/arraybuffer/index.html b/files/de/web/javascript/reference/global_objects/arraybuffer/index.html new file mode 100644 index 0000000000..a8de24aac7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/arraybuffer/index.html @@ -0,0 +1,144 @@ +--- +title: ArrayBuffer +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +tags: + - ArrayBuffer + - Constructor + - JavaScript + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +--- +<div>{{JSRef}}</div> + +<p>Das <code><strong>ArrayBuffer</strong></code> Objekt repräsentiert einen generischen Buffer mit fester Länge. Der Inhalt eines <code>ArrayBuffer</code>s kann nicht direkt bearbeitet werden; stattdessen wird eines der <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">typisierten Array-Objekte</a> oder ein {{jsxref("DataView")}} Objekt verwendet, welches den Buffer in einem bestimmten Format repräsentiert und von welchem aus sein Inhalt bearbeitet werden kann.</p> + +<div>{{EmbedInteractiveExample("pages/js/arraybuffer-constructor.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new ArrayBuffer(length) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>length</dt> + <dd>Die Größe, in Bytes, des zu erstellenden <code>ArrayBuffer</code>.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues <code>ArrayBuffer </code>Objekt der angegebenen Länge. Der Inhalt wird auf 0 initialisiert.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<p>Ein {{jsxref("RangeError")}} wird erhoben wenn die Länge größer als {{jsxref("Number.MAX_SAFE_INTEGER")}} (>= 2 ** 53) oder negativ ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Der <code>ArrayBuffer</code> Konstruktor erstellt einen neuen <code>ArrayBuffer </code>der angegebenen Länge in Bytes.</p> + +<h3 id="Einen_ArrayBuffer_von_existierenden_Daten_erstellen">Einen ArrayBuffer von existierenden Daten erstellen</h3> + +<ul> + <li><a href="/de/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">Von einem Base64-String</a></li> + <li><a href="/de/docs/Web/API/FileReader#readAsArrayBuffer()">Von einer lokalen Datei</a></li> +</ul> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>ArrayBuffer.length</code></dt> + <dd>Der Wert des <code>ArrayBuffer</code> Konstruktors für die Länge.</dd> + <dt>{{jsxref("ArrayBuffer.@@species", "get ArrayBuffer[@@species]")}}</dt> + <dd>Die Konstruktor-Funktion um abgeleitete Objekte zu erstellen.</dd> + <dt>{{jsxref("ArrayBuffer.prototype")}}</dt> + <dd>Erlaubt das Hinzufügen von Eigenschaften zu allen <code>ArrayBuffer </code>Objekten.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("ArrayBuffer.isView", "ArrayBuffer.isView(arg)")}}</dt> + <dd>Gibt <code>true</code> zurück wenn <code>arg</code> eines der Views des <code>ArrayBuffers </code>ist, wie zum Beispiel die <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">typisierten Array-Objekt</a>e oder ein {{jsxref("DataView")}}. Ansonsten wird <code>false</code> zurückgegeben.</dd> + <dt>{{jsxref("ArrayBuffer.transfer", "ArrayBuffer.transfer(oldBuffer [, newByteLength])")}} {{experimental_inline}}</dt> + <dd> + <div class="line" id="file-arraybuffer-transfer-LC6">Gibt einen neuen <code>ArrayBuffer</code> zurück, dessen Inhalt von den Daten des <code>oldBuffer</code>s genommen wird und dann entweder abgeschnitten oder mit Null auf <code>newByteLength</code> erweitert wird.</div> + </dd> +</dl> + +<h2 id="Instanzen">Instanzen</h2> + +<p>Alle <code>ArrayBuffer</code> Instanzen erben von {{jsxref("ArrayBuffer.prototype")}}.</p> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<p>{{page('de/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Eigenschaften')}}</p> + +<h3 id="Methoden_2">Methoden</h3> + +<p>{{page('de/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Methoden')}}</p> + +<dl> + <dt>{{jsxref("ArrayBuffer.slice()")}} {{non-standard_inline}}</dt> + <dd>Hat die selbe Funktion wie {{jsxref("ArrayBuffer.prototype.slice()")}}.</dd> +</dl> + +<h2 id="Beispiel">Beispiel</h2> + +<p>In diesem Beispiel erstellen wir einen 8-byte Puffer mit einem {{jsxref("Global_Objects/Int32Array", "Int32Array")}} View, um auf den Puffer zu verweisen:</p> + +<pre class="brush: js">var buffer = new ArrayBuffer(8); +var view = new Int32Array(buffer);</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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition im ECMA Standard. Spezifiziert, dass <code>new</code> benötigt wird.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.ArrayBuffer")}}</p> + +<h2 id="Kompatibilitätshinweis">Kompatibilitätshinweis</h2> + +<p>Seit ECMAScript 2015 müssen <code>ArrayBuffer</code> Konstruktor mit einem {{jsxref("Operators/new", "new")}} Operator konstruiert werden. Einen <code>ArrayBuffer</code> Konstruktor als Funktion aufzurufen ohne <code>new</code> ab sofort einen {{jsxref("TypeError")}} erheben.</p> + +<pre class="brush: js example-bad">var dv = ArrayBuffer(10); +// TypeError: Einen eingebauten ArrayBuffer-Konstruktor +// ohne new aufzurufen ist nicht erlaubt.</pre> + +<pre class="brush: js example-good">var dv = new ArrayBuffer(10);</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typed arrays</a></li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/arraybuffer/isview/index.html b/files/de/web/javascript/reference/global_objects/arraybuffer/isview/index.html new file mode 100644 index 0000000000..f00f471fb3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/arraybuffer/isview/index.html @@ -0,0 +1,89 @@ +--- +title: ArrayBuffer.isView() +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView +tags: + - ArrayBuffer + - JavaScript + - Method + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>ArrayBuffer.isView()</strong></code> Methode gibt <code>true</code> zurück, wenn <code>arg</code> eines der <code>ArrayBuffer</code> Views ist, so wie <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">getyptes Array Objekte</a> oder eine {{jsxref("DataView")}}; andernfalls <code>false</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/arraybuffer-isview.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>ArrayBuffer.isView(<var>arg</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>arg</code></dt> + <dd>Der Parameter, der überprüft wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><code>true</code>, wenn der gegebene Parameter ist einer der <code>ArrayBuffer</code> Views; andernfalls <code>false</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">ArrayBuffer.isView(); // false +ArrayBuffer.isView([]); // false +ArrayBuffer.isView({}); // false +ArrayBuffer.isView(null); // false +ArrayBuffer.isView(undefined); // false +ArrayBuffer.isView(new ArrayBuffer(10)); // false + +ArrayBuffer.isView(new Uint8Array()); // true +ArrayBuffer.isView(new Float32Array()); // true +ArrayBuffer.isView(new Int8Array(10).subarray(0, 3)); // true + +var buffer = new ArrayBuffer(2); +var dv = new DataView(buffer); +ArrayBuffer.isView(dv); // true +</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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt in ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-arraybuffer.isview', 'ArrayBuffer.isView')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition im ECMA Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arraybuffer.isview', 'ArrayBuffer.isView')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.ArrayBuffer.isView")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/arraybuffer/prototype/index.html b/files/de/web/javascript/reference/global_objects/arraybuffer/prototype/index.html new file mode 100644 index 0000000000..b287e0712c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/arraybuffer/prototype/index.html @@ -0,0 +1,68 @@ +--- +title: ArrayBuffer.prototype +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype +tags: + - ArrayBuffer + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>ArrayBuffer.prototype</code></strong> Eigenschaft repräsentiert den Prototyp für das {{jsxref("ArrayBuffer")}} Objekt.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>ArrayBuffer</code> Instanzen erben von <code>ArrayBuffer.prototype</code>. Wie bei allen Konstruktoren, kann der Prototype des Konstruktorobjekts geändert werden, um Änderungen für alle <code>ArrayBuffer</code> Instanzen zu übernehmen.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>ArrayBuffer.prototype.constructor</dt> + <dd>Spezifiziert die Funktion, die das Prototypeobjekt erstellt. Der Initialwert ist der eingebaute Standard-<code>ArrayBuffer</code>-Konstruktor.</dd> + <dt>{{jsxref("ArrayBuffer.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Die größe, in Bytes, des Arrays. Dieser wird bei der Erstellung des Arrays ermittelt und kan nicht geändert werden.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("ArrayBuffer.prototype.slice()")}}</dt> + <dd>Gibt einen neuen <code>ArrayBuffer</code> zurück, welcher eine Kopie der Bytes des eigentlichen <code>ArrayBuffer</code> einthält. Die Kopie geht von <code>begin</code> (inklusiv) bis <code>end</code> (exclusiv). Wenn einer der Werte negativ ist, referenziert er auf den Index vom Ende des Arrays an und nicht vom Beginn des Arrays.</dd> +</dl> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spzifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.ArrayBuffer.prototype")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/arraybuffer/slice/index.html b/files/de/web/javascript/reference/global_objects/arraybuffer/slice/index.html new file mode 100644 index 0000000000..f149d2322b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/arraybuffer/slice/index.html @@ -0,0 +1,88 @@ +--- +title: ArrayBuffer.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice +tags: + - ArrayBuffer + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>slice()</strong></code> Methode gibt einen neuen <code>ArrayBuffer</code> zurück, wessen Inhalt eine Kopie der <code>ArrayBuffer</code> Bytes von <code>begin</code> (inklusiv) bis <code>end</code> (exklusiv) ist.</p> + +<div>{{EmbedInteractiveExample("pages/js/arraybuffer-slice.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">arraybuffer.slice(begin[, end])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>begin</code></dt> + <dd>0-basierter Byteindex an welchem slice <code>slice</code> mit dem zuschneiden beginnt.</dd> +</dl> + +<dl> + <dt><code>end</code></dt> + <dd>Byteindex bevor <code>slice</code> das zuschneiden beendet. Wenn end nicht angegeben ist, wird der neue <code>ArrayBuffer</code> alle Bytes von <code>begin</code> des <code>ArrayBuffer</code> enthalten.<span id="result_box" lang="de"><span> Der durch die Anfangs- und Endwerte angegebene Bereich wird an den gültigen Indexbereich für das aktuelle Array gebunden.</span> <span>Wenn die berechnete Länge des neuen ArrayBuffers negativ wäre, wird er auf 0 gesetzt.</span></span></dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues <code>ArrayBuffer</code> Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>slice</code> Methode kopiert bis zum Byteindex <code>end</code> Parameter, der nicht enthalten ist. Wenn <code>begin</code> oder <code>end</code> negativ ist, referenziert dieser zum Index vom Ende der Array, im Gegensatz zum Anfang des Arrays</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einen_ArrayBuffer_kopieren">Einen <code>ArrayBuffer</code> kopieren</h3> + +<pre class="brush: js">var buf1 = new ArrayBuffer(8); +var buf2 = buf1.slice(0); +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt in EMCAScript 6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arraybuffer.prototype.slice', 'ArrayBuffer.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition im ECMA Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arraybuffer.prototype.slice', 'ArrayBuffer.prototype.slice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.ArrayBuffer.slice")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/arraybuffer/transfer/index.html b/files/de/web/javascript/reference/global_objects/arraybuffer/transfer/index.html new file mode 100644 index 0000000000..3004da98bf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/arraybuffer/transfer/index.html @@ -0,0 +1,84 @@ +--- +title: ArrayBuffer.transfer() +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/transfer +tags: + - ArrayBuffer + - Experimental + - JavaScript + - Method + - Reference + - TypedArrays +translation_of: Archive/Web/JavaScript/ArrayBuffer.transfer +--- +<div>{{JSRef}} {{SeeCompatTable}}</div> + +<p>Die statische <code><strong>ArrayBuffer.transfer()</strong></code> Funktion gibt einen neuen <code>ArrayBuffer</code> mit dem Inhalt von <code>oldBuffer</code>. Je nachdem, wei die <code>newByteLength</code> gesetzt ist, werden die Daten abgeschnitten oder erweitert. Wenn <code>newByteLength</code> nicht gesetzt ist, wird die <code>byteLength</code> von <code>oldBuffer</code> benutzt. Diese Operation bringt <code>oldBuffer</code> in einen detached Status.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">ArrayBuffer.transfer(oldBuffer [, newByteLength]);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>oldBuffer</code></dt> + <dd>Ein {{jsxref("ArrayBuffer")}} Objekt von dem die Daten transferiert werden.</dd> + <dt>newByteLength</dt> + <dd>Die Bytelänge des neuen <code>ArrayBuffer</code> Objektes.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues <code>ArrayBuffer</code> Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>ArrayBuffer.transfer()</code> Methode erlaubt es ein <code>ArrayBuffer</code> zu vergrößern und zu detachen. Die Möglichkeit ein <code>ArrayBuffer</code> zu vergrößern ohne es zu kopieren, hat den Vorteil, dass es viel schneller für große Buffer ist (ähnlich wie bei realloc). Die Möglichkeit, dass ein <code>ArrayBuffer</code> detachet wird, gibt dem Entwickler die explizite Kontrolle über das freigeben des internen Speichers. Dieses vermeidet das Entfernen aller Referenzen und das Warten auf die Garbage Collection.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var buf1 = new ArrayBuffer(40); +new Int32Array(buf1)[0] = 42; + +var buf2 = ArrayBuffer.transfer(buf1, 80); +buf1.byteLength; // 0 but if you use the polyfill then the value is still 40 +buf2.byteLength; // 80 +new Int32Array(buf2)[0]; // 42 + +var buf3 = ArrayBuffer.transfer(buf2, 0); +buf2.byteLength; // 0 but if you use the polyfill then the value is still 80 +buf3.byteLength; // 0 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Für Browser, die die Funktion nicht nativ unterstützen, gibt es die Möglichkeit folgenden Quelltext am Anfang eines Skriptes einzufügen, um die Funktion <code>transfer()</code> zu benutzen. Diese Funktion ist nicht exakt die in der API beschriebene, weil Browser, die die Funktion unterstützen, direkten Zugriff auf die C++ Funktion <code>realloc()</code> haben, welche die Länge des Speichers erhöht und nur eine Kopie anlegt, wenn es nötig ist. Im Gegensatz dazu kopiert der folgende Pollyfill alles immer in neuen Speicher. Diese Funktion transferiert die Daten jedoch von einem <code>ArrayBuffer</code> zu einem anderen.</p> + +<pre class="brush: js">if (!ArrayBuffer.transfer) { + ArrayBuffer.transfer = function(source, length) { + if (!(source instanceof ArrayBuffer)) + throw new TypeError('Source must be an instance of ArrayBuffer'); + if (length <= source.byteLength) + return source.slice(0, length); + var sourceView = new Uint8Array(source), + destView = new Uint8Array(new ArrayBuffer(length)); + destView.set(sourceView); + return dest.buffer; + }; +}</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Ist in keiner aktuellen Spezifikation enthalten, wird aber <a href="https://esdiscuss.org/topic/sept-23-2014-meeting-notes">in der Zukunft für ECMA-262 geplant</a>.</p> + +<h2 id="Browserkompatibilität"><a id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</a></h2> + + + +<p>{{Compat("javascript.builtins.ArrayBuffer.transfer")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript getypte Arrays</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/asyncfunction/index.html b/files/de/web/javascript/reference/global_objects/asyncfunction/index.html new file mode 100644 index 0000000000..994df6d344 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/asyncfunction/index.html @@ -0,0 +1,124 @@ +--- +title: AsyncFunction +slug: Web/JavaScript/Reference/Global_Objects/AsyncFunction +tags: + - Constructor + - Experimental + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/AsyncFunction +--- +<div>{{JSRef}}</div> + +<p>Der <strong><code>AsyncFunction</code> Konstruktor</strong> erstellt ein neues {{jsxref("Statements/async_function", "AsyncFunction")}} Objekt. In JavaScript ist jede asynchrone Funktion ein <code>AsyncFunction</code> Objekt.</p> + +<div class="note"> +<p><strong>Hinweis: </strong><code>AsyncFunction</code> ist kein globales Objekt. Durch die ausführung des folgenden Quelltextes kann das Objekte erhalten werden.</p> + +<pre class="brush: js">Object.getPrototypeOf(async function(){}).constructor</pre> +</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new AsyncFunction([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Namen, die für die Namen der formalen Parameter der Funktion verwendet werden. Jeder muss ein String mit einem validen JavaScript-Bezeichner sein oder eine Liste von Strings, welche mit einem Komma getrennt sind; zum Beispiel "<code>x</code>", "<code>theValue</code>", oder "<code>a,b</code>".</dd> + <dt><code>functionBody</code></dt> + <dd>Ein String, welcher die JavaScript-Anweisungen enthält, welche die Funktion definieren.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("Statements/async_function", "asyncFunction")}} Objekte, die mit dem <code>AsyncFunction</code> Konstruktor erstellt werden, werden analysieren, wenn sie erstellt werden. Dieses ist weniger effizient als die Deklaration einer asynchronen Funktion mit einem {{jsxref("Statements/async_function", "asyncFunction Ausdruck")}} und dem Aufruf in dem Code, weil solche Funktion mit dem Rest des Quelltextes analysieren werden.</p> + +<p><span id="result_box" lang="de"><span>Alle an die Funktion übergebenen Argumente werden als die Namen der Bezeichner der Parameter in der zu erstellenden Funktion in der Reihenfolge behandelt, in der sie übergeben werden.</span></span></p> + +<div class="note"> +<p><strong>Hinweis:</strong> Mit dem <code>AsyncFunction</code> Konstruktor erstellte {{jsxref("Statements/async_function", "asyncFunctions")}} erstellen keine Closures in ihrem Erstellungskontext; Sie werden immer im globalen Scope erstellt. Wenn sie ausgeführt werden, haben sie nur Zugriff auf eigene lokale Variablen und globale Variablen, jedoch nicht auf Variablen aus dem Scope, indem der <code>AsyncFunction</code> Konstruktor aufgerufen wurde. Dies ist der Unterschied zum Einsatz von {{jsxref("Global_Objects/eval", "eval")}} mit Quelltext für eine asynchrone Funktionsanweisung.</p> +</div> + +<p>Das Aufrufen des <code>AsyncFunction</code> Konstruktors als Funktion (ohne Einsatz des <code>new</code> Operators) hat den gleichen Effekt wie das Aufrufen als Konstruktor.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code><strong>AsyncFunction.length</strong></code></dt> + <dd>Die <code>AsyncFunction</code> Konstruktor Längeneigenschaft, welche den Wert 1 hat.</dd> + <dt>{{jsxref("AsyncFunction.prototype")}}</dt> + <dd>Erlaubt das Hinzufügen von Eigenschaften zu allen <code>AsyncFunction</code> Objekten.</dd> +</dl> + +<h2 id="AsyncFunction_Prototype_Objekt"><code>AsyncFunction</code> Prototype Objekt</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype', 'Eigenschaften')}}</div> + +<h2 id="AsyncFunction_Instanzen"><code>AsyncFunction</code> Instanzen</h2> + +<p><code>AsyncFunction</code> Instanzen erben Methoden und Eigenschaften von {{jsxref("AsyncFunction.prototype")}}. Wie bei allen Konstruktoren ist es möglich die Eigenschaften des Konstruktor Objektes zu ändern, um Änderungen an allen <code>AsyncFunction</code> Instanzen vorzunehmen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Erstellen_einer_asynchronen_Funktion_mit_einem_AsyncFunction_Konstruktor">Erstellen einer asynchronen Funktion mit einem <code>AsyncFunction</code> Konstruktor</h3> + +<pre class="brush: js">function resolveAfter2Seconds(x) { + return new Promise(resolve => { + setTimeout(() => { + resolve(x); + }, 2000); + }); +} + +var AsyncFunction = Object.getPrototypeOf(async function(){}).constructor + +var a = new AsyncFunction('a', + 'b', + 'return await resolveAfter2Seconds(a) + await resolveAfter2Seconds(b);'); + +a(10, 20).then(v => { + console.log(v); // prints 30 after 4 seconds +}); +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-async-function-objects', 'AsyncFunction object')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.AsyncFunction")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Statements/async_function", "async function function")}}</li> + <li>{{jsxref("Operators/async_function", "async function expression")}}</li> + <li>{{jsxref("Global_Objects/Function", "Function")}}</li> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Functions_and_function_scope", "Functions and function scope", "", 1)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/asyncfunction/prototype/index.html b/files/de/web/javascript/reference/global_objects/asyncfunction/prototype/index.html new file mode 100644 index 0000000000..2dc516ca5c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/asyncfunction/prototype/index.html @@ -0,0 +1,61 @@ +--- +title: AsyncFunction.prototype +slug: Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype +tags: + - Experimental + - JavaScript + - Property + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>AsyncFunction.prototype</strong></code> Eigenschaft repräsentiert den Prototypen des {{jsxref("AsyncFunction")}} Objektes.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("AsyncFunction")}} Objekte erben von <code>AsyncFunction.prototype</code>. <code>AsyncFunction.prototype</code> kann nicht verändert werden.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code><strong>AsyncFunction.constructor</strong></code></dt> + <dd>Der Initialwert ist {{jsxref("AsyncFunction")}}.</dd> + <dt><code><strong>AsyncFunction.prototype[@@toStringTag]</strong></code></dt> + <dd>Gibt <code>"AsyncFunction"</code> zurück.</dd> +</dl> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-async-function-constructor-prototype', 'AsyncFunction.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.AsyncFunction.prototype")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("AsyncFunction")}}</li> + <li>{{jsxref("Function")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/add/index.html b/files/de/web/javascript/reference/global_objects/atomics/add/index.html new file mode 100644 index 0000000000..f9b8e98b1b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/add/index.html @@ -0,0 +1,83 @@ +--- +title: Atomics.add() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/add +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/add +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.add()</code></strong> Methode addiert eine gegebenen Wert an einer gegebenen Position im Array und gibt den alten Wert zurück. Diese atomare Operation garantiert, dass keine andere Schreiboperation während der Operation durchgeführt werden kann.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-add.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.add(typedArray, index, value) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position in <code>typedArray</code>, zu der <code>value</code> addiert wird.</dd> + <dt><code>value</code></dt> + <dd>Die Zahl, die addiert werden soll.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li> + <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); + +Atomics.add(ta, 0, 12); // returns 0, the old value +Atomics.load(ta, 0); // 12</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-atomics.add', 'Atomics.add')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.add")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.sub()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/and/index.html b/files/de/web/javascript/reference/global_objects/atomics/and/index.html new file mode 100644 index 0000000000..34093b64e7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/and/index.html @@ -0,0 +1,129 @@ +--- +title: Atomics.and() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/and +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/and +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.and()</code></strong> Methode berechnet eine bitweises UND mit einem gegebenen Wert auf einem Wert an einer gegebenen Position im Array und gibt den alten Wert an der Position zurück. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-and.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.and(typedArray, index, value) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position in <code>typedArray</code>, mit der das bitweise UND berechnet wird.</dd> + <dt><code>value</code></dt> + <dd>Die Zahl, mit der das bitweise UND berechnet wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li> + <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die bitweise UND Operation ergibt nur 1, wenn beide Werte, <code>a</code> und <code>b</code>, 1 sind. Die Wahrheitstabelle für die UND Operation ist:</p> + +<table class="standard-table"> + <thead> + <tr> + <th><code>a</code></th> + <th><code>b</code></th> + <th><code>a & b</code></th> + </tr> + </thead> + <tbody> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<p>Zum Beispiel resultiert ein bitweises UND auf <code>5 & 1</code> in <code>0001</code>, was im Dezimalsystem 1 ist.</p> + +<pre>5 0101 +1 0001 + ---- +1 0001</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); +ta[0] = 5; + +Atomics.and(ta, 0, 1); // returns 0, the old value +Atomics.load(ta, 0); // 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('ESDraft', '#sec-atomics.and', 'Atomics.and')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.and")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.or()")}}</li> + <li>{{jsxref("Atomics.xor()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/compareexchange/index.html b/files/de/web/javascript/reference/global_objects/atomics/compareexchange/index.html new file mode 100644 index 0000000000..1c61ef7d26 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/compareexchange/index.html @@ -0,0 +1,86 @@ +--- +title: Atomics.compareExchange() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.compareExchange()</code></strong> Methode ersetzt einen Wert an einer gegebenen Position im einem Array mit einem gegebene Wert aus, wenn ein gegebenen Wert gleich dem alten Wert ist. Es wird der alte Wert an der Position zurückgegeben, egal ob der abzugleichende Wert gleich oder nicht ist. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-compareexchange.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.compareExchange(typedArray, index, expectedValue, replacementValue) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position in <code>typedArray</code>, an den ein Wert ersetzt wird.</dd> + <dt><code>expectedValue</code></dt> + <dd>Wert, auf dem die gleichheit geprüft wird.</dd> + <dt>replacementValue</dt> + <dd>Neu Zahl, die geschreiben wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li> + <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); +ta[0] = 7; + +Atomics.compareExchange(ta, 0, 7, 12); // returns 7, the old value +Atomics.load(ta, 0); // 12</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-atomics.compareexchange', 'Atomics.compareExchange')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.compareExchange")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.exchange()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/exchange/index.html b/files/de/web/javascript/reference/global_objects/atomics/exchange/index.html new file mode 100644 index 0000000000..df040868a6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/exchange/index.html @@ -0,0 +1,85 @@ +--- +title: Atomics.exchange() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/exchange +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/exchange +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.exchange()</code></strong> Methode ersetzt einen Wert an einer gegebenen Position im einem Array mit einem gegebene Wert aus. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-exchange.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.compareExchange(typedArray, index, value) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position in <code>typedArray</code>, an den ein Wert ersetzt wird.</dd> + <dt><code>value</code></dt> + <dd>Neu Zahl, die geschreiben wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li> + <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); + +Atomics.compareExchange(ta, 0, 12); // returns 0, the old value +Atomics.load(ta, 0); // 12</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-atomics.exchange', 'Atomics.exchange')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.exchange")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.compareExchange()")}}</li> +</ul> + +<p> </p> diff --git a/files/de/web/javascript/reference/global_objects/atomics/index.html b/files/de/web/javascript/reference/global_objects/atomics/index.html new file mode 100644 index 0000000000..e8a945060e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/index.html @@ -0,0 +1,116 @@ +--- +title: Atomics +slug: Web/JavaScript/Reference/Global_Objects/Atomics +tags: + - JavaScript + - Shared Memory + - Specifications +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Atomics</code></strong> Objekt unterstützt atomare Operationen als statische Methoden. Diese werden mit {{jsxref("SharedArrayBuffer")}} Objekte benutzt.</p> + +<p>Die atomaren Operationen sind auf dem <code>Atomics</code> Modul installiert. Anders, als bei anderen globalen Objekten, ist, dass <code>Atomics</code> kein Konstruktor ist. Man kann <code>Atomics</code> nicht mit einem <a href="/de/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> Operator</a> oder als Funktion verwenden. Alle Eigenschaften und Methoden von <code>Atomics</code> sind statisch (genauso wie zum Beispiel bei dem {{jsxref("Math")}} Objekt).</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Atomics[Symbol.toStringTag]</code></dt> + <dd>Der Wert dieser Eigenschaft ist: <code>"Atomics"</code>.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<h3 id="Atomare_Operationen">Atomare Operationen</h3> + +<p>Wenn Speicher geteilt wird, können mehrere Threads auf dem gleichen Speicher lesen und schreiben. Atomare Operationen stellen sicher, dass Werte in einer Operation geschrieben und gelesen werden bevor mit der nächste Operation begonnen wird und dass eine Operation nicht unterbrochen wird.</p> + +<dl> + <dt>{{jsxref("Atomics.add()")}}</dt> + <dd>Addiert den angegebenen Wert dem existierenden Wert an der gegebenen Position im Array hinzu. Gibt den alten Wert an der Position zurück.</dd> + <dt>{{jsxref("Atomics.and()")}}</dt> + <dd>Berechnet ein Bitweises UND mit dem Wert an der angegebenen Position im Array und dem angegebenen Wert. Gibt den alten Wert an der Position zurück.</dd> + <dt>{{jsxref("Atomics.compareExchange()")}}</dt> + <dd>Speichert einen angegebenen Wert an der angegebenen Position im Array, wenn dieser gleich einem angegebene Wert ist. Gibt den alten Wert zurück.</dd> + <dt>{{jsxref("Atomics.exchange()")}}</dt> + <dd>Speichert einen angegebenen Wert an einer angegebenen Position im Array. Gibt den alten Wert zurück.</dd> +</dl> + +<dl> + <dt>{{jsxref("Atomics.load()")}}</dt> + <dd>Gibt den Wert an einer angegebenen Position im Array zurück.</dd> + <dt>{{jsxref("Atomics.or()")}}</dt> + <dd>Berechnet ein Bitweises ODER mit dem gegebenen Wert an der angegebenen Position im Array und dem angegebenen Wert. Gibt den alten Wert an der Position zurück.</dd> + <dt>{{jsxref("Atomics.store()")}}</dt> + <dd>Speichert einen angegebenen Wert an einer angegebenen Position im Array. Gibt den Wert zurück.</dd> + <dt>{{jsxref("Atomics.sub()")}}</dt> + <dd>Subtrahiert einen angegebenen Wert von einem Wert an einer angegebenen Position im Array. Gibt den alten Wert an der Position zurück.</dd> + <dt>{{jsxref("Atomics.xor()")}}</dt> + <dd>Berechnet ein Bitweises XOR mit dem Wert an einer angegebenen Position im Array und einem angegebenen Wert. Gibt den alten Wert an der Position zurück.</dd> +</dl> + +<h3 id="Wait_und_notify">Wait und notify</h3> + +<p>Die <code>wait()</code> und <code>notify()</code> Methoden sind auf Linux Futexes ("fast user-space mutex") modelliert und ermöglichen es zu warten, bis eine bestimmte Bedingung <code>true</code> wird, und wird als blockierendes Konstrukt verwendet.</p> + +<dl> + <dt>{{jsxref("Atomics.wait()")}}</dt> + <dd>Überprüft, ob an der angegebenen Position in einem Array einen angegebener Wert enthalten ist und wartet oder bekommt ein Timeout. Es wird <code>"ok"</code>, <code>"not-equal"</code>, oder <code>"timed-out"</code> zurückgegeben. Wenn Warten im ausführenden Agenten nicht erlaubt ist, wird ein Fehler geworfen (die meisten Browser erlauben kein <code>wait()</code> im Browser main Thread).</dd> + <dt>{{jsxref("Atomics.notify()")}}</dt> + <dd>Benachrichtigt Agenten, die auf die angegebene Arrayposition warten. Gibt die Zahl der benachrichtigten Agenten zurück.</dd> + <dt>{{jsxref("Atomics.isLockFree()", "Atomics.isLockFree(size)")}}</dt> + <dd> + <p>Eine primitive Optimierung, die feststellten kann, ob Locks und atomare Operationen benutzt werden können. Gibt <code>true</code> zurück, wenn atomare Operationen auf einem Array der gegebenen Elementgröße mit einer atomaren Hardwareoperation implementiert ist (im Gegensatz zu einem Lock). Nur für Experten.</p> + </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('ESDraft', '#sec-atomics-object', 'Atomics')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-atomics-object', 'Atomics')}}</td> + <td>{{Spec2('ES8')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics")}}</p> + +<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2> + +<p><span id="result_box" lang="de"><span>Vor Firefox 48 waren die neuesten API-Namen und Semantiken noch nicht implementiert.</span></span> Die Unterschiede zwischen der Firefox Version 46 und der Version 48 sind:</p> + +<ul> + <li>Die Methoden <code>Atomics.futexWakeOrRequeue()</code> und <code>Atomics.fence()</code> sind vollständig entfernt ({{bug(1259544)}} und {{bug(1225028)}}).</li> + <li>Die Methoden {{jsxref("Atomics.wait()")}} and {{jsxref("Atomics.wake()")}} hießen <code>Atomics.futexWait()</code> und <code>Atomics.futexWake()</code> ({{bug(1260910)}}). Hinweis: Die alten Namen wurden in den Version 49 und später entfernt ({{bug(1262062)}}).</li> + <li>Die Eigenschaften <code>Atomics.OK</code>, <code>Atomics.TIMEDOUT</code>, <code>Atomics.NOTEQUAL</code> wurden entfernt. die Methode {{jsxref("Atomics.wait()")}} gibt jetzt die Strings <code>"ok"</code>, <code>"timed-out"</code> und <code>"not-equal"</code> zurück ({{bug(1260835)}}).</li> + <li>Der <code>count</code> Parameter der {{jsxref("Atomics.wake()")}} Methode wurde geändert: Der Standardwert ist <code>+Infinity</code> und nicht <code>0</code> ({{bug(1253350)}}).</li> +</ul> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> + <li><a href="/de/docs/Web/JavaScript/Typed_arrays">JavaScript getypte Arrays</a></li> + <li><a href="/de/docs/Web/API/Web_Workers_API">Web Workers</a></li> + <li><a href="https://github.com/lars-t-hansen/parlib-simple">parlib-simple </a>– Eine einfache Bibliothek, die Synchronisation und verteilte Abstraktionen ermöglicht.</li> + <li><a href="https://github.com/tc39/ecmascript_sharedmem/blob/master/TUTORIAL.md">Geteilter Speicher (Shared Memory) – ein kurzes Tutorial</a></li> + <li><a href="https://hacks.mozilla.org/2016/05/a-taste-of-javascripts-new-parallel-primitives/">A Taste of JavaScript’s New Parallel Primitives – Mozilla Hacks</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/islockfree/index.html b/files/de/web/javascript/reference/global_objects/atomics/islockfree/index.html new file mode 100644 index 0000000000..61bf90e0bf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/islockfree/index.html @@ -0,0 +1,73 @@ +--- +title: Atomics.isLockFree() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.isLockFree()</code></strong> Methode wird benutzt, um festzustellen, ob ein Lock (Sperre) oder eine atomare Operation vorhanden ist. Sie gibt <code>true</code> zurück, wenn die gegebene Größe eine von den in der <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/BYTES_PER_ELEMENT">BYTES_PER_ELEMENT</a> Eigenschften von Integer TypedArray Typen ist.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-islockfree.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.isLockFree(size) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>size</code></dt> + <dd>Die größe in Bytes, für die geprüft wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Boolean")}}, der angibt, ob die Operation frei von Locks ist.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Atomics.isLockFree(1); // true +Atomics.isLockFree(2); // true +Atomics.isLockFree(3); // false +Atomics.isLockFree(4); // true +Atomics.isLockFree(5); // false +Atomics.isLockFree(6); // false +Atomics.isLockFree(7); // false +Atomics.isLockFree(8); // false</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-atomics.islockfree', 'Atomics.isLockFree')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.isLockFree")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/load/index.html b/files/de/web/javascript/reference/global_objects/atomics/load/index.html new file mode 100644 index 0000000000..07d2c4a477 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/load/index.html @@ -0,0 +1,81 @@ +--- +title: Atomics.load() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/load +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/load +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.load()</code></strong> Methode gibt den Wert an einer gegebenen Position in einem Array zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-load.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.load(typedArray, index) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position in <code>typedArray</code>, von der der Wert geladen wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Wert an der gegebenen Position (<code>typedArray[index]</code>).</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li> + <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); + +Atomics.add(ta, 0, 12); +Atomics.load(ta, 0); // 12</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-atomics.load', 'Atomics.load')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.load")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.store()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/or/index.html b/files/de/web/javascript/reference/global_objects/atomics/or/index.html new file mode 100644 index 0000000000..ec052cadde --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/or/index.html @@ -0,0 +1,129 @@ +--- +title: Atomics.or() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/or +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/or +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.or()</code></strong> Methode berechnet eine bitweises ODER mit einem gegebenen Wert auf einem Wert an einer gegebenen Position im Array und gibt den alten Wert an der Position zurück. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-or.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.and(typedArray, index, value) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position in <code>typedArray</code>, mit der das bitweise ODER berechnet wird.</dd> + <dt><code>value</code></dt> + <dd>Die Zahl, mit der das bitweise ODER berechnet wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li> + <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die bitweise ODER Operation ergibt nur 1, wenn eine Werte, <code>a</code> oder <code>b</code>, 1 ist. Die Wahrheitstabelle für die ODER Operation ist:</p> + +<table class="standard-table"> + <thead> + <tr> + <th><code>a</code></th> + <th><code>b</code></th> + <th><code>a | b</code></th> + </tr> + </thead> + <tbody> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<p>Zum Beispiel resultiert ein bitweises ODER auf <code>5 | 1</code> in <code>0111</code>, was im Dezimalsystem 5 ist.</p> + +<pre>5 0101 +1 0001 + ---- +5 0101</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); +ta[0] = 2; + +Atomics.or(ta, 0, 1); // returns 2, the old value +Atomics.load(ta, 0); // 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('ESDraft', '#sec-atomics.or', 'Atomics.or')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.or")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.and()")}}</li> + <li>{{jsxref("Atomics.xor()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/store/index.html b/files/de/web/javascript/reference/global_objects/atomics/store/index.html new file mode 100644 index 0000000000..6112dc5f62 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/store/index.html @@ -0,0 +1,82 @@ +--- +title: Atomics.store() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/store +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/store +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.store()</code></strong> Methode speichert einen gegebenen Wert an einer gegebenen Position in dem Array und gibt den Wert zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-store.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.store(typedArray, index, value) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position in <code>typedArray</code>, an der <code>value</code> gespeichert wird.</dd> + <dt><code>value</code></dt> + <dd>Die Zahl, die gespeichert wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Wert, der abgespeichert wurde.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li> + <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); + +Atomics.store(ta, 0, 12); // 12</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-atomics.store', 'Atomics.store')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.store")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.load()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/sub/index.html b/files/de/web/javascript/reference/global_objects/atomics/sub/index.html new file mode 100644 index 0000000000..cce9ae06c6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/sub/index.html @@ -0,0 +1,86 @@ +--- +title: Atomics.sub() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/sub +tags: + - Atomics + - Java + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/sub +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.sub()</code></strong> Methode subtrahiert eine gegebenen Wert an einer gegebenen Position im Array und gibt den alten Wert zurück. Diese atomare Operation garantiert, dass keine andere Schreiboperation während der Operation durchgeführt werden kann.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-sub.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.add(typedArray, index, value) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position in <code>typedArray</code>, zu der <code>value</code> subtrahiert wird.</dd> + <dt><code>value</code></dt> + <dd>Die Zahl, die subtrahiert werden soll.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li> + <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); +ta[0] = 48; + +Atomics.sub(ta, 0, 12); // returns 48, the old value +Atomics.load(ta, 0); // 36</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-atomics.sub', 'Atomics.sub')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.sub")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.add()")}}</li> +</ul> + +<p> </p> diff --git a/files/de/web/javascript/reference/global_objects/atomics/wait/index.html b/files/de/web/javascript/reference/global_objects/atomics/wait/index.html new file mode 100644 index 0000000000..6af6022fc4 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/wait/index.html @@ -0,0 +1,95 @@ +--- +title: Atomics.wait() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/wait +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/wait +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.wait()</code></strong> Methode verifiziert, dass eine gegebene Position in einem {{jsxref("Int32Array")}} ein gegebene Wert ist und dann schläft und entweder aufgeweckt wird oder ein Timeout bekommt. Die Strings <code>"ok"</code>, <code>"not-equal"</code>, und <code>"timed-out"</code> sind alle möglichen Rückgabewerte</p> + +<div class="note"> +<p><strong>Hinweis:</strong> Diese Operation funktioniert nur mit einem geteilten<strong> </strong>{{jsxref("Int32Array")}} und ist nicht im Main-Thread erlaubt.</p> +</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.wait(typedArray, index, value[, timeout]) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes {{jsxref("Int32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position im <code>typedArray</code>, an der gewartet wird.</dd> + <dt><code>value</code></dt> + <dd>Der wert, mit dem getestet wird.</dd> + <dt><code>timeout</code> {{optional_inline}}</dt> + <dd>Wartezeit in Millisekunden. {{jsxref("Infinity")}}, wenn keine Zeit angegeben wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("String")}} welcher <code>"ok"</code>, <code>"not-equal"</code> oder <code>"timed-out"</code> ist.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein {{jsxref("Int32Array")}} ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beipsiele">Beipsiele</h2> + +<p>Gegeben ist ein <code>Int32Array</code>:</p> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var int32 = new Int32Array(sab); +</pre> + +<p>Ein lesender Thread schläft und wartet auf Position 0, ander der Wert 0 erwartet wird. Solange diese gegeben ist, geht es nicht weiter. Immer wenn ein neuer schreibender Thread einen neuen Wert speichert, wacht der Thread. Im Anschluss ist der neue Wert an der Position 0 (123).</p> + +<pre class="brush: js">Atomics.wait(int32, 0, 0); +console.log(int32[0]); // 123</pre> + +<p>Ein schreibender Thread speichert einen neuen Wert und wacht den wartenden Thread nach dem Schreiben auf.</p> + +<pre class="brush: js">console.log(int32[0]); // 0; +Atomics.store(int32, 0, 123); +Atomics.wake(int32, 0, 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('ESDraft', '#sec-atomics.wait', 'Atomics.wait')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.wait")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.wake()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/wake/index.html b/files/de/web/javascript/reference/global_objects/atomics/wake/index.html new file mode 100644 index 0000000000..5ac06d7adc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/wake/index.html @@ -0,0 +1,93 @@ +--- +title: Atomics.notify() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/wake +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/notify +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.notify()</code></strong> Methode benachrichtigt Threads, die in einer Warteschlange schlafen.</p> + +<div class="note"> +<p><strong>Hinweis:</strong> Diese Operation funktioniert nur mit einem {{jsxref("Int32Array")}}.</p> +</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.notify(typedArray, index, count) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes {{jsxref("Int32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position im <code>typedArray</code>, an der aufgewacht wird.</dd> + <dt><code>count</code></dt> + <dd>Anzahl der aufzuweckenden Threads. Standard ist {{jsxref("Infinity", "+Infinity")}}.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Anzahl an geweckten Threads.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein {{jsxref("Int32Array")}} ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beipsiele">Beipsiele</h2> + +<p>Gegeben ist ein <code>Int32Array</code>:</p> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var int32 = new Int32Array(sab); +</pre> + +<p>Ein lesender Thread schläft und wartet auf Position 0, ander der Wert 0 erwartet wird. Solange diese gegeben ist, geht es nicht weiter. Immer wenn ein neuer schreibender Thread einen neuen Wert speichert, wacht der Thread. Im Anschluss ist der neue Wert an der Position 0 (123).</p> + +<pre class="brush: js">Atomics.wait(int32, 0, 0); +console.log(int32[0]); // 123</pre> + +<p>Ein schreibender Thread speichert einen neuen Wert und wacht den wartenden Tread nach dem Schreiben auf.</p> + +<pre class="brush: js">console.log(int32[0]); // 0; +Atomics.store(int32, 0, 123); +Atomics.notify(int32, 0, 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('ESDraft', '#sec-atomics.notify', 'Atomics.notify')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.notify")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.wait()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/atomics/xor/index.html b/files/de/web/javascript/reference/global_objects/atomics/xor/index.html new file mode 100644 index 0000000000..913fcc1298 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/atomics/xor/index.html @@ -0,0 +1,130 @@ +--- +title: Atomics.xor() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/xor +tags: + - Atomics + - JavaScript + - Method + - Shared Memory +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/xor +--- +<div>{{JSRef}}</div> + +<p>Die statische <code><strong>Atomics</strong></code><strong><code>.xor()</code></strong> Methode berechnet eine bitweises XOR mit einem gegebenen Wert auf einem Wert an einer gegebenen Position im Array und gibt den alten Wert an der Position zurück. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p> + +<div>{{EmbedInteractiveExample("pages/js/atomics-xor.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Atomics.and(typedArray, index, value) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>Die Position in <code>typedArray</code>, mit der das bitweise XOR berechnet wird.</dd> + <dt><code>value</code></dt> + <dd>Die Zahl, mit der das bitweise XOR berechnet wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p> + +<h3 id="Exceptions">Exceptions</h3> + +<ul> + <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li> + <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li> + <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li> +</ul> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die bitweise XOR Operation ergibt nur 1, wenn genau ein Werte, <code>a</code> oder <code>b</code>, 1 ist. Die Wahrheitstabelle für die XOR Operation ist:</p> + +<table class="standard-table"> + <thead> + <tr> + <th><code>a</code></th> + <th><code>b</code></th> + <th><code>a & b</code></th> + </tr> + </thead> + <tbody> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>0</td> + </tr> + </tbody> +</table> + +<p>Zum Beispiel resultiert ein bitweises XOR auf <code>5 & 1</code> in <code>0100</code>, was im Dezimalsystem 4 ist.</p> + +<pre>5 0101 +1 0001 + ---- +4 0100</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); +ta[0] = 5; + +Atomics.xor(ta, 0, 1); // returns 5, the old value +Atomics.load(ta, 0); // 4</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-atomics.xor', 'Atomics.xor')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition in ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Atomics.xor")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.and()")}}</li> + <li>{{jsxref("Atomics.or()")}}</li> +</ul> + +<p> </p> diff --git a/files/de/web/javascript/reference/global_objects/boolean/index.html b/files/de/web/javascript/reference/global_objects/boolean/index.html new file mode 100644 index 0000000000..245c2d1a8b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/boolean/index.html @@ -0,0 +1,159 @@ +--- +title: Boolean +slug: Web/JavaScript/Reference/Global_Objects/Boolean +tags: + - Boolean + - Constructor + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Boolean</code></strong> Objekt ist ein Objekt-Wrapper für einen booleschen Wert.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new Boolean([<var>value</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Optional. Der Anfangswert des <code>Boolean</code>-Objektes.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Der als erster Parameter übergebene Wert wird, wenn nötig, in einen booleschen Wert umgewandelt. Wird der Wert ausgelassen oder ist <code>0</code>, <code>-0</code>, {{jsxref("null")}}, <code>false</code>, {{jsxref("NaN")}}, {{jsxref("undefined")}} oder der leere String (<code>""</code>), so besitzt das Objekt den Initialwert <code>false</code>. Alle anderen Werte, einschließlich eines Objektes oder des Strings <code>"false"</code>, erzeugen ein Objekt mit dem Initialwert <code>true</code>.</p> + +<p>Die Werte <code>true </code>und <code>false </code>des <code>Boolean</code>-Objektes sind nicht zu verwechseln mit den primitiven Booleanwerten <code>true </code>und <code>false.</code></p> + +<p>Jedes Objekt, dessen Wert nicht {{jsxref("undefined")}} oder {{jsxref("null")}} entspricht, einschließlich eines <code>Boolean-</code>Objektes, dessen Wert <code>false</code> ist, wird bei der Übergabe an eine Bedingung als <code>true</code> gewertet. Beispielsweise wird das folgende {{jsxref("Statements/if...else", "if")}} Konstrukt als <code>true</code> ausgewertet:</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> x <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Boolean</span><span class="punctuation token">(</span><span class="string token">"false"</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="keyword token">if</span> <span class="punctuation token">(</span>x<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="comment token">// this code is executed</span> +<span class="punctuation token">}</span> +</code></pre> + +<p>Dieses Verhalten trifft nicht auf primitive Boolwerte zu. Beispielsweise ergibt das folgende {{jsxref("Statements/if...else", "if")}} Konstrukt <code>false</code>:</p> + +<pre class="brush: js">x = false; +if (x) { + // this code is not executed +} +</pre> + +<p>Ein <code>Boolean</code>-Objekt sollte nicht genutzt werden um einen nicht-booleschenWert in einen booleschen Wert umzuwandeln. In diesem Fall wäre es besser, den Boolean als Funktion zu verwenden:</p> + +<pre class="brush: js">x = Boolean(expression); // preferred +x = new Boolean(expression); // don't use +</pre> + +<p>Wird ein Objekt, einschließlich eines <code>Boolean</code>-Objektes dessen Wert <code>false</code> ist, als Anfangsparameter an das <code>Boolean-</code>Objekt übergeben, so hat das neue <code>Boolean</code>-Objekt den Wert <code>true</code>.</p> + +<pre class="brush: js">myFalse = new Boolean(false); // initialer Wert von false +g = Boolean(myFalse); // initialer Wert von true +myString = new String('Hello'); // string objekt +s = Boolean(myString); // initialer Wert von true +</pre> + +<p>Ein <code>Boolean</code>-Objekt darf nicht anstelle eines primitiven <code>Boolean-wertes </code>verwendet werden.</p> + +<div class="note"> +<p><strong>Hinweis:</strong> Wenn die nicht standardisierte Eigenschaft <code><a href="/de/docs/Web/API/Document#Properties">document.all</a></code> als Argument für den Konstruktor benutzt wird, ist das Resultat ein <code>Boolean</code> Objekt mit dem Wert <code>false</code>. Diese Eigenschaft ist veraltet und nicht standardisierte und darf nicht eingesetzt werden.</p> +</div> + +<h2 id="Properties" name="Properties">Eigenschaften</h2> + +<dl> + <dt><code>Boolean.length</code></dt> + <dd>Längen-Eingeschaft, die den Wert 1 hat.</dd> + <dt>{{jsxref("Boolean.prototype")}}</dt> + <dd>Repräsentiert den Prototypen für den <code>Boolean</code> Konstruktor</dd> +</dl> + +<h2 id="Methods" name="Methods">Methoden</h2> + +<p>Das globale Objekt <code>Boolean</code> enthält zwar keine eigenen Methoden, erbt jedoch einige seiner Methoden durch die Prototypenkette:</p> + +<h2 id="Boolean_instances" name="Boolean_instances"><code>Boolean</code> Instanzen</h2> + +<p>Alle Instanzen von <code>Boolean</code> erben von {{jsxref("Boolean.prototype")}}. Wie bei allen Konstruktoren diktiert das Prototyp-Objekt die geerbten Eigenschaften und Methoden der Child-Elemente.</p> + +<h3 id="Eigenschaften">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methoden">Methoden</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Methoden')}}</div> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Creating_Boolean_objects_with_an_initial_value_of_false" name="Example:_Creating_Boolean_objects_with_an_initial_value_of_false">Erstellung eines <code>Boolean</code> Objektes mit dem Anfangswert <code>false</code></h3> + +<pre class="brush: js">var bNoParam = new Boolean(); +var bZero = new Boolean(0); +var bNull = new Boolean(null); +var bEmptyString = new Boolean(''); +var bfalse = new Boolean(false); +</pre> + +<h3 id="Example:_Creating_Boolean_objects_with_an_initial_value_of_true" name="Example:_Creating_Boolean_objects_with_an_initial_value_of_true">Erstellung eines <code>Boolean</code> Objektes mit dem Anfangswert <code>true</code></h3> + +<pre class="brush: js">var btrue = new Boolean(true); +var btrueString = new Boolean('true'); +var bfalseString = new Boolean('false'); +var bSuLin = new Boolean('Su Lin'); +var bArrayProto = new Boolean([]); +var bObjProto = new Boolean({}); +</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>Ursprüngliche Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6', 'Boolean')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean-objects', 'Boolean')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-boolean-objects', 'Boolean')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Boolean")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Boolean.prototype")}}</li> + <li>{{Glossary("Boolean")}}</li> + <li><a href="https://de.wikipedia.org/wiki/Boolesche_Variable">Boolesche Variablen (Wikipedia)</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/boolean/prototype/index.html b/files/de/web/javascript/reference/global_objects/boolean/prototype/index.html new file mode 100644 index 0000000000..2a6dda6de7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/boolean/prototype/index.html @@ -0,0 +1,83 @@ +--- +title: Boolean.prototype +slug: Web/JavaScript/Reference/Global_Objects/Boolean/prototype +tags: + - Boolean + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +--- +<div>{{JSRef}}</div> + +<div>Die <strong><code>Boolean.prototype</code></strong> Eigenschaft repräsentiert den Prototypen des {{jsxref("Boolean")}} Konstruktors.</div> + +<div> </div> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<div>{{EmbedInteractiveExample("pages/js/boolean-constructor.html")}}</div> + + + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("Boolean")}} Instanzen ergen von from <code>Boolean.prototype</code>. Man kann das prototype Objekt benutzen, um Eigenschaften und Methoden zu allen {{jsxref("Boolean")}} Instanzen hinzuzufügen.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Boolean.prototype.constructor</code></dt> + <dd>Gibt die Funktion, die einen Instanz des Prototypen erstellt zurück. Im Standardfall ist das die Funktion {{jsxref("Boolean")}}.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Gibt den Quelltext des {{jsxref("Boolean")}} Objektes als String zurück. Man kann diesen String benutzen um ein gleiches Objekt zu erstellen. Diese Methode überschreibt die {{jsxref("Object.prototype.toSource()")}} Methode.</dd> + <dt>{{jsxref("Boolean.prototype.toString()")}}</dt> + <dd>Gibt einen String <code>"true"</code> oder <code>"false"</code> zurück, abhängig vom Wert des Objektes. Diese Methode überschreibt die {{jsxref("Object.prototype.toString()")}} Methode.</dd> + <dt>{{jsxref("Boolean.prototype.valueOf()")}}</dt> + <dd>Gibt einen primitiven Wert des {{jsxref("Boolean")}} Objektes zurück. Diese Methode ü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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6.3.1', 'Boolean.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean.prototype', 'Boolean.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-boolean.prototype', 'Boolean.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Boolean.prototype")}}</p> +</div> diff --git a/files/de/web/javascript/reference/global_objects/boolean/tosource/index.html b/files/de/web/javascript/reference/global_objects/boolean/tosource/index.html new file mode 100644 index 0000000000..b37e4c226f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/boolean/tosource/index.html @@ -0,0 +1,60 @@ +--- +title: Boolean.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Boolean/toSource +tags: + - Boolean + - JavaScript + - Method + - Non-standard + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<div>Die <code><strong>toSource()</strong></code> Methode gibt einen String mit dem Quelltext des Objektes zurück.</div> + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>booleanObj</var>.toSource() +Boolean.toSource()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine String-Repräsentation des Quelltextes des Objektes.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toSource</code> gibt folgende Werte zurück:</p> + +<ul> + <li>Für das eingebaute {{jsxref("Boolean")}} Objekt gibt die <code>toSource</code> folgenden String zurück, um anzuzeigen, dass der Qeulltext nicht verfügbar ist: + + <pre class="brush: js">function Boolean() { + [native code] +} +</pre> + </li> + <li>Für Instanzen von {{jsxref("Boolean")}} gibt die <code>toSource</code> Methode einen String, der den Quelltext wiederspiegelt, zurück.</li> +</ul> + +<p>Die Methode wird intern von JavaScript aufgerufen und wird normalerweise nicht in Applikationen eingesetzt.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>In keinem Standard enthalten. Implementiert in JavaScript 1.3.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Boolean.toSource")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/boolean/tostring/index.html b/files/de/web/javascript/reference/global_objects/boolean/tostring/index.html new file mode 100644 index 0000000000..0732aec15a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/boolean/tostring/index.html @@ -0,0 +1,89 @@ +--- +title: Boolean.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Boolean/toString +tags: + - Boolean + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toString +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>toString()</strong></code> gibt einen String, der eine {{jsxref("Boolean")}} Objekt repräsentiert, zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/boolean-tostring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>bool</var>.toString()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine String-Repräsentation des {{jsxref("Boolean")}} Objektes.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das {{jsxref("Boolean")}} Objekt überschreibt die <code>toString</code> Methode des {{jsxref("Object")}} Objektes. Es erbt nicht von {{jsxref("Object.prototype.toString()")}}. Für {{jsxref("Boolean")}} Objekte gibt die <code>toString</code> Methode einen String, der das Objekt repräsentiert, zurück.</p> + +<p>JavaScript ruft die <code>toString</code> Methode automatisch auf, wenn ein {{jsxref("Boolean")}} Objekt als Text dargestellt wird oder wenn ein {{jsxref("Boolean")}} mit einem String konkatiniert wird.</p> + +<p>Für {{jsxref("Boolean")}} Objekte und Werte gibt die eingebaute <code>toString</code> Methode die Strings "<code>true</code>" oder "<code>false</code>", abhängig vom Wert des Boolean, zurück.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toString">Einsatz von <code>toString</code></h3> + +<p>Im folgenden Beispiel gibt der Aufruf <code>flag.toString()</code> den Wert "<code>true</code>" zurück:</p> + +<pre class="brush: js">var flag = new Boolean(true); +var myVar = flag.toString(); +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6.4.2', 'Boolean.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Boolean.toString")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/boolean/valueof/index.html b/files/de/web/javascript/reference/global_objects/boolean/valueof/index.html new file mode 100644 index 0000000000..3d21502589 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/boolean/valueof/index.html @@ -0,0 +1,85 @@ +--- +title: Boolean.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf +tags: + - Boolean + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>valueOf()</strong></code> Methode gibt einen primitiven Wert des {{jsxref("Boolean")}} Objektes zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/boolean-valueof.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>bool</var>.valueOf()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den primitiven Wert des gegebenen {{jsxref("Boolean")}} Objektes.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>valueOf</code> Methode des {{jsxref("Boolean")}} Objektes gibt einen primitiven Wert eines {{jsxref("Boolean")}} Objekts oder {{jsxref("Boolean")}} Literals als Boolean Datentyp zurück.</p> + +<p>Diese Methode wird intern von JavaScript aufgerufen und wird nicht in normalen Anwendungen benutzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_valueOf">Einsatz von <code>valueOf</code></h3> + +<pre class="brush: js">x = new Boolean(); +myVar = x.valueOf(); // weist myVar false zu +</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.6.4.3', 'Boolean.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean.prototype.valueof', 'Boolean.prototype.valueOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-boolean.prototype.valueof', 'Boolean.prototype.valueOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Boolean.valueOf")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/buffer/index.html b/files/de/web/javascript/reference/global_objects/dataview/buffer/index.html new file mode 100644 index 0000000000..5cb68fd75b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/buffer/index.html @@ -0,0 +1,71 @@ +--- +title: DataView.prototype.buffer +slug: Web/JavaScript/Reference/Global_Objects/DataView/buffer +tags: + - DataView + - JavaScript + - Property + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/buffer +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>buffer</code></strong> Zugriffseigenschaft repräsentiert und referenziert den {{jsxref("ArrayBuffer")}} oder {{jsxref("SharedArrayBuffer")}}, der bei der Erstellung der <code>DataView</code> übergeben wurde.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-buffer.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.buffer</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>buffer</code> Eigenschaft ist eine Zugriffseigenschaft, bei der die Funktion für das erneute Beschreibeiben <code>undefined</code> ist. Das bedeutet, dass die Eigenschaft nur gelesen werden kann. Der Wert wird bei der Erstellung der <code>DataView</code> festgelegt und kann nicht mehr geändert werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_buffer_Eigenschaft">Einsatz der <code>buffer</code> Eigenschaft</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.buffer; // ArrayBuffer { byteLength: 8 } +</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-get-dataview.prototype.buffer', 'DataView.prototype.buffer')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-dataview.prototype.buffer', 'DataView.prototype.buffer')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.buffer")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/bytelength/index.html b/files/de/web/javascript/reference/global_objects/dataview/bytelength/index.html new file mode 100644 index 0000000000..dd20867f50 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/bytelength/index.html @@ -0,0 +1,77 @@ +--- +title: DataView.prototype.byteLength +slug: Web/JavaScript/Reference/Global_Objects/DataView/byteLength +tags: + - DataView + - JavaScript + - Property + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/byteLength +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>byteLength</code></strong> Zugriffseigenschaft repräsentiert die Länge (in Bytes) der View vom Anfang ihres {{jsxref("ArrayBuffer")}} oder {{jsxref("SharedArrayBuffer")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-bytelength.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.byteLength</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>byteLength</code> Eigenschaft ist eine Zugriffseigenschaft, bei der die set Funktion <code>undefined</code> ist. Das bedeutet, dass diese Eigenschaften nur gelesen werden kann. Der Wert der Eigenschaft wird beim erstellen einer <code>DataView</code> bekannt gemacht und kann nicht mehr verändert werden. Wenn beim erstellen kein Offset oder keine <code>byteLength</code> angegeben sind, wird der <code>byteLength</code> Wert des übergebenen <code>ArrayBuffer</code> oder <code>SharedArrayBuffer</code> zurückgegeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_byteLength_Eigenschaft">Einsatz der <code>byteLength</code> Eigenschaft</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.byteLength; // 8 (gleich mit byteLength von buffer) + +var dataview2 = new DataView(buffer, 1, 5); +dataview2.byteLength; // 5 (wie beim erstellen der DataView spezifiziert) + +var dataview3 = new DataView(buffer, 2); +dataview3.byteLength; // 6 (passend mit dem Offset beim erstellen der DataView) +</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-get-dataview.prototype.bytelength', 'DataView.prototype.byteLength')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-dataview.prototype.bytelength', 'DataView.prototype.byteLength')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.byteLength")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/byteoffset/index.html b/files/de/web/javascript/reference/global_objects/dataview/byteoffset/index.html new file mode 100644 index 0000000000..b6889271ba --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/byteoffset/index.html @@ -0,0 +1,74 @@ +--- +title: DataView.prototype.byteOffset +slug: Web/JavaScript/Reference/Global_Objects/DataView/byteOffset +tags: + - DataView + - JavaScript + - Property + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/byteOffset +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>byteOffset</code></strong> Zugriffseigenschaft repräsentiert das Offset (in Bytes) der View vom Anfang ihres {{jsxref("ArrayBuffer")}} oder {{jsxref("SharedArrayBuffer")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-byteoffset.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.byteOffset</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>byteOffset</code> Eigenschaft ist eine Zugriffseigenschaft, bei der die set Funktion <code>undefined</code> ist. Das bedeutet, dass diese Eigenschaften nur gelesen werden kann. Der Wert der Eigenschaft wird beim erstellen einer <code>DataView</code> bekannt gemacht und kann nicht mehr verändert werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_byteOffset_Eigenschaft">Einsatz der <code>byteOffset</code> Eigenschaft</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.byteOffset; // 0 (no offset specified) + +var dataview2 = new DataView(buffer, 3); +dataview2.byteOffset; // 3 (as specified when constructing the DataView) +</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-get-dataview.prototype.byteoffset', 'DataView.prototype.byteOffset')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-dataview.prototype.byteoffset', 'DataView.prototype.byteOffset')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.byteOffset")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/getfloat32/index.html b/files/de/web/javascript/reference/global_objects/dataview/getfloat32/index.html new file mode 100644 index 0000000000..b8d8fe0986 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/getfloat32/index.html @@ -0,0 +1,95 @@ +--- +title: DataView.prototype.getFloat32() +slug: Web/JavaScript/Reference/Global_Objects/DataView/getFloat32 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getFloat32 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getFloat32()</code></strong> Methode gibt eine 32-Bit Gleitkommazahl mit Vorzeichen (Float) vom spezifizierten Offset der {{jsxref("DataView")}} zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-getfloat32.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.getFloat32(byteOffset [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gelesen werden sollen.</dd> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 32 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine 32-Bit Gleitkommazahl mit Vorzeichen.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View gelesen werden müsste.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span id="result_box" lang="de"><span>Es gibt keine</span> <span>Einschränkung</span> <span>Orientierung.</span> Werte mit mehrere Bytes<span> können</span> mit<span> jedem Offset abgerufen werden</span><span>.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_getFloat32_Methode">Einsatz der <code>getFloat32</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.getFloat32(1); // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.getfloat32', 'DataView.prototype.getFloat32')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getfloat32', 'DataView.prototype.getFloat32')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.getFloat32")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/getfloat64/index.html b/files/de/web/javascript/reference/global_objects/dataview/getfloat64/index.html new file mode 100644 index 0000000000..7537520965 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/getfloat64/index.html @@ -0,0 +1,95 @@ +--- +title: DataView.prototype.getFloat64() +slug: Web/JavaScript/Reference/Global_Objects/DataView/getFloat64 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getFloat64 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getFloat64()</code></strong> Methode gibt eine 64-Bit Gleitkommazahl mit Vorzeichen (Double) vom spezifizierten Offset der {{jsxref("DataView")}} zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-getfloat64.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.getFloat64(byteOffset [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gelesen werden sollen.</dd> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 64 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine 64-Bit Gleitkommazahl mit Vorzeichen.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View gelesen werden müsste.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span id="result_box" lang="de"><span>Es gibt keine</span> <span>Einschränkung</span> <span>Orientierung.</span> Werte mit mehrere Bytes<span> können</span> mit<span> jedem Offset abgerufen werden</span><span>.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_getFloat64_Methode">Einsatz der <code>getFloat64</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.getFloat64(0); // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.getfloat64', 'DataView.prototype.getFloat64')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getfloat64', 'DataView.prototype.getFloat64')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.getFloat64")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/getint16/index.html b/files/de/web/javascript/reference/global_objects/dataview/getint16/index.html new file mode 100644 index 0000000000..9223ab4dae --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/getint16/index.html @@ -0,0 +1,95 @@ +--- +title: DataView.prototype.getInt16() +slug: Web/JavaScript/Reference/Global_Objects/DataView/getInt16 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getInt16 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getInt16()</code></strong> Methode gibt eine ganze 16-Bit Zahl mit Vorzeichen (Short) vom spezifizierten Offset der {{jsxref("DataView")}} zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-getint16.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.getInt16(byteOffset [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gelesen werden sollen.</dd> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 16 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegeben ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze 16-Bit Zahl mit Vorzeichen.</p> + +<h3 id="Auftretende_Errors">Auftretende Errors</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View gelesen werden müsste.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span id="result_box" lang="de"><span>Es gibt keine</span> <span>Einschränkung</span> <span>Orientierung.</span> Werte mit mehrere Bytes<span> können</span> mit<span> jedem Offset abgerufen werden</span><span>.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_getInt16_Methode">Einsatz der <code>getInt16</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.getInt16(1); // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.getint16', 'DataView.prototype.getInt16')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getint16', 'DataView.prototype.getInt16')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.getInt16")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/getint32/index.html b/files/de/web/javascript/reference/global_objects/dataview/getint32/index.html new file mode 100644 index 0000000000..8e6bd22603 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/getint32/index.html @@ -0,0 +1,95 @@ +--- +title: DataView.prototype.getInt32() +slug: Web/JavaScript/Reference/Global_Objects/DataView/getInt32 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getInt32 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getInt32()</code></strong> Methode gibt eine ganze 32-Bit Zahl mit Vorzeichen (Long) vom spezifizierten Offset der {{jsxref("DataView")}} zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-getint32.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.getInt32(byteOffset [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gelesen werden sollen.</dd> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 32 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze 32-Bit Zahl mit Vorzeichen</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View gelesen werden müsste.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span id="result_box" lang="de"><span>Es gibt keine</span> <span>Einschränkung</span> <span>Orientierung.</span> Werte mit mehrere Bytes<span> können</span> mit<span> jedem Offset abgerufen werden</span><span>.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_getInt32_Methode">Einsatz der <code>getInt32</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.getInt32(1); // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.getint32', 'DataView.prototype.getInt32')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getint32', 'DataView.prototype.getInt32')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.getInt32")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/getint8/index.html b/files/de/web/javascript/reference/global_objects/dataview/getint8/index.html new file mode 100644 index 0000000000..cc550d3f86 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/getint8/index.html @@ -0,0 +1,93 @@ +--- +title: DataView.prototype.getInt8() +slug: Web/JavaScript/Reference/Global_Objects/DataView/getInt8 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getInt8 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getInt8()</code></strong> Methode gibt eine ganze 8-Bit Zahl mit Vorzeichen (Byte) vom spezifizierten Offset der {{jsxref("DataView")}} zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-getint8.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.getInt8(byteOffset)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gelesen werden sollen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze 8-Bit Zahl mit Vorzeichen</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View gelesen werden müsste.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span id="result_box" lang="de"><span>Es gibt keine</span> <span>Einschränkung</span> <span>Orientierung.</span> Werte mit mehrere Bytes<span> können</span> mit<span> jedem Offset abgerufen werden</span><span>.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_getInt8_Methode">Einsatz der <code>getInt8</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.getInt8(1); // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.getint8', 'DataView.prototype.getInt8')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getint8', 'DataView.prototype.getInt8')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.getInt8")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/getuint16/index.html b/files/de/web/javascript/reference/global_objects/dataview/getuint16/index.html new file mode 100644 index 0000000000..df82d10a69 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/getuint16/index.html @@ -0,0 +1,98 @@ +--- +title: DataView.prototype.getUint16() +slug: Web/JavaScript/Reference/Global_Objects/DataView/getUint16 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getUint16 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUint16()</code></strong> Methode gibt eine ganze vorzeichenlose 8-Bit Zahl (Unsigned Byte) vom spezifizierten Offset der {{jsxref("DataView")}} zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-getuint16.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.getUint16(byteOffset [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gelesen werden sollen.</dd> +</dl> + +<dl> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 16 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine vorzeichenlose ganze 16-Bit Zahl.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View gelesen werden müsste.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span id="result_box" lang="de"><span>Es gibt keine</span> <span>Einschränkung</span> <span>Orientierung.</span> Werte mit mehrere Bytes<span> können</span> mit<span> jedem Offset abgerufen werden</span><span>.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_getUint16_Methode">Einsatz der <code>getUint16</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.getUint16(1); // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.getuint16', 'DataView.prototype.getUint16')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getuint16', 'DataView.prototype.getUint16')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.getUint16")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/getuint32/index.html b/files/de/web/javascript/reference/global_objects/dataview/getuint32/index.html new file mode 100644 index 0000000000..b51d1d4d27 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/getuint32/index.html @@ -0,0 +1,98 @@ +--- +title: DataView.prototype.getUint32() +slug: Web/JavaScript/Reference/Global_Objects/DataView/getUint32 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getUint32 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUint32()</code></strong> Methode gibt eine ganze vorzeichenlose 8-Bit Zahl (Unsigned Byte) vom spezifizierten Offset der {{jsxref("DataView")}} zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-getuint32.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.getUint32(byteOffset [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gelesen werden sollen.</dd> +</dl> + +<dl> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 32 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine vorzeichenlose ganze 32-Bit Zahl.</p> + +<h3 id="Auftretende_Errors">Auftretende Errors</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View gelesen werden müsste.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span id="result_box" lang="de"><span>Es gibt keine</span> <span>Einschränkung</span> <span>Orientierung.</span> Werte mit mehrere Bytes<span> können</span> mit<span> jedem Offset abgerufen werden</span><span>.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_getUint32_Methode">Einsatz der <code>getUint32</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.getUint32(1); // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.getuint32', 'DataView.prototype.getUint32')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getuint32', 'DataView.prototype.getUint32')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.getUint32")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/getuint8/index.html b/files/de/web/javascript/reference/global_objects/dataview/getuint8/index.html new file mode 100644 index 0000000000..568930978a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/getuint8/index.html @@ -0,0 +1,95 @@ +--- +title: DataView.prototype.getUint8() +slug: Web/JavaScript/Reference/Global_Objects/DataView/getUint8 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getUint8 +--- +<div>{{JSRef}}</div> + +<div>Die <strong><code>getUint8()</code></strong> Methode gibt eine ganze vorzeichenlose 8-Bit Zahl (Unsigned Byte) vom spezifizierten Offset der {{jsxref("DataView")}} zurück.</div> + +<div>{{EmbedInteractiveExample("pages/js/dataview-getuint8.html")}}</div> + + + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.getUint8(byteOffset)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gelesen werden sollen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine vorzeichenlose ganze 8-Bit Zahl</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View gelesen werden müsste.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span id="result_box" lang="de"><span>Es gibt keine</span> <span>Einschränkung</span> <span>Orientierung.</span> Werte mit mehrere Bytes<span> können</span> mit<span> jedem Offset abgerufen werden</span><span>.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_getUint8_Methode">Einsatz der <code>getUint8</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.getUint8(1); // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.getuint8', 'DataView.prototype.getUint8')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.getuint8', 'DataView.prototype.getUint8')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.getUint8")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/index.html b/files/de/web/javascript/reference/global_objects/dataview/index.html new file mode 100644 index 0000000000..1384eafe34 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/index.html @@ -0,0 +1,127 @@ +--- +title: DataView +slug: Web/JavaScript/Reference/Global_Objects/DataView +tags: + - Constructor + - DataView + - JavaScript + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>DataView</code></strong> Ansicht unterstützt eine Low-Level Schnittstelle für das Lesen und Schreiben von mehrere Zahlentypen in einem {{jsxref("ArrayBuffer")}}. Diese Ansicht ist unabhängig von den Plattform Byte-Reihenfolgen.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-constructor.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new DataView(buffer [, byteOffset [, byteLength]])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>buffer</code></dt> + <dd>Ein existierender {{jsxref("ArrayBuffer")}} oder {{jsxref("SharedArrayBuffer")}} {{experimental_inline}}, welche als Speicher für das neue <code>DataView</code> Objekt dient.</dd> + <dt><code>byteOffset</code> {{optional_inline}}</dt> + <dd>Das Offset in Bytes, welches auf das erste Byte in dem spezifizierten Buffer für die neue Ansicht referenziert. Wenn dieser Parameter nicht angegeben ist, wird das erste Byte des Buffers als Startpunkt benutzt.</dd> + <dt><code>byteLength</code> {{optional_inline}}</dt> + <dd>Die Anzahl der Elemente in dem Byte Array. Wenn es nicht angegeben wird, wird die Länge des Buffers benutzt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues <code>DataView</code> Objekt welches den spezifizierten Datenpuffer (Buffer) repräsentiert.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt><code>{{jsxref("RangeError")}}</code></dt> + <dd>Wird erzeugt, wenn <code>byteOffset</code> oder <code>byteLength</code> Größe als der Puffer (Buffers) sind</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<h3 id="Byte-Reihenfolge">Byte-Reihenfolge</h3> + +<p>Zahlenformate mit mehreren Bytes werden im Speicher verschieden dargestellt, je nachdem welche Maschinenarchitektur genutzt wird (siehe {{Glossary("Endianness")}} für weitere Erklärungen). DataView bietet explizit die Kontrolle über den Zugriff auf die Zahlen unabhängig von der Plattformarchitektur-Byte-Reihenfolge.</p> + +<pre class="brush: js">var littleEndian = (function() { + var buffer = new ArrayBuffer(2); + new DataView(buffer).setInt16(0, 256, true /* littleEndian */); + // Int16Array benutzt die Plattform Byte-Reihenfolge. + return new Int16Array(buffer)[0] === 256; +})(); +console.log(littleEndian); // true oder false +</pre> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<p>Alle <code>DataView</code> Instanzen erben von {{jsxref("DataView.prototype")}} und erlauben das Hinzufügen von Eigenschaften zu allen DataView Objekten</p> + +<p>{{page('de/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Eigenschaften')}}</p> + +<h2 id="Methoden">Methoden</h2> + +<p>{{page('de/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Methoden')}}</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var buffer = new ArrayBuffer(16); +var dv = new DataView(buffer, 0); + +dv.setInt16(1, 42); +dv.getInt16(1); //42 +</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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Abgelöst von ECMAScript 6</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition in einem ECMA Standard</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview-constructor', 'DataView')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView")}}</p> + +<h2 id="Bemerkungen_zur_Kompatibilität">Bemerkungen zur Kompatibilität</h2> + +<p>Mit dem Start von Firefox 40 wird der {{jsxref("Operators/new", "new")}} Operator benötigt um eine <code>DataView</code> zu erstellen. Der Aufruf von <code>DataView()</code> als Funktion ohne <code>new</code> erzeugt jetzt einen {{jsxref("TypeError")}}.</p> + +<pre class="brush: js example-bad">var dv = DataView(buffer, 0); +// TypeError: Das Aufrufen des DataView-Konstruktors ohne new ist verboten</pre> + +<pre class="brush: js example-good">var dv = new DataView(buffer, 0);</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a class="link-https" href="https://github.com/jDataView/jDataView">jDataView</a>: JavaScript-Bibliothek welche Polyfills und Erweiterungen für die <code>DataView</code> API in allen Browdern und Node.js zur verfügung stellt.</li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/prototype/index.html b/files/de/web/javascript/reference/global_objects/dataview/prototype/index.html new file mode 100644 index 0000000000..ea91eb795f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/prototype/index.html @@ -0,0 +1,109 @@ +--- +title: DataView.prototype +slug: Web/JavaScript/Reference/Global_Objects/DataView/prototype +tags: + - DataView + - JavaScript + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/DataView +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>DataView</strong></code><strong><code>.prototype</code></strong> Eigenschaft repräsentiert den Prototypen für das {{jsxref("DataView")}} Objekt.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>DataView</code> Instanzen erben von <code>DataView.prototype</code>. Wie bei allen Konstruktoren, können Änderungen am Prototypen Änderungen in allen <code>DataView</code> Instanzen zur folge haben.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>DataView.prototype.constructor</code></dt> + <dd>Spezifiziert die Funktion, die ein Objekt des Prototypen erstellt. Der initialwert ist der Standard eingebaute <code>DataView</code> Konstruktor</dd> + <dt>{{jsxref("DataView.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Der {{jsxref("ArrayBuffer")}}, der von dieser Ansicht repräsentiert wird. Wird bei der Erstellung erzeugt und deswegen kann nur lesend darauf zugegriffen werden.</dd> + <dt>{{jsxref("DataView.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Die Länge (in Bytes) von dieser Ansicht, von Beginn des {{jsxref("ArrayBuffer")}}. Wird bei der Erstellung erzeugt und deswegen kann nur lesend darauf zugegriffen werden.</dd> + <dt>{{jsxref("DataView.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Das Offset (in Bytes) von dieser Ansicht, von Beginn des {{jsxref("ArrayBuffer")}}. Wird bei der Erstellung erzeugt und deswegen kann nur lesend darauf zugegriffen werden.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<h3 id="Lesend">Lesend</h3> + +<dl> + <dt>{{jsxref("DataView.prototype.getInt8()")}}</dt> + <dd>Gibt eine 8-Bit ganze Zahl mit Vorzeichen (byte) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.</dd> + <dt>{{jsxref("DataView.prototype.getUint8()")}}</dt> + <dd>Gibt eine 8-Bit vorzeichenlose ganze Zahl (unsigned byte) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.</dd> + <dt>{{jsxref("DataView.prototype.getInt16()")}}</dt> + <dd>Gibt eine 16-Bit ganze Zahl mit Vorzeichen (short) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.</dd> + <dt>{{jsxref("DataView.prototype.getUint16()")}}</dt> + <dd>Gibt eine 16-Bit vorzeichenlose ganze Zahl (unsigned short) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.</dd> + <dt>{{jsxref("DataView.prototype.getInt32()")}}</dt> + <dd>Gibt eine 32-Bit ganze Zahl mit Vorzeichen (long) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.</dd> + <dt>{{jsxref("DataView.prototype.getUint32()")}}</dt> + <dd>Gibt eine 32-Bit vorzeichenlose ganze Zahl (unsigned long) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.</dd> + <dt>{{jsxref("DataView.prototype.getFloat32()")}}</dt> + <dd>Gibt eine 32-Bit Gleitkommazahl mit Vorzeichen (float) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück</dd> + <dt>{{jsxref("DataView.prototype.getFloat64()")}}</dt> + <dd>Gibt eine 64-Bit Gleitkommazahl mit Vorzeichen (double) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück</dd> +</dl> + +<h3 id="Schreibend">Schreibend</h3> + +<dl> + <dt>{{jsxref("DataView.prototype.setInt8()")}}</dt> + <dd>Speichert eine ganze 8-Bit Zahl mit Vorzeichen (byte) an einem spezifizierten Offset vom Start der Ansicht.</dd> + <dt>{{jsxref("DataView.prototype.setUint8()")}}</dt> + <dd>Speichert eine ganze vorzeichenlose 8-Bit Zahl (unsigned byte) an einem spezifizierten Offset vom Start der Ansicht.</dd> + <dt>{{jsxref("DataView.prototype.setInt16()")}}</dt> + <dd>Speichert eine ganze 16-Bit Zahl mit Vorzeichen (short) an einem spezifizierten Offset vom Start der Ansicht.</dd> + <dt>{{jsxref("DataView.prototype.setUint16()")}}</dt> + <dd>Speichert eine ganze vorzeichenlose 16-Bit Zahl (unsigned short) an einem spezifizierten Offset vom Start der Ansicht.</dd> + <dt>{{jsxref("DataView.prototype.setInt32()")}}</dt> + <dd>Speichert eine ganze 32-Bit Zahl mit Vorzeichen (long) an einem spezifizierten Offset vom Start der Ansicht.</dd> + <dt>{{jsxref("DataView.prototype.setUint32()")}}</dt> + <dd>Speichert eine ganze vorzeichenlose 32-Bit Zahl (unsigned long) an einem spezifizierten Offset vom Start der Ansicht.</dd> + <dt>{{jsxref("DataView.prototype.setFloat32()")}}</dt> + <dd>Speichert eine 32-Bit Gleitkommazahl mit Vorzeichen (float) an einem spezifizierten Offset vom Start der Ansicht.</dd> + <dt>{{jsxref("DataView.prototype.setFloat64()")}}</dt> + <dd>Speichert eine 64-Bit Gleitkommazahl mit Vorzeichen (double) an einem spezifizierten Offset vom Start der Ansicht.</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('ES6', '#sec-dataview.prototype', 'DataView.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype', 'DataView.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.prototype")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/setfloat32/index.html b/files/de/web/javascript/reference/global_objects/dataview/setfloat32/index.html new file mode 100644 index 0000000000..a7728311fc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/setfloat32/index.html @@ -0,0 +1,97 @@ +--- +title: DataView.prototype.setFloat32() +slug: Web/JavaScript/Reference/Global_Objects/DataView/setFloat32 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setFloat32 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setFloat32()</code></strong> Methode speichert eine 32-Bit Gleitkommazahl mit Vorzeichen (Float) am spezifizierten Offset der {{jsxref("DataView")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-setfloat32.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.setFloat32(byteOffset, value [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gespeichert werden sollen.</dd> +</dl> + +<dl> + <dt>value</dt> + <dd>Der Wert, der gespeichert werden soll.</dd> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 32 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View geschrieben werden müsste.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_setFloat32_Methode">Einsatz der <code>setFloat32</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.setFloat32(1, 3); +dataview.getFloat32(1); // 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.setfloat32', 'DataView.prototype.setFloat32')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setfloat32', 'DataView.prototype.setFloat32')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.setFloat32")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/setfloat64/index.html b/files/de/web/javascript/reference/global_objects/dataview/setfloat64/index.html new file mode 100644 index 0000000000..8a0d9545e3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/setfloat64/index.html @@ -0,0 +1,97 @@ +--- +title: DataView.prototype.setFloat64() +slug: Web/JavaScript/Reference/Global_Objects/DataView/setFloat64 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setFloat64 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setFloat64()</code></strong> Methode speichert eine 64-Bit Gleitkommazahl mit Vorzeichen (Float) am spezifizierten Offset der {{jsxref("DataView")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-setfloat64.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.setFloat64(byteOffset, value [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gespeichert werden sollen.</dd> +</dl> + +<dl> + <dt>value</dt> + <dd>Der Wert, der gespeichert werden soll.</dd> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 64 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View geschrieben werden müsste.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_setFloat64_Methode">Einsatz der <code>setFloat64</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.setFloat64(0, 3); +dataview.getFloat64(0); // 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.setfloat64', 'DataView.prototype.setFloat64')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setfloat64', 'DataView.prototype.setFloat64')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.setFloat64")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/setint16/index.html b/files/de/web/javascript/reference/global_objects/dataview/setint16/index.html new file mode 100644 index 0000000000..acbc44f22e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/setint16/index.html @@ -0,0 +1,100 @@ +--- +title: DataView.prototype.setInt16() +slug: Web/JavaScript/Reference/Global_Objects/DataView/setInt16 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setInt16 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setInt16()</code></strong> Methode speichert eine ganze 16-Bit Zahl mit Vorzeichen (Schort) am spezifizierten Offset der {{jsxref("DataView")}} ab.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-setint16.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.setInt16(byteOffset, value [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gespeichert werden sollen.</dd> +</dl> + +<dl> + <dt>value</dt> + <dd>Der Wert, der gespeichert werden soll.</dd> +</dl> + +<dl> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 16 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h3 id="Auftretende_Errors">Auftretende Errors</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View geschrieben werden müsste.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_setInt16_Methode">Einsatz der <code>setInt16</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.setInt16(1, 3); +dataview.getInt16(1); // 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.setint16', 'DataView.prototype.setInt16')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setint16', 'DataView.prototype.setInt16')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.setInt16")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/setint32/index.html b/files/de/web/javascript/reference/global_objects/dataview/setint32/index.html new file mode 100644 index 0000000000..740fbb678d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/setint32/index.html @@ -0,0 +1,100 @@ +--- +title: DataView.prototype.setInt32() +slug: Web/JavaScript/Reference/Global_Objects/DataView/setInt32 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setInt32 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setInt32()</code></strong> Methode speichert eine ganze 32-Bit Zahl mit Vorzeichen (Long) am spezifizierten Offset der {{jsxref("DataView")}} ab.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-setint32.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.setInt32(byteOffset, value [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gespeichert werden sollen.</dd> +</dl> + +<dl> + <dt>value</dt> + <dd>Der Wert, der gespeichert werden soll.</dd> +</dl> + +<dl> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 32 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View geschrieben werden müsste.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_setInt32_Methode">Einsatz der <code>setInt32</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.setInt32(1, 3); +dataview.getInt32(1); // 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.setint32', 'DataView.prototype.setInt32')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setint32', 'DataView.prototype.setInt32')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.setInt32")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/setint8/index.html b/files/de/web/javascript/reference/global_objects/dataview/setint8/index.html new file mode 100644 index 0000000000..cdfc7b8bd5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/setint8/index.html @@ -0,0 +1,95 @@ +--- +title: DataView.prototype.setInt8() +slug: Web/JavaScript/Reference/Global_Objects/DataView/setInt8 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setInt8 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setInt8()</code></strong> Methode speichert eine ganze 8-Bit Zahl mit Vorzeichen (Byte) am spezifizierten Offset der {{jsxref("DataView")}} ab.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-setint8.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.setInt8(byteOffset, value)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gespeichert werden sollen.</dd> +</dl> + +<dl> + <dt>value</dt> + <dd>Der Wert, der gespeichert werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View geschrieben werden müsste.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_setInt8_Methode">Einsatz der <code>setInt8</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.setInt8(1, 3); +dataview.getInt8(1); // 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.setint8', 'DataView.prototype.setInt8')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setint8', 'DataView.prototype.setInt8')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.setInt8")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/setuint16/index.html b/files/de/web/javascript/reference/global_objects/dataview/setuint16/index.html new file mode 100644 index 0000000000..912407d086 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/setuint16/index.html @@ -0,0 +1,100 @@ +--- +title: DataView.prototype.setUint16() +slug: Web/JavaScript/Reference/Global_Objects/DataView/setUint16 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setUint16 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setInt16()</code></strong> Methode speichert eine ganze vorzeichenlose 16-Bit Zahl (Unsigned Short) am spezifizierten Offset der {{jsxref("DataView")}} ab.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-setuint16.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.setUint16(byteOffset, value [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gespeichert werden sollen.</dd> +</dl> + +<dl> + <dt>value</dt> + <dd>Der Wert, der gespeichert werden soll.</dd> +</dl> + +<dl> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 16 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h3 id="Auftretende_Errors">Auftretende Errors</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View geschrieben werden müsste.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_setUint16_Methode">Einsatz der <code>setUint16</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.setUint16(1, 3); +dataview.getUint16(1); // 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.setuint16', 'DataView.prototype.setUint16')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setuint16', 'DataView.prototype.setUint16')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.setUint16")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/setuint32/index.html b/files/de/web/javascript/reference/global_objects/dataview/setuint32/index.html new file mode 100644 index 0000000000..5cba529880 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/setuint32/index.html @@ -0,0 +1,100 @@ +--- +title: DataView.prototype.setUint32() +slug: Web/JavaScript/Reference/Global_Objects/DataView/setUint32 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setUint32 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setInt32()</code></strong> Methode speichert eine ganze vorzeichenlose 32-Bit Zahl (Unsigned Long) am spezifizierten Offset der {{jsxref("DataView")}} ab.</p> + +<div>{{EmbedInteractiveExample("pages/js/dataview-setuint32.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.setUint32(byteOffset, value [, littleEndian])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gespeichert werden sollen.</dd> +</dl> + +<dl> + <dt>value</dt> + <dd>Der Wert, der gespeichert werden soll.</dd> +</dl> + +<dl> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Gibt an, ob die 32 Bit Zahl als {{Glossary("Endianness", "little- oder big-Endian")}} abgespeichert wird. Wenn false oder undefined angegewen ist, wird ein big-Endian gelesen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View geschrieben werden müsste.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_setUint32_Methode">Einsatz der <code>setUint32</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.setUint32(1, 3); +dataview.getUint32(1); // 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.setuint32', 'DataView.prototype.setUint32')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setuint32', 'DataView.prototype.setUint32')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.setUint32")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/dataview/setuint8/index.html b/files/de/web/javascript/reference/global_objects/dataview/setuint8/index.html new file mode 100644 index 0000000000..dc293963a1 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/dataview/setuint8/index.html @@ -0,0 +1,95 @@ +--- +title: DataView.prototype.setUint8() +slug: Web/JavaScript/Reference/Global_Objects/DataView/setUint8 +tags: + - DataView + - JavaScript + - Method + - Prototype + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/setUint8 +--- +<div>{{JSRef}}</div> + +<div>Die <strong><code>setInt8()</code></strong> Methode speichert eine ganze vorzeichenlose 8-Bit Zahl (Unsigned Byte) am spezifizierten Offset der {{jsxref("DataView")}} ab.</div> + +<div>{{EmbedInteractiveExample("pages/js/dataview-setuint8.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dataview</var>.setUint8(byteOffset, value)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>byteOffset</dt> + <dd>Das Offset, in Bytes, vom Start der View, an dem die Daten gespeichert werden sollen.</dd> +</dl> + +<dl> + <dt>value</dt> + <dd>Der Wert, der gespeichert werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Tritt auf, wenn <code>byteOffset</code> so gesetzt ist, dass hinter dem Ende der View geschrieben werden müsste.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_setUint8_Methode">Einsatz der <code>setUint8</code> Methode</h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.setUint8(1, 3); +dataview.getUint8(1); // 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt durch ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-dataview.prototype.setuint8', 'DataView.prototype.setUint8')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA-Standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview.prototype.setuint8', 'DataView.prototype.setUint8')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.DataView.setUint8")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/@@toprimitive/index.html b/files/de/web/javascript/reference/global_objects/date/@@toprimitive/index.html new file mode 100644 index 0000000000..593369fe87 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/@@toprimitive/index.html @@ -0,0 +1,69 @@ +--- +title: 'Date.prototype[@@toPrimitive]' +slug: Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive +--- +<div>{{JSRef}}</div> + +<div>Die <code><strong>[@@toPrimitive]()</strong></code> Methode konvertiert ein {{jsxref("date")}} Objekt in einen primitiven Wert.</div> + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>Date()[Symbol.toPrimitive](hint); +</var></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der primitive Wert des gegebenen {{jsxref("Date")}} Objektes. Abhängig vom übergebenen Parameter kann die Methode einen String oder eine Zahl zurückgeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>[@@toPrimitive]()</code> ist eine Methode des {{jsxref("date")}} Objektes, welche einen primitiven Wert zurück gibt, was vom Typ number oder String sein kann.</p> + +<p>Wenn der Parameter <code>hint</code> die Wert <code>"string"</code> oder <code>"default"</code> enthält, wird versucht die {{jsxref("Object.prototype.toString()", "toString")}} Methode aufzurufen. Wenn diese Methode nicht existiert, wird versucht die {{jsxref("Object.prototype.valueOf()", "valueOf")}} Methode aufzurufen. Wenn diese wiederum nicht existiert wirft <code>[@@toPrimitive]()</code> einen {{jsxref("TypeError")}}.</p> + +<p>Wenn der Parameter <code>hint</code> den Wert <code>"number"</code> hat, wird als erstes versucht die <code>valueOf</code> Methode aufzurufen. Wenn diese nicht existiert, wird die <code>toString</code> Methode aufgerufen.</p> + +<p>JavaScript ruft die <code>[@@toPrimitive]()</code> auf, um ein Objekt in einen primitiven Wert zu konvertieren. Explizit muss man diese Methode extrem selten aufrufen. JavaScript ruft diese Methode automatisch auf, wenn ein Objekt an Stellen verwendet wird, an denen ein primitiver Wert erwartet wird.</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('ES6', '#sec-date.prototype-@@toprimitive', 'Date.prototype.@@toPrimitive')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype-@@toprimitive', 'Date.prototype.@@toPrimitive')}}</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.Date.@@toPrimitive")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Symbol.toPrimitive")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getday/index.html b/files/de/web/javascript/reference/global_objects/date/getday/index.html new file mode 100644 index 0000000000..28c185fe16 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getday/index.html @@ -0,0 +1,69 @@ +--- +title: Date.prototype.getDay() +slug: Web/JavaScript/Reference/Global_Objects/Date/getDay +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">Die <strong><code>getDay()</code></strong> Methode gibt den Tag der Woche eines Datums gemäß der Ortszeit zurück, wobei Sonntag durch den Wert 0 repräsentiert wird.</span> Für den Tag des Monats gibt es die Methode {{jsxref("Date.prototype.getDate()", "getDate()")}}</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getday.html")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getDay()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 6, die den Tag der Woche des gegebenden Datums repräsentiert: 0 für Sonntag, 1 für Montag, 2 für Dienstag und so weiter.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getDay">Einsatz von <code>getDay()</code></h3> + +<p>Im zweiten Statement wird die Variable <code>weekday</code> mit dem Wert 1 initialisiert. Dabei wird der Wert des {{jsxref("Date")}} object <code>Xmas95</code> benutzt. 25. Dezember 1995 ist ein Montag.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var weekday = Xmas95.getDay(); + +console.log(weekday); // 1 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spezifikation</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getday', 'Date.prototype.getDay')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Date.getDay")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getfullyear/index.html b/files/de/web/javascript/reference/global_objects/date/getfullyear/index.html new file mode 100644 index 0000000000..170b9cebfa --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getfullyear/index.html @@ -0,0 +1,88 @@ +--- +title: Date.prototype.getFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/getFullYear +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getFullYear()</code></strong> Methode gibt das Jahr eines Datums bezüglich der Ortszeit zurück.</p> + +<p>Diese Methode wird anstatt der {{jsxref("Date.prototype.getYear()", "getYear()")}} eingesetzt.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getfullyear.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getFullYear()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Zahl, die das Jahr des gegebenen Datums bezüglich der lokalen Zeit angibt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Der von <code>getFullYear()</code> zurückgegebene Wert ist eine absolute Zahl. Für Daten zwischen den Jahren 1000 und 9999 gibt <code>getFullYear()</code> eine vier ziffrige Nummer zurück (z. B. 1995). Diese Methode wird eingesetzt, um sicherzustellen, dass auch Jahre nach 2000 richtig zurückgegeben werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getFullYear()">Einsatz von <code>getFullYear()</code></h3> + +<p>Im folgenden Beispiel wird die Variable <code>year</code> mit dem aktuellen Jahr (4 Ziffern) initialisiert.</p> + +<pre class="brush: js">var today = new Date(); +var year = today.getFullYear(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.10', 'Date.prototype.getFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getfullyear', 'Date.prototype.getFullYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getfullyear', 'Date.prototype.getFullYear')}}</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.Date.getFullYear")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getYear()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/gethours/index.html b/files/de/web/javascript/reference/global_objects/date/gethours/index.html new file mode 100644 index 0000000000..c8036ad465 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/gethours/index.html @@ -0,0 +1,83 @@ +--- +title: Date.prototype.getHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/getHours +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getHours()</code></strong> Methode gibt die Stunde eines Datums bezüglich der Ortszeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-gethours.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getHours()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 23, welche die Stunde der gegebenen Zeit bezüglich der lokalen Zeit angibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getHours()">Einsatz von <code>getHours()</code></h3> + +<p>Im zweiten Statement wird die Variable <code>hours</code> mit dem Wert 23 initialisiert. Dieses geschied mit dem Wert des {{jsxref("Global_Objects/Date", "Date")}} Objektes <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var hours = Xmas95.getHours(); + +console.log(hours); // 23 +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.18', 'Date.prototype.getHours')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.gethours', 'Date.prototype.getHours')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.gethours', 'Date.prototype.getHours')}}</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.Date.getHours")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getmilliseconds/index.html b/files/de/web/javascript/reference/global_objects/date/getmilliseconds/index.html new file mode 100644 index 0000000000..3238d48bbc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getmilliseconds/index.html @@ -0,0 +1,81 @@ +--- +title: Date.prototype.getMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getMilliseconds()</code></strong> Methode gibt die Millisekunden eines Datums bezüglich der Ortszeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getmilliseconds.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMilliseconds()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 999, welche die Millisekunden der gegebenen Zeit bezüglich der lokalen Zeit angibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getMilliseconds()">Einsatz von <code>getMilliseconds()</code></h3> + +<p>Im folgenden Beispiel wird die Variable <code>milliseconds</code> mit den aktuellen Millisekunden initialisiert:</p> + +<pre class="brush: js">var today = new Date(); +var milliseconds = today.getMilliseconds(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.24', 'Date.prototype.getMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}</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.Date.getMilliseconds")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getminutes/index.html b/files/de/web/javascript/reference/global_objects/date/getminutes/index.html new file mode 100644 index 0000000000..ec541dc8fe --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getminutes/index.html @@ -0,0 +1,81 @@ +--- +title: Date.prototype.getMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/getMinutes +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getMinutes()</code></strong> Methode gibt die Minuten eines Datums bezüglich der Ortszeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getminutes.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMinutes()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 59, welche die Minuten der gegebenen Zeit bezüglich der lokalen Zeit angibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getMinutes()">Einsatz von <code>getMinutes()</code></h3> + +<p>Im zweiten Statement wird die Variable <code>minutes</code> mit dem Wert 15 initialisiert. Dieses wird mit dem Wert des {{jsxref("Global_Objects/Date", "Date")}} Objektes <code>Xmas95</code> erreicht.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var minutes = Xmas95.getMinutes(); + +console.log(minutes); // 15 +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.20', 'Date.prototype.getMinutes')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}</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.Date.getMinutes")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getmonth/index.html b/files/de/web/javascript/reference/global_objects/date/getmonth/index.html new file mode 100644 index 0000000000..5c5d8ceed7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getmonth/index.html @@ -0,0 +1,83 @@ +--- +title: Date.prototype.getMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/getMonth +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getMonth()</code></strong> Methode gibt den Monat eines Datums bezüglich der Ortszeit zurück. Diese Monat ist ein 0 basierter Wert (wobei 0 den ersten Monat des Jahres beschreibt).</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getmonth.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMonth()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 11, welche den Monat des gegebenen Datums bezüglich der lokalen Zeit angibt. 0 steht für Januar, 1 für Februar und so weiter.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getMonth()">Einsatz von <code>getMonth()</code></h3> + +<p>Im zweiten Statement wird der Variablen <code>month</code> der Wert 11 zugewiesen. Dieses geschiet auf Basis des {{jsxref("Date")}} Objektes <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var month = Xmas95.getMonth(); + +console.log(month); // 11 +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.12', 'Date.prototype.getMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getmonth', 'Date.prototype.getMonth')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getmonth', 'Date.prototype.getMonth')}}</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.Date.getMonth")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getseconds/index.html b/files/de/web/javascript/reference/global_objects/date/getseconds/index.html new file mode 100644 index 0000000000..1cd8514b1b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getseconds/index.html @@ -0,0 +1,83 @@ +--- +title: Date.prototype.getSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getSeconds +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getSeconds()</code></strong> Methode gibt die Sekunden eines Datums (Zeit) bezüglich der Ortszeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getseconds.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getSeconds()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 59, welche die Sekunden der gegebenen Zeit bezüglich der lokalen Zeit angibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getSeconds()">Einsatz von <code>getSeconds()</code></h3> + +<p>Im zweiten Statement wird der Variablen <code>seconds</code> der Wert 30 zugewiesen. Dieses geschiet auf Basis des {{jsxref("Date")}} Objektes <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var seconds = Xmas95.getSeconds(); + +console.log(seconds); // 30 +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.22', 'Date.prototype.getSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}</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.Date.getSeconds")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/gettime/index.html b/files/de/web/javascript/reference/global_objects/date/gettime/index.html new file mode 100644 index 0000000000..8c6eb521e1 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/gettime/index.html @@ -0,0 +1,126 @@ +--- +title: Date.prototype.getTime() +slug: Web/JavaScript/Reference/Global_Objects/Date/getTime +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getTime()</code></strong> Methode gibt einen nummerischen Wert zurück, der die Zeit gemäß der Weltzeit (UTC) angibt.</p> + +<p><em>getTime() nutzt immer die UTC für die Zeitrepräsentation. Zum Beispiel ist der Aufruf von getTime() in einer Zeitzone der gleiche Wert wie in einer anderen Zone.</em></p> + +<p>Man kann diese Methode einsetzten, um ein anderes {{jsxref("Date")}} Objekt zu initialisieren. Diese Methode hat den gleichen Funktionsumfang wie die {{jsxref("Date.valueof", "valueOf()")}} Methode.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-gettime.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTime()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem gegebenen Zeitpunkt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getTime()_für_das_Kopieren_von_Daten">Einsatz von <code>getTime()</code> für das Kopieren von Daten</h3> + +<p>Erstellen eines {{jsxref("Date")}} Objektes mit identischem Zeitwert.</p> + +<pre class="brush: js">// Seit der Monat 0-basiert ist, ist birthday der 10. Januar 1995 +var birthday = new Date(1994, 12, 10); +var copy = new Date(); +copy.setTime(birthday.getTime()); +</pre> + +<h3 id="Ausführzeit_Messen">Ausführzeit Messen</h3> + +<p>Das Subtrahieren zweier <code>getTime()</code> Aufrufe auf {{jsxref("Date")}} Objekten, ergibt die Zeitspanne zwischen den beiden Aufrufen. Das kann eingesetzt werden, um die Ausführungszeit von Operationen zu berechnen. Auch die {{jsxref("Date.now()")}} Methode kann eingesetzt werden, um unnötiges Instanziieren von {{jsxref("Date")}} Objekten zu vermeiden.</p> + +<pre class="brush: js">var end, start; + +start = new Date(); +for (var i = 0; i < 1000; i++) { + Math.sqrt(i); +} +end = new Date(); + +console.log('Operation took ' + (end.getTime() - start.getTime()) + ' msec'); +</pre> + +<h2 id="Reduzierte_Zeitpräzision">Reduzierte Zeitpräzision</h2> + +<p>Um den Schutz vor Timing-Angriffen und Fingerabdrücken zu gewährleisten, kann die Genauigkeit von <code>new Date().GetTime()</code> abhängig von den Browsereinstellungen abgerundet werden.<br> + <span>In Firefox ist die <code>privacy.resistFingerprinting</code> Einstellung normalerweise eingeschaltet auf 20 us in Firefox 59; in 60 wird es 2 ms sein.</span></p> + +<pre class="brush: js" id="ct-107">// reduced time precision disabled +new Date().getTime(); +// 1519129755973 +// 1519129769481 +// 1519129808126 +// ... + + +// reduced time precision enabled +new Date().getTime(); +// 1519129853500 +// 1519129858900 +// 1519129864400 +// ... +</pre> + +<p>In Firefox kann man zudem die Eigenschaft <code>privacy.resistFingerprinting</code> einschalten, die Präzision wird 100 ms sein oder man benutzt den Wert <code>privacy.resistFingerprinting.reduceTimerPrecision.microseconds</code>, wenn der Wert größer sein soll.</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>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.9', 'Date.prototype.getTime')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}</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.Date.getTime")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.setTime()")}}</li> + <li>{{jsxref("Date.prototype.valueOf()")}}</li> + <li>{{jsxref("Date.now()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html b/files/de/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html new file mode 100644 index 0000000000..6d7cbb8442 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html @@ -0,0 +1,102 @@ +--- +title: Date.prototype.getTimezoneOffset() +slug: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getTimezoneOffset()</code></strong> Methode gibt den Unterschied zwischen der aktuellen Ortszeit (Einstellungen des Hostsystems) und der Weltzeit (UTC) in Minuten zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-gettimezoneoffset.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTimezoneOffset()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Zahl, welche den Unterschied zwischen der aktuellen Ortszeit (Einstellung des Hostsystems) und der UTC in Minuten repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Der Zeitzonen-Offset ist der Unterschied, in Minuten, zwischen der lokalen Zeit und der Weltzeit (UTC). Das bedeutet, dass die Anzahl der Minuten eine positive Zahl ist, wenn die lokale Zeit hinterher geht, und eine negative Zahl ist, wenn die lokale Zeit voraus geht. Zum Beispiel gibt die Methode für die Zeitzone UTC+10 (Ost Australische Standardzeit) -600 zurück.</p> + +<table class="standard-table"> + <tbody> + <tr> + <td>Aktuelle Zeitzone</td> + <td>UTC-8</td> + <td>UTC</td> + <td>UTC+3</td> + </tr> + <tr> + <td>Rückgabewert</td> + <td>480</td> + <td>0</td> + <td>-180</td> + </tr> + </tbody> +</table> + +<p>Das zurückgegebene Zeitzonen-Offset ist immer das zu dem Date-Objekt zugehörige Offset. <span id="result_box" lang="de"><span>Wenn das Hostsystem für die Sommerzeit konfiguriert ist, ändert sich das Offset je nach Datum und Uhrzeit des Datums und der Sommerzeit.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getTimezoneOffset()">Einsatz von <code>getTimezoneOffset()</code></h3> + +<pre class="brush: js">// Gibt das aktuelle Zeitzonen-Offset für das Hostsystem zurück. +var x = new Date(); +var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60; +// 1 + +// Gibt das Zeitzonen Offset des Internationalen Tag der Arbeit (1. Mai) in 2016 zurück. +// Vorsicht beim Einsatz des Date() Konstruktors, denn dieser Benutzt den 0-indizierten Monat +// so dass Mai durch 4 (und nicht durch 5) repräsentiert wird. +var labourDay = new Date(2016, 4, 1); +var labourDayOffset = labourDay.getTimezoneOffset() / 60;</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.26', 'Date.prototype.getTimezoneOffset')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.gettimezoneoffset', 'Date.prototype.getTimezoneOffset')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.gettimezoneoffset', 'Date.prototype.getTimezoneOffset')}}</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.Date.getTimezoneOffset")}}</p> diff --git a/files/de/web/javascript/reference/global_objects/date/getutcdate/index.html b/files/de/web/javascript/reference/global_objects/date/getutcdate/index.html new file mode 100644 index 0000000000..4d85c3b3b8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getutcdate/index.html @@ -0,0 +1,80 @@ +--- +title: Date.prototype.getUTCDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUTCDate()</code></strong> Methode gibt den Tag des Monats eines Datums bezüglich der Weltzeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcdate.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDate()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 1 und 31, die den Tag des Monats des gegebenen Datums bezüglich der Weltzeit (UTC) angibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getUTCDate()">Einsatz von <code>getUTCDate()</code></h3> + +<p>Das folgende Beispiel weißt der Variablen <code>day</code> den Tag des aktullen Datums zu.</p> + +<pre class="brush: js">var today = new Date(); +var day = today.getUTCDate(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.15', 'Date.prototype.getUTCDate')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}</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.Date.getUTCDate")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getutcday/index.html b/files/de/web/javascript/reference/global_objects/date/getutcday/index.html new file mode 100644 index 0000000000..445e09aae3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getutcday/index.html @@ -0,0 +1,82 @@ +--- +title: Date.prototype.getUTCDay() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUTCDay()</code></strong> Methode gibt den Wochentag eines Datums bezüglich der Weltzeit zurück. 0 steht für Sonntag.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcday.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDay()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl, die einen Wochentag des gegebenen Datums bezüglich der Weltzeit (UTC) repräsentiert. 0 steht für Sonntag, 1 für Montag, 2 für Dienstag und so weiter.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getUTCDay()">Einsatz von <code>getUTCDay()</code></h3> + +<p>Im folgenden Beispiel wird der aktuelle Wochentag der Variablen <code>weekday</code> zugewiesen.</p> + +<pre class="brush: js">var today = new Date(); +var weekday = today.getUTCDay(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.17', 'Date.prototype.getUTCDay')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcday', 'Date.prototype.getUTCDay')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcday', 'Date.prototype.getUTCDay')}}</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.Date.getUTCDay")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getutcfullyear/index.html b/files/de/web/javascript/reference/global_objects/date/getutcfullyear/index.html new file mode 100644 index 0000000000..0c273c4af9 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getutcfullyear/index.html @@ -0,0 +1,85 @@ +--- +title: Date.prototype.getUTCFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUTCFullYear()</code></strong> Methode gibt das Jahr eines Datums bezüglich der Weltzeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcfullyear.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCFullYear()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Zahl, die das Jahr des gegebenen Datums bezüglich der Weltzeit (UTC) angibt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Der von <code>getUTCFullYear()</code> zurückgegebene Wert ist eine absolute Zahl, die das Jahr (4-stellig) repräsentiert (z. B. 1995).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getUTCFullYear()">Einsatz von <code>getUTCFullYear()</code></h3> + +<p>Im folgenden Beispiel wird die Variable <code>year</code> mit dem aktuellen Jahr (4-stellig) bezüglich der Weltzeit beschrieben.</p> + +<pre class="brush: js">var today = new Date(); +var year = today.getUTCFullYear(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.11', 'Date.prototype.getUTCFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}</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.Date.getUTCFullYear")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getutchours/index.html b/files/de/web/javascript/reference/global_objects/date/getutchours/index.html new file mode 100644 index 0000000000..b11d3df06f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getutchours/index.html @@ -0,0 +1,81 @@ +--- +title: Date.prototype.getUTCHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUTCHours()</code></strong> Methode gibt die Stunden eines Datums bezüglich der Weltzeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutchours.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCHours()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 23, die die Stunde des gegebenen date Objektes bezüglich der Weltzeit (UTC) angibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getUTCHours()">Einsatz von <code>getUTCHours()</code></h3> + +<p>Im folgenden Beispiel wird der Variablen <code>hours</code> die aktuelle Stunde der Weltzeit zugewiesen.</p> + +<pre class="brush: js">var today = new Date(); +var hours = today.getUTCHours(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.19', 'Date.prototype.getUTCHours')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutchours', 'Date.prototype.getUTCHours')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutchours', 'Date.prototype.getUTCHours')}}</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.Date.getUTCHours")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html b/files/de/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html new file mode 100644 index 0000000000..d44ece54d3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html @@ -0,0 +1,79 @@ +--- +title: Date.prototype.getUTCMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUTCMilliseconds()</code></strong> Methode gibt die Millisekunden eines Datums bezüglich der Weltzeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcmilliseconds.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMilliseconds()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 999, die die Millisekunden des gegebenen date Objektes bezüglich der Weltzeit (UTC) angibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getUTCMilliseconds()">Einsatz von <code>getUTCMilliseconds()</code></h3> + +<p>Im folgenden Beispiel wird der Variablen <code>milliseconds</code> die aktuellen Millisekunden der Weltzeit zugewiesen.</p> + +<pre class="brush: js">var today = new Date(); +var milliseconds = today.getUTCMilliseconds(); +</pre> + +<h2 id="Spezifikationer">Spezifikationer</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.25', 'Date.prototype.getUTCMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}</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.Date.getUTCMilliseconds")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getutcminutes/index.html b/files/de/web/javascript/reference/global_objects/date/getutcminutes/index.html new file mode 100644 index 0000000000..e2f039b987 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getutcminutes/index.html @@ -0,0 +1,79 @@ +--- +title: Date.prototype.getUTCMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUTCMinutes()</code></strong> Methode gibt die Minuten eines Datums bezüglich der Weltzeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcminutes.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMinutes()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl wzischen 0 und 59, die die Minuten des gegebenen date Objektes bezüglich der Weltzeit (UTC) angibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getUTCMinutes()">Einsatz von <code>getUTCMinutes()</code></h3> + +<p>Im Folgenden Beispiel wird der Variablen <code>minutes</code> die aktuelle Minute der Weltzeit zugewiesen.</p> + +<pre class="brush: js">var today = new Date(); +var minutes = today.getUTCMinutes(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.21', 'Date.prototype.getUTCMinutes')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcminutes', 'Date.prototype.getUTCMinutes')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcminutes', 'Date.prototype.getUTCMinutes')}}</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.Date.getUTCMinutes")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getutcmonth/index.html b/files/de/web/javascript/reference/global_objects/date/getutcmonth/index.html new file mode 100644 index 0000000000..3de532c78a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getutcmonth/index.html @@ -0,0 +1,81 @@ +--- +title: Date.prototype.getUTCMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUTCMonth()</code></strong> Methode gibt den Monat eines Datums bezüglich der Weltzeit zurück. Dieser Wert ist 0-basierend (0 steht für den ersten Monat im Jahr).</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcmonth.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMonth()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 11, die den Monat des gegebenen Datums bezüglich der Weltzeit (UTC) angibt. 0 steht für Januar, 1 für Februar, 2 für März und so weiter.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getUTCMonth()">Einsatz von <code>getUTCMonth()</code></h3> + +<p>Das folgende Beispiel weist der <code>month</code> Variable den aktuellen Monat zu.</p> + +<pre class="brush: js">var today = new Date(); +var month = today.getUTCMonth(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.13', 'Date.prototype.getUTCMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}</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.Date.getUTCMonth")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getutcseconds/index.html b/files/de/web/javascript/reference/global_objects/date/getutcseconds/index.html new file mode 100644 index 0000000000..55ca03eb8f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getutcseconds/index.html @@ -0,0 +1,79 @@ +--- +title: Date.prototype.getUTCSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>getUTCSeconds()</code></strong> Methode gibt die Sekunden der Zeit bezüglich der Weltzeit zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcseconds.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCSeconds()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl zwischen 0 und 59, die die Sekunden des gegebenen Date-Objektes bezüglich der Weltzeit (UTC) angibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_getUTCSeconds()">Einsatz von <code>getUTCSeconds()</code></h3> + +<p>Das folgende Beispiel weist der Variablen <code>seconds</code> die aktuelle Sekunde zu.</p> + +<pre class="brush: js">var today = new Date(); +var seconds = today.getUTCSeconds(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.23', 'Date.prototype.getUTCSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}</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.Date.getUTCSeconds")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/getyear/index.html b/files/de/web/javascript/reference/global_objects/date/getyear/index.html new file mode 100644 index 0000000000..1c7ef8baba --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/getyear/index.html @@ -0,0 +1,127 @@ +--- +title: Date.prototype.getYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/getYear +tags: + - Date + - Deprecated + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>Die <strong><code>getYear()</code></strong> Methode gibt das Jahr eines Datums bezüglich der Ortszeit zurück. Weil <code>getYear()</code> nicht das ganze Jahr zurück gibt (das "Jahr 2000 Problem"), wird es nicht weiter eingesetzt und wird von der Methode {{jsxref("Date.prototype.getFullYear", "getFullYear()")}} ersetzt.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getYear()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Zahl, welche das Jahr minus 1900 des gegebenen Datums bezüglich der lokalen Zeit angibt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<ul> + <li>Für Jahre größer oder gleich 2000 ist der Rückgabewert von <code>getYear()</code> 100 oder größer. Zum Beispiel wird für das Jahr 2026 der Wert 126 zurück gegeben.</li> + <li>Für Jahre zwischen 1900 und 1999 ist der Rückgabewert von <code>getYear()</code> zwischen 0 und 99. Zum Beispiel wird für das Jahr 1976 der Wert 76 zurückgegeben.</li> + <li>Für Jahre kleiner als 1900 ist der Rückgabewert von <code>getYear()</code> kleiner 0. Zum Beispiel wird für das Jahr 1800 der Wert -100 zurück gegeben.</li> +</ul> + +<p>Um mit Jahren vor und nach 2000 umgehen zu können, sollte stattdessen die Methode {{jsxref("Date.prototype.getFullYear", "getFullYear()")}} eingesetzt werden. Diese gibt das vollständige Jahr zurück.</p> + +<h2 id="Rückwärtskompatibilität">Rückwärtskompatibilität</h2> + +<h3 id="Verhalten_in_JavaScript_1.2_und_früher">Verhalten in JavaScript 1.2 und früher</h3> + +<p>Die <code>getYear()</code> Methode gibt entweder ein 2-stelliges oder 4-stelliges Jahr zurück.</p> + +<ul> + <li>Für Jahre zwischen 1900 (inklusiv) und 1999 (inklusiv) gibt <code>getYear()</code> das Jahr minus 1900 zurück. Zum Beispiel wird für das Jahr 1976 der Wert 76 zurückgegeben.</li> + <li>Für Jahre kleiner als 1900 oder größer als 1999 gibt die <code>getYear()</code> eine 4-stellige Jahreszahl zurück. Zum Beispiel wird für das Jahr 1856 der Wert 1856 zurückgegeben. Für das Jahr 2026 wird der Wert 2026 zurückgegeben.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Jahre_zwischen_1900_und_1999">Jahre zwischen 1900 und 1999</h3> + +<p>Das zweite Statement initialisiert die Variable <code>year</code> mit dem Wert 95.</p> + +<pre class="brush: js">var Xmas = new Date('December 25, 1995 23:15:00'); +var year = Xmas.getYear(); // returns 95 +</pre> + +<h3 id="Jahre_nach_1999">Jahre nach 1999</h3> + +<p>Das zweite Statement initialisiert die Variable <code>year</code> mit dem Wert 100.</p> + +<pre class="brush: js">var Xmas = new Date('December 25, 2000 23:15:00'); +var year = Xmas.getYear(); // returns 100 +</pre> + +<h3 id="Jahre_vor_1900">Jahre vor 1900</h3> + +<p>Das zweite Statement initialisiert die Variable <code>year</code> mit dem Wert -100.</p> + +<pre class="brush: js">var Xmas = new Date('December 25, 1800 23:15:00'); +var year = Xmas.getYear(); // returns -100 +</pre> + +<h3 id="Setzen_und_bekommen_von_Jahren_zwischen_1900_und_1999">Setzen und bekommen von Jahren zwischen 1900 und 1999</h3> + +<p>Das zweite Statement initialisiert die Variable <code>year</code> mit dem Wert 95, was für das Jahr 1995 steht.</p> + +<pre class="brush: js">var Xmas = new Date('December 25, 2015 23:15:00'); +Xmas.setYear(95); +var year = Xmas.getYear(); // returns 95 +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.4', 'Date.prototype.getYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> + <p>Definiert in dem (informativen) Kompatibilitäts-Anhang</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getyear', 'Date.prototype.getYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td><span id="result_box" lang="de"><span>Definiert in</span> dem <span>(normativ)</span> <span>Anhang</span> <span>für</span> <span>zusätzliche Funktionen</span> <span>für Web-Browser</span><span>.</span></span></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getyear', 'Date.prototype.getYear')}}</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.Date.getYear")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/index.html b/files/de/web/javascript/reference/global_objects/date/index.html new file mode 100644 index 0000000000..75346dfbc4 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/index.html @@ -0,0 +1,230 @@ +--- +title: Date +slug: Web/JavaScript/Reference/Global_Objects/Date +tags: + - Date + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Date +--- +<p>{{JSRef}}</p> + +<p>Erstellt eine JavaScript Date Instanz, die einen einzelnen Moment der Zeit repräsentiert. Date Objekte basieren auf dem Zeitwert, der der Anzahl der Millisekunden seit dem 1. Januar 1970 (UTC) entspricht.</p> + +<p>{{EmbedInteractiveExample("pages/js/date-constructor.html")}}</p> + +<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre>new Date(); +new Date(<var>value</var>); +new Date(<var>dateString</var>); +new Date(<var>year</var>, <var>monthIndex</var> [, <var>day</var> [, <var>hour </var>[, <var>minutes </var>[, <var>seconds</var> [, <var>milliseconds</var>]]]]]); +</pre> + +<p><strong>Anmerkung:</strong> Ein JavaScript <code>Date</code> Objekt kann nur instanziiert werden, wenn JavaScript Date als ein Konstruktor aufgerufen wird: Beim Aufrufen als reguläre Funktion (z. B. ohne den {{jsxref("Operators/new", "new")}} Operator) gibt die Funktion einen String zurück und kein <code>Date</code> Objekt. Anders als andere JavaScript-Datentypen hat das <code>Date</code> Objekt keine Literalsyntax.</p> + +<h3 id="Parameter">Parameter</h3> + +<p><strong>Anmerkung:</strong> Das Argument <code>monthIndex</code> ist 0-basiert. Das bedeutet, dass <code>0 = Januar</code> und <code>11 = Dezember</code> ist.</p> + +<p><strong>Anmerkung: </strong>Wenn <code>Date</code> als Konstruktor mit mehr als einem Argument aufgerufen wird und die übergebenen Werte größer als ihr logischer Bereich sind (z. B. 13 wird als Monat genutzt oder 70 wird als Minutenwert eingesetzt) wird der angrenzende Wert angepasst. Z. B. ist <code>new Date(2013, 13, 1)</code> äquivalent zu <code>new Date(2014, 1, 1</code>. Beide Ausdrücke erstellen das Datum <code>2014-02-01</code> (Monate fangen bei 0 an). Das gleiche gilt für folgende Werte: <code>new Date(2013, 2, 1, 0, 70)</code> ist äquivalent zu <code>new Date(2013, 2, 1, 1, 10)</code>, was beides den Zeitpunkt <code>2013-03-01T01:10:00</code> erzeugt.</p> + +<p><strong>Anmerkung:</strong> Wenn <code>Date</code> als Konstruktor mit mehr als einem Argumenten aufgerufen wird, werden die Argumente als Ortszeiten interpretiert. Wenn die Weltzeit genutzt werden soll, muss <code>new Date({{jsxref("Date.UTC()", "Date.UTC(...)")}})</code> mit den gleichen Argumenten genutzt werden.</p> + +<dl> + <dt><code>value</code></dt> + <dd>Ganze Zahl, die die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC (Unixzeit) repräsentiert.</dd> +</dl> + +<dl> + <dt><code>dateString</code></dt> + <dd>String der ein Datum repräsentiert. Der String muss in einem Format vorliegen, der von der {{jsxref("Date.parse()")}} Methode eingelesen werden kann (<a class="external" href="http://tools.ietf.org/html/rfc2822#page-14" title="http://tools.ietf.org/html/rfc2822#page-14">IETF-compliant RFC 2822 Zeitstempel</a> und auch eine <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15">Version von ISO8601</a>). + <p><strong>Anmerkung:</strong> Von dem Einlesen eines Zeitstempel-Strings durch den <code>Date</code> Konstruktor (und <code>Date.parse</code>, denn diese Funktion ist äquivalent) wird stark abgeraten, wegen der Unterschiede in den Browsern und Inkonsistenzen. Die Unterstützung für RFC 2822 formatierte Strings ist nur eine Konvention. Unterstützung für ISO 8601 formatierte Strings unterscheidet sich in den Strings mit nur einem Datum (z. B. "1970-01-01") werden nur als UTC behandelt und nicht als lokales Daten.</p> + </dd> +</dl> + +<dl> + <dt><code>year</code></dt> + <dd>Ganze Zahl, die die Jahre repräsentiert. Werte von 0 bis 99 werden zu den Jahren 1900 bis 1999 umgewandelt. Siehe das {{anch("Zwei_ziffrige_Zahlen_für_die_Jahre_1900_-_1999", "Beispiel unten")}}.</dd> +</dl> + +<dl> + <dt><code>monthIndex</code></dt> + <dd>Ganze Zahl, die den Monat repräsentiert. Die Zahl beginnt bei 0 für Januar und endet bei 11 für Dezember.</dd> +</dl> + +<dl> + <dt><code>day</code></dt> + <dd>Ganze Zahl, die den Tag des Monats repräsentiert.</dd> +</dl> + +<dl> + <dt><code>hour</code></dt> + <dd>Ganze Zahl, die die Stunde des Tages repräsentiert.</dd> +</dl> + +<dl> + <dt><code>minute</code></dt> + <dd>Ganze Zahl, die die Minuten einer Stunde repräsentiert.</dd> +</dl> + +<dl> + <dt><code>second</code></dt> + <dd>Ganze Zahl, die die Sekunden einer Minute repräsentiert.</dd> +</dl> + +<dl> + <dt><code>millisecond</code></dt> + <dd>Ganze Zahl, die die Millisekunden einer Sekunde repräsentiert.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<ul> + <li>Wenn keine Argumente übergeben werden, erstellt der Konstruktor ein <code>Date</code> Objekt mit dem aktuellen Datum und der aktuellen Zeit der Systemzeitzone.</li> + <li>Wenn mindestens zwei Argumente übergeben werden, werden fehlende Argumente auf 1 gesetzt (wenn day fehlt) oder auf 0 gesetzt (für alle anderen Fälle).</li> + <li>Das JavaScript Datum basiert auf einem Zeitwert, der die Millisekunden seit Mitternacht am 1. Januar 1970 UTC beinhaltet. Ein Tag hat 86.400.000 Millisekunden. Der Bereich des JavaScript Datums-Objektes ist von -100.000.000 Tagen bis 100.000.000 Tagen relativ zum 1. Januar 1970 UTC.</li> + <li>Das JavaScript <code>Date</code> Objekt unterstützt ein einheitliches plattformübergreifendes Format. Der Zeitwert kann zwischen Systemen ausgetauscht werden, um den gleichen Moment der Zeit zu repräsentieren. Wenn es zum Erstellen eines lokalen <code>date</code> Objektes genutzt wird, wird es die lokale äquivalente Zeit benutzen.</li> + <li>Das JavaScript <code>Date</code> Objekt unterstützt eine Nummer der UTC (universal) Methode genauso wie eine lokale Zeit Methode. UTC ist auch bekannt als Greenwich-Zeit (GTM), welches die Standardweltzeit ist. Die lokale Zeit ist die Zeit des Computers, auf dem JavaScript ausgeführt wird.</li> + <li>Das Aufrufen der JavaScript <code>Date</code> Funktion (z. B. ohne den {{jsxref("Operators/new", "new")}} Operator) gibt einen String, der das aktuelle Datum und die aktuelle Zeit repräsentiert, zurück.</li> +</ul> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("Date.prototype")}}</dt> + <dd>Erlaubt das Hinzufügen von Eigenschaften zum JavaScript <code>Date</code> Objekt.</dd> + <dt>Date.length</dt> + <dd>Der Wert von <code>Date.length</code> ist 7. Dieser ist die Anzahl der Argumente, die vom Konstruktor gehändelt werden.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Date.now()")}}</dt> + <dd>Gibt den nummerischen Wert der aktuellen Zeit an - die Anzahl der Millisekunden die seit dem 1. Januar 1970 00:00:00 UTC vergangen sind.</dd> + <dt>{{jsxref("Date.parse()")}}</dt> + <dd>Analysiert eine String-Repräsentation eines Datums und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC zurück. + <p><strong>Anmerkung:</strong> Von der Nutzung der <code>Date.parse</code> Methode wird stark abgeraten wegen der Unterschiede und Widersprüche in verschiedenen Browsern.</p> + </dd> + <dt>{{jsxref("Date.UTC()")}}</dt> + <dd>Akzeptiert die gleichen Parameter wie die längste Form des Konstruktors (z. B. 2 bis 7) und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC zurück.</dd> +</dl> + +<h2 id="JavaScript_Date_Instanzen">JavaScript <code>Date</code> Instanzen</h2> + +<p>Alle <code>Date</code> Instanzen erben von {{jsxref("Date.prototype")}}. Das Prototype Objekt des <code>Date</code> Konstruktors kann modifiziert werden, um alle <code>Date</code> Instanzen zu ändern.</p> + +<h3 id="Methoden_2">Methoden</h3> + +<p>{{ page("/de/docs/Web/JavaScript/Reference/Global_Objects/Date/prototype", "Methoden") }}</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verschiedene_Wege_ein_Date_Objekt_zu_erstellen">Verschiedene Wege ein Date Objekt zu erstellen</h3> + +<p>Das folgende Beispiel zeigt verschiedene Wege, um JavaScript {{jsxref("Date")}} Objekte zu erstellen:</p> + +<p><strong>Anmerkung:</strong> Von der Nutzung des <code>Date</code> Konstruktors mit einem String-Argument (und der <code>Date.parse</code> Methode) wird wegen der Unterschiede und Widersprüche in verschiedenen Browsern abgeraten.</p> + +<pre>var today = new Date(); +var birthday = new Date("December 17, 1995 03:24:00"); +var birthday = new Date("1995-12-17T03:24:00"); +var birthday = new Date(1995,11,17); +var birthday = new Date(1995,11,17,3,24,0); +</pre> + +<h3 id="Zwei_ziffrige_Zahlen_für_die_Jahre_1900_-_1999">Zwei ziffrige Zahlen für die Jahre 1900 - 1999</h3> + +<p>Um Daten in den Jahren 0 bis 99 zu erzeugen und abzufragen, müssen die Methoden {{jsxref("Date.prototype.setFullYear()")}} und {{jsxref("Date.prototype.getFullYear()")}} eingesetzt werden.</p> + +<pre>var date = new Date(98, 1); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT) + +// Deprecated Methode, 98 wird hier zu 1998 +date.setYear(98); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT) + +date.setFullYear(98); // Sat Feb 01 0098 00:00:00 GMT+0000 (BST)</pre> + +<h3 id="Berechnen_von_vergangener_Zeit">Berechnen von vergangener Zeit</h3> + +<p>Die folgenden Beispiele zeigen, wie man die vergangene Zeit zwischen zwei JavaScript <code>date</code>s in Millisekunden berechnet.</p> + +<p>Durch die unterschiedlichen Längen von Tagen (wegen der Sommer/Winter Zeitumstellung), Monaten und Jahren gibt es bei Zeiteinheiten größer als Stunden, Minuten und Sekunden eine Reihe von Problemen, die vorher recherchiert und abgeprüft werden sollten.</p> + +<pre>// Einsatz Date Objekts +var start = Date.now(); + +// Event was einige Zeit braucht: +doSomethingForALongTime(); +var end = Date.now(); +var elapsed = end - start; // elapsed time in milliseconds +</pre> + +<pre>// Einsatz Eingebauter Methoden +var start = new Date(); + +// Event was einige Zeit braucht: +doSomethingForALongTime(); +var end = new Date(); +var elapsed = end.getTime() - start.getTime(); // elapsed time in milliseconds +</pre> + +<pre>// Testen einer funktion und Rückgabe des Rückgabewertes +function printElapsedTime (fTest) { + var nStartTime = Date.now(), + vReturn = fTest(), + nEndTime = Date.now(); + + alert("Elapsed time: " + String(nEndTime - nStartTime) + " milliseconds"); + return vReturn; +} + +yourFunctionReturn = printElapsedTime(yourFunction); +</pre> + +<p><strong>Anmerkung:</strong> In Browsern, die die hochauflösende Zeitfunktionen von der {{domxref("window.performance", "Web Performance API", "", 1)}} unterstützen, kann {{domxref("Performance.now()")}} bessere und präzisere Messergebnisse liefern als {{jsxref("Date.now()")}}.</p> + +<h3 id="Die_Anzahl_der_Sekunden_seit_der_Unix_Epoche_ermitteln">Die Anzahl der Sekunden seit der Unix Epoche ermitteln</h3> + +<pre>var seconds = Math.floor(Date.now() / 1000);</pre> + +<p>In diesem Fall ist es wichtig, nur eine ganze Zahl zurückzugeben (eine einfache Division würde nicht reichen) und auch nur tatsächlich verstrichene Sekunden zurückzugeben (deswegen nutzt der Quelltext die {{jsxref("Math.floor()")}} Funktion und nicht die {{jsxref("Math.round()")}} Funktion).</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>Initiale Definition. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9', 'Date')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date-objects', 'Date')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date-objects', 'Date')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>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.Date")}}</p> diff --git a/files/de/web/javascript/reference/global_objects/date/now/index.html b/files/de/web/javascript/reference/global_objects/date/now/index.html new file mode 100644 index 0000000000..e275650960 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/now/index.html @@ -0,0 +1,105 @@ +--- +title: Date.now() +slug: Web/JavaScript/Reference/Global_Objects/Date/now +tags: + - Date + - JavaScript + - MakeBrowserAgnostic + - Method + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Date/now +--- +<div>{{JSRef}}</div> + +<p>Die<strong><code> Date.now()</code></strong> Methode gibt die Anzahl der Millisekunden, die seit dem 01.01.1970 00:00:00 UTC vergangen sind zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-now.html")}}</div> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox">var timeInMs = Date.now(); +</pre> + +<h3 id="Parameters" name="Parameters">Rückgabewert</h3> + +<p>Eine {{jsxref("Number", "Zahl")}}, die die vergangenen Millisekunden seit dem 1. Januar 1970 00:00:00 Weltzeit (UTC) angibt (UNIX-Zeit).</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Da <code>now</code> eine statische Methode von <code>Date</code> ist, kann es immer so verwendet werden: <code>Date.now()</code></p> + +<h2 id="Reduzierte_Zeitpräzision">Reduzierte Zeitpräzision</h2> + +<p>Um den Schutz vor Timing-Angriffen und Fingerabdrücken zu gewährleisten, kann die Genauigkeit von <code>new Date().getTime()</code> abhängig von den Browsereinstellungen abgerundet werden.<br> + <span>In Firefox ist die <code>privacy.resistFingerprinting</code> Einstellung normalerweise eingeschaltet auf 20 us in Firefox 59; in 60 wird es 2 ms sein.</span></p> + +<pre class="brush: js" id="ct-107">// reduced time precision disabled +new Date().getTime(); +// 1519129755973 +// 1519129769481 +// 1519129808126 +// ... + + +// reduced time precision enabled +new Date().getTime(); +// 1519129853500 +// 1519129858900 +// 1519129864400 +// ... +</pre> + +<p>In Firefox kann man zudem die Eigenschaft <code>privacy.resistFingerprinting</code> einschalten, die Präzision wird 100 ms sein oder man benutzt den Wert <code>privacy.resistFingerprinting.reduceTimerPrecision.microseconds</code>, wenn der Wert größer sein soll.</p> + +<h2 id="Compatibility" name="Compatibility">Polyfill</h2> + +<p>Diese Methode wurde in in ECMA-262 5<sup>th</sup> edition standardisiert. Engines die noch nicht hinsichtlich diesen Standards aktualisiert wurden können den folgenden shim verwenden, um die Methode verfügbar zu machen:</p> + +<pre class="brush: js">if (!Date.now) { + Date.now = function now() { + return new Date().getTime(); + }; +} +</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('ES5.1', '#sec-15.9.4.4', 'Date.now')}}<br> + Implemented in JavaScript 1.5</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.now', 'Date.now')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.now', 'Date.now')}}</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.Date.now")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{domxref("window.performance.now")}} - bietet timestamps mit einer kleineren Auflösung (kleiner als Millisekunden), um die Seitenperformance messen zu können</li> + <li>{{domxref("console.time")}} / {{domxref("console.timeEnd")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/parse/index.html b/files/de/web/javascript/reference/global_objects/date/parse/index.html new file mode 100644 index 0000000000..4920cdb6a8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/parse/index.html @@ -0,0 +1,173 @@ +--- +title: Date.parse() +slug: Web/JavaScript/Reference/Global_Objects/Date/parse +tags: + - Date + - JavaScript + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Date.parse()</code></strong> Methode liest eine String-Repräsentation eines Datums ein und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC oder <code>NaN</code>, wenn der String kein Datum ist oder manchmal wenn einige Datums- oder Zeitwerte einen falschen Wert haben (z. B. 2015-02-31), zurück.</p> + +<p>Es ist bis ES5 nicht empfohlen die <code>Date.parse</code> Methode einzusetzten, weil das Einlesen von Strings implementierungsabhängig war. Es gibt sehr viele Unterschiede wie verschiedene Implementierungen strings einlesen, weshalb Strings manuell eingelesen werden sollten (eine Bibliothek kann helfen, wenn viele Formate eingesetzt werden sollen).</p> + +<div>{{EmbedInteractiveExample("pages/js/date-parse.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<p>Direkter Aufruf:</p> + +<pre class="syntaxbox">Date.parse(<var>dateString</var>)</pre> + +<p>Impliziter Aufruf:</p> + +<pre class="syntaxbox">new Date(<var>dateString</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>dateString</code></dt> + <dd>Ein String, der ein <a href="http://tools.ietf.org/html/rfc2822#section-3.3">RFC2822</a> oder (eine Variante des) ISO 8601 Datumsformat (mit Zeit) repräsentiert (andere Formate können manchmal eingesetzt werden, jedoch ist das Ergebnis manchmal unerwartet).</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Zahl, die die Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem Datum, das in dem übergebenen Parameter repräsentiert wird. Wenn der Parameter kein valides Datum repräsentiert, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>parse()</code> Methode bekommt ein Datumsstring (z. B. <code>"Dec 25, 1995"</code> ) und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC zurück. Diese Funktion ist nützlich, um Datumswerte mithilfe eines Stringswertes einzustellen, (z. B. im zusammenhang mit der {{jsxref("Date.prototype.setTime()", "setTime()")}} Methode und dem {{jsxref("Global_Objects/Date", "Date")}} Objekt).</p> + +<p>Bei einer Stringrepräsentation mit einer Zeit, gibt die <code>parse()</code> Methode die Zeitwert zurück. Es wird die RFC2822 / IETF Datums Syntax (<a href="http://tools.ietf.org/html/rfc2822#section-3.3">RFC2822 Section 3.3</a>) unterstützt (z. B. <code>"Mon, 25 Dec 1995 13:30:00 GMT"</code>). Die Methode versteht die kontimentalen US Zeitzonenabkürzungen, jedoch sollte lieber der Zeitzonenunterschied angegeben werden, wie zum Beispiel <code>"Mon, 25 Dec 1995 13:30:00 +0430"</code> (4 Stunden und 30 Minuten östlich vom Greenwich Meridian).</p> + +<p>GMT und UTC werden gleich berücksichtigt. Die lokale Zeitzone wird eingesetzt um Argumente im <a href="http://tools.ietf.org/html/rfc2822#section-3.3">RFC2822 Kapitel 3.3</a> Format zu interpretieren, welche keine Zeitzoneninformationen enthalten.</p> + +<p>Wegen der Unterschiede beim einlesen von Datums Strings, ist es empfohlen das Einlesen eines Datums immer manuell durchzuführen, wenn das Ergebnisse inkonsistent sind, besonders über verschiedene ECMAScript Implementierungen hinweg, wo Strings wie <code>"2015-10-12 12:00:00"</code> manchmal zu <code>NaN</code>, UTC oder lokaler Zeitzone eingelesen werden.</p> + +<h3 id="ECMAScript_5_ISO-8601_Format_Unterstützung">ECMAScript 5 ISO-8601 Format Unterstützung</h3> + +<p>Der Datums- / Zeit-String ist manchmal im einfachen <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a> Format. Zum Beispiel können <code>"2011-10-10"</code> (nur ein Datum) oder <code>"2011-10-10T14:48:00"</code> (Datum und Zeit) übergeben und eingelesen werden. Wenn der String ein ISO 8601 Datum (ohne Zeit) ist, wird die UTC Zeitzone eingesetzt, um die Argumente zu interpretieren. Wenn der String Datums- und Zeitangaben im <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a> Format enthällt, wird dieses als lokale Zeit interpretiert.</p> + +<p>Weil Zeitzonen im String enthalten sein können und interpretiert werden können, wird immer die Anzahl der Millisekunden zwischen dem repräsentierten Datum und dem 1. Januar 1970 00:00:00 UTC oder <code>NaN</code> zurückgegeben.</p> + +<p>Weil <code>parse()</code> eine statische Methode von {{jsxref("Date")}} ist, wird diese mit <code>Date.parse()</code> aufgerufen und nicht als Methode einer {{jsxref("Date")}} Instanz.</p> + +<h3 id="Unterschiede_in_erwarteten_Zeitzonen">Unterschiede in erwarteten Zeitzonen</h3> + +<p>Wenn der Datumsstring <code>"March 7, 2014"</code> gegeben ist, nimmt <code>parse()</code> dabei die lokale Zeitzone an. Ist hingegen ein ISO Format wie <code>"2014-03-07"</code> angegeben, so wird eine UTC Zeitzone angenommen (ES5 und ECMAScript 2015). Deshalb können die so erstellten {{jsxref("Date")}} Objekte einen unterschiedlichen Zeitpunkt repräsentieren. Dieses ist von der ECMAScript Version abhängig wenn das System mit einer lokalen UTC Zeit eingestellt ist. Das bedeutet, dass zwei Strings mit einem äquivalenten Datum (Unterschied in der Formatierung) zu zwei verschiednenen Ergebnissen führen kann.</p> + +<h3 id="Fall-back_für_implementierungsspezifische_Datumsformate">Fall-back für implementierungsspezifische Datumsformate</h3> + +<p>Die ECMAScript Spezifikation besagt: Wenn ein String nicht dem Standardformat entspricht, nutzen die Funktionen eine Fall-back-Lösung in Form einer implementierungsabhängigen Heuristik oder eines implementierungsabhängigen Algorithmus. Unkenntliche Strings oder Daten, die nicht valide Werte von ISO formattierten Elementen haben, führen dazu, dass <code>Date.parse()</code> den Wert {{jsxref("NaN")}} zurückgibt.</p> + +<p>Immer, wenn ein String nicht im einfachen ISO Format ist (ECMA-252) und nicht valide Datumswerte enthällt, ist es vom Wert und vom Browser abhängig, ob {{jsxref("NaN")}} zurückgegeben wird oder nicht. Z. B.:</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="comment token">// Kein-ISO String: Mit nicht validen Datumswerten</span> +<span class="keyword token">new</span> <span class="class-name token">Date</span><span class="punctuation token">(</span><span class="string token">'23/25/2014'</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Führt zu den Datum 25. November 2015 (Ortszeit) in Firefox 30 und zu einem nicht validen Datum in Safari 7. Immer, wenn Strings als ISO Format erkannt werden und diese nicht valider Werte enthalten, wird von allen Browsern, die mindestens ES5 unterstützen, {{jsxref("NaN")}} zurückgegeben:</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="comment token">// ISO String mit nicht validen Werten</span> +<span class="keyword token">new</span> <span class="class-name token">Date</span><span class="punctuation token">(</span><span class="string token">'2014-25-23'</span><span class="punctuation token">)</span><span class="punctuation token">.</span><span class="function token">toISOString</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// returns "RangeError: invalid date" in allen es5 kompatiblen Browsern</span></code></pre> + +<p>SpiderMonkey's implementierungsabhängige Heuristik kann in der <a href="http://mxr.mozilla.org/mozilla-central/source/js/src/jsdate.cpp?rev=64553c483cd1#889"><code>jsdate.cpp</code></a>-Datei gefunden werden. Der String <code>"10 06 2014"</code> ist ein Beispiel für einen nicht konformen ISO formatierten String und dieses wird durch die implementierungsabhängige Heuristik abgearbeitet. Siehe zudem diese <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1023155#c6">grobe Übersicht</a> an, wie das Analysieren funktioniert.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">new</span> <span class="class-name token">Date</span><span class="punctuation token">(</span><span class="string token">'10 06 2014'</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Wird das Datum 6. Oktober 2014 (Ortszeit) erzeugen und nicht den 10 Juni 2014. Andere Beispiele:</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">new</span> <span class="class-name token">Date</span><span class="punctuation token">(</span><span class="string token">'foo-bar 2014'</span><span class="punctuation token">)</span><span class="punctuation token">.</span><span class="function token">toString</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// returns: "Invalid Date"</span> + +Date<span class="punctuation token">.</span><span class="function token">parse</span><span class="punctuation token">(</span><span class="string token">'foo-bar 2014'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="comment token">// returns: NaN</span></code></pre> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Date.parse()">Einsatz von <code>Date.parse()</code></h3> + +<p>Wenn <code>IPOdate</code> ein existierendes {{jsxref("Date")}} Objekt ist, kann es auf den 9. August 1995 (Ortszeit) gesetzt werden:</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">IPOdate<span class="punctuation token">.</span><span class="function token">setTime</span><span class="punctuation token">(</span>Date<span class="punctuation token">.</span><span class="function token">parse</span><span class="punctuation token">(</span><span class="string token">'Aug 9, 1995'</span><span class="punctuation token">)</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Das gleich Beispiel für das Analysieren von nicht-Standarddatumsstrings:</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Date<span class="punctuation token">.</span><span class="function token">parse</span><span class="punctuation token">(</span><span class="string token">'Aug 9, 1995'</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Gibt den Wert <code>807937200000</code> in der Zeitzone GMT-0300 zurück und andere Werte in anderen Zeitzonen, wenn im String keine Zeitzone definiert ist und es kein ISO formatiertes Datum ist. Deswegen wird als Standardwert die Ortszeit genutzt.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Date<span class="punctuation token">.</span><span class="function token">parse</span><span class="punctuation token">(</span><span class="string token">'Wed, 09 Aug 1995 00:00:00 GMT'</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Gibt <code>807926400000</code> in allen Zeitzonen zurück, weil GMT (UTC) angegeben ist.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Date<span class="punctuation token">.</span><span class="function token">parse</span><span class="punctuation token">(</span><span class="string token">'Wed, 09 Aug 1995 00:00:00'</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Gibt den Wert <code>807937200000</code> in der Zeitzone GMT-0400 zurück und andere Werte in anderen Zeitzonen, wenn im String keine Zeitzone definiert ist und es kein ISO formatiertes Datum ist. Deswegen wird als Standardwert die Ortszeit genutzt.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Date<span class="punctuation token">.</span><span class="function token">parse</span><span class="punctuation token">(</span><span class="string token">'Thu, 01 Jan 1970 00:00:00 GMT'</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Gibt 0 in allen Zeitzonen zurück, weil GMT (UTC) angegeben ist.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Date<span class="punctuation token">.</span><span class="function token">parse</span><span class="punctuation token">(</span><span class="string token">'Thu, 01 Jan 1970 00:00:00'</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Gibt den Wert <code>14400000</code> in der Zeitzone GMT-0400 zurück und andere Werte in anderen Zeitzonen, wenn im String keine Zeitzone definiert ist und es kein ISO formatiertes Datum ist. Deswegen wird als Standardwert die Ortszeit genutzt.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Date<span class="punctuation token">.</span><span class="function token">parse</span><span class="punctuation token">(</span><span class="string token">'Thu, 01 Jan 1970 00:00:00 GMT-0400'</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Gibt <code>14400000</code> in allen Zeitzonen zurück, weil GMT (UTC) angegeben ist.</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>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.4.2', 'Date.parse')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Einfaches ISO 8601 Format hinzugefügt.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.parse', 'Date.parse')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.parse', 'Date.parse')}}</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.Date.parse")}}</p> + +<h2 id="Kompatibilitätsnotitzen">Kompatibilitätsnotitzen</h2> + +<ul> + <li>Firefox 49 {{geckoRelease(49)}} hat das Einlesen von 2-Stelligen Jahreszahlen geändert und hat sich damit an den Google Chrome angepasst und nicht mehr an den Internet Explorer. Jetzt werden 2-Stellige Jahreszahlen, die kleiner oder gleich 50 sind zum 21. Jahrhundert gezählt. Zum Beispiel wird <code>04/16/17</code> jetzt zum 16. April 19 2017 und nicht mehr zum 16. April 1917 eingelesen. Es vermeidet alle Probleme mit mehrdeutigen Jahren. Es wird empfohlen das ISO 8601 (z. B. 2017-04-16) zu benutzen ({{bug(1265136)}}).</li> +</ul> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.UTC()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/prototype/index.html b/files/de/web/javascript/reference/global_objects/date/prototype/index.html new file mode 100644 index 0000000000..a056132ba7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/prototype/index.html @@ -0,0 +1,182 @@ +--- +title: Date.prototype +slug: Web/JavaScript/Reference/Global_Objects/Date/prototype +tags: + - Date + - JavaScript + - Property + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Date.prototype-</code></strong>Eigenschaft ist der Prototype für den {{jsxref("Date")}}-Konstruktor</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>JavaScript-{{jsxref("Date")}}-Instanzen erben von <code>Date.prototype</code>. Man kann das Konstruktorprototype-Objekt ändern, um Eigenschaften und Methoden aller {{jsxref("Date")}}-Instanzen zu ändern.</p> + +<p>Für die Kompatibilität mit Jahrtausendsrechnungen (in anderen Worten, um das Jahr 2000 mit einzukalkulieren), sollte man das Jahr immer in voller Länge spezifizieren; zum Beispiel sollte 1998 und nicht 98 benutzt werden. Zur Unterstützung der Spezifizierung des vollen Jahres hat JavaScript die Methoden {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}}, {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}}, {{jsxref("Date.prototype.getUTCFullYear()", "getUTCFullYear()")}} und {{jsxref("Date.prototype.setUTCFullYear()", "setUTCFullYear()")}}.</p> + +<p>Mit Einführung von ECMAScript 6 ist das <code>Date.prototype</code>-Objekt ein normales Objekt. Es ist keine Instanz von {{jsxref("Date")}}.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Date.prototype.constructor</code></dt> + <dd>Eine Funktion, die Instanzen erzeugen kann. Der {{jsxref("Date")}}-Konstruktor ist der Standard.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<h3 id="Getter">Getter</h3> + +<dl> + <dt>{{jsxref("Date.prototype.getDate()")}}</dt> + <dd>Gibt den Tag des Monats (1 - 31) eines Datums gemäß der Ortszeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getDay()")}}</dt> + <dd>Gibt den Tag der Woche (0 - 6) eines Datums gemäß der Ortszeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getFullYear()")}}</dt> + <dd>Gibt das Jahr (4 Ziffern für 4 ziffrige Jahre) eines Datums gemäß der Ortszeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getHours()")}}</dt> + <dd>Gibt die Stunde (0 - 23) eines Datums gemäß der Ortszeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getMilliseconds()")}}</dt> + <dd>Gibt die Millisekunden (0 - 999) eines Datums gemäß der Ortszeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getMinutes()")}}</dt> + <dd>Gibt die Minuten (0 - 59) eines Datums gemäß der Ortszeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getMonth()")}}</dt> + <dd>Gibt den Monat (0 - 11) eines Datums gemäß der Ortszeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getSeconds()")}}</dt> + <dd>Gibt die Sekunden (0 - 59) eines Datums gemäß der Ortszeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getTime()")}}</dt> + <dd>Gibt den nummerischen Wert eines Datums als Millisekunden seit 1. Januar 1970 00:00:00 UTC (negativ für frühere Daten) zurück.</dd> + <dt>{{jsxref("Date.prototype.getTimezoneOffset()")}}</dt> + <dd>Gibt den Zeitzonenunterschied in Minuten für die aktuelle Region zurück.</dd> + <dt>{{jsxref("Date.prototype.getUTCDate()")}}</dt> + <dd>Gibt den Tag des Monats (1 - 31) eines Datums gemäß der Weltzeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getUTCDay()")}}</dt> + <dd>Gibt den Tag der Woche (0 - 6) eines Datums gemäß der Weltzeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getUTCFullYear()")}}</dt> + <dd>Gibt das Jahr (4 Ziffern für 4 ziffrige Jahre) eines Datums gemäß der Weltzeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getUTCHours()")}}</dt> + <dd>Gibt die Stunden (0 - 23) eines Datums gemäß der Weltzeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</dt> + <dd>Gibt die Millisekunden (0 - 999) eines Datums gemäß der Weltzeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getUTCMinutes()")}}</dt> + <dd>Gibt die Minuten (0 - 59) eines Datums gemäß der Weltzeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getUTCMonth()")}}</dt> + <dd>Gibt den Monat (0 - 11) eines Datums gemäß der Weltzeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getUTCSeconds()")}}</dt> + <dd>Gibt die Sekunden (0 - 59) eines Datums gemäß der Weltzeit zurück.</dd> + <dt>{{jsxref("Date.prototype.getYear()")}} {{deprecated_inline}}</dt> + <dd>Gibt das Jahr (nur 2 - 3 Ziffern) eines Datums gemäß der Ortszeit zurück. Stattdessen sollte {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}} benutzt werden.</dd> +</dl> + +<h3 id="Setter">Setter</h3> + +<dl> + <dt>{{jsxref("Date.prototype.setDate()")}}</dt> + <dd>Setzt den Tag des Monats eines Datums gemäß der Ortszeit.</dd> + <dt>{{jsxref("Date.prototype.setFullYear()")}}</dt> + <dd>Setzt das Jahr (4 Ziffern für vierstellige Jahre) eines Datums gemäß der Ortszeit.</dd> + <dt>{{jsxref("Date.prototype.setHours()")}}</dt> + <dd>Setzt die Stunden eines Datums gemäß der Ortszeit.</dd> + <dt>{{jsxref("Date.prototype.setMilliseconds()")}}</dt> + <dd>Setzt die Millisekunden eines Datums gemäß der Ortszeit.</dd> + <dt>{{jsxref("Date.prototype.setMinutes()")}}</dt> + <dd>Setzt die Minuten eines Datums gemäß der Ortszeit.</dd> + <dt>{{jsxref("Date.prototype.setMonth()")}}</dt> + <dd>Setzt den Monat eines Datums gemäß der Ortszeit.</dd> + <dt>{{jsxref("Date.prototype.setSeconds()")}}</dt> + <dd>Setzt die Sekunden eines Datums gemäß der Ortszeit.</dd> + <dt>{{jsxref("Date.prototype.setTime()")}}</dt> + <dd>Setzt ein {{jsxref("Date")}} Objekt auf die Zeit, mit der Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00UTC. Negative Zahlen sind für frühere Daten erlaubt.</dd> + <dt>{{jsxref("Date.prototype.setUTCDate()")}}</dt> + <dd>Setzt den Tag des Monats eines Datums gemäß der Weltzeit.</dd> + <dt>{{jsxref("Date.prototype.setUTCFullYear()")}}</dt> + <dd>Setzt das Jahr (4 Ziffern für 4 ziffrige Jahre) eines Datums gemäß der Weltzeit.</dd> + <dt>{{jsxref("Date.prototype.setUTCHours()")}}</dt> + <dd>Setzt die Stunde eines Datums gemäß der Weltzeit.</dd> + <dt>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</dt> + <dd>Setzt die Millisekunden eines Datums gemäß der Weltzeit.</dd> + <dt>{{jsxref("Date.prototype.setUTCMinutes()")}}</dt> + <dd>Setzt die Minuten eines Datums gemäß der Weltzeit.</dd> + <dt>{{jsxref("Date.prototype.setUTCMonth()")}}</dt> + <dd>Setzt den Monat eines Datums gemäß der Weltzeit.</dd> + <dt>{{jsxref("Date.prototype.setUTCSeconds()")}}</dt> + <dd>Setzt die Sekunden eines Datums gemäß der Weltzeit.</dd> + <dt>{{jsxref("Date.prototype.setYear()")}} {{deprecated_inline}}</dt> + <dd>Setzt das Jahr (nur 2 - 3 Ziffern) eines Datums gemäß der Ortszeit. Stattdessen sollte {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} benutzt werden.</dd> +</dl> + +<h3 id="Konvertierungsgetter">Konvertierungsgetter</h3> + +<dl> + <dt>{{jsxref("Date.prototype.toDateString()")}}</dt> + <dd>Gibt das Datum als menschlich lesbaren String zurück (z. B. Thu Apr 12 2018). </dd> + <dt>{{jsxref("Date.prototype.toISOString()")}}</dt> + <dd>Konvertiert ein Datum zu einem String im erweiterten ISO-8601-Format.</dd> + <dt>{{jsxref("Date.prototype.toJSON()")}}</dt> + <dd>Gibt eine String-Repräsentation eines {{jsxref("Date")}}-Objektes zurück. Dabei wird die {{jsxref("Date.prototype.toISOString()", "toISOString()")}}-Methode eingesetzt. Gedacht für den Einsatz von {{jsxref("JSON.stringify()")}}.</dd> + <dt>{{jsxref("Date.prototype.toGMTString()")}} {{deprecated_inline}}</dt> + <dd>Gibt eine String-Repräsentation eines {{jsxref("Date")}}-Objektes auf Basis der GMT-(UT)-Zeitzone zurück. Stattdessen sollte {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}} eingesetzt werden.</dd> + <dt>{{jsxref("Date.prototype.toLocaleDateString()")}}</dt> + <dd>Gibt einen String mit ortssensitiver Repräsentation eines Datums zurück. Dieses Datum basiert auf den Systemeinstellungen.</dd> + <dt>{{jsxref("Date.prototype.toLocaleFormat()")}} {{non-standard_inline}}</dt> + <dd>Konvertiert ein Datum zu einem String mithilfe eines Formatierungsstrings.</dd> + <dt>{{jsxref("Date.prototype.toLocaleString()")}}</dt> + <dd>Gibt einen String mit ortssensitiver Repräsentation eines Datums zurück. Diese Method überschreibt die {{jsxref("Object.prototype.toLocaleString()")}}-Methode.</dd> + <dt>{{jsxref("Date.prototype.toLocaleTimeString()")}}</dt> + <dd>Gibt einen String mit ortssensitiver Repräsentation der Zeit eines Datums zurück. Diese Zeit basiert auf den Systemeinstellungen.</dd> + <dt>{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Gibt einen String-Repräsentation des Quelltextes zurück (gleich dem {{jsxref("Date")}}-Objekt). Man kann diese Methode einsetzen um ein neues Objekt zu erstellen. Diese Methode überschreibt die {{jsxref("Object.prototype.toSource()")}}-Methode</dd> + <dt>{{jsxref("Date.prototype.toString()")}}</dt> + <dd>Gibt eine String-Repräsentation eines {{jsxref("Date")}}-Objektes zurück. Diese Methode überschreibt die {{jsxref("Object.prototype.toString()")}} Methode.</dd> + <dt>{{jsxref("Date.prototype.toTimeString()")}}</dt> + <dd>Gibt die Zeit eines Datums als menschlich lesbaren String zurück.</dd> + <dt>{{jsxref("Date.prototype.toUTCString()")}}</dt> + <dd>Konvertiert das Datum zu einem String unter Einsatz der UTC-Zeitzone.</dd> + <dt>{{jsxref("Date.prototype.valueOf()")}}</dt> + <dd>Gibt ein primitiven Wert eines {{jsxref("Date")}}-Objektes zurück. Diese Methode überschreibt die {{jsxref("Object.prototype.valueOf()")}}-Methode.</dd> +</dl> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</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.9.5', 'Date.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}</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.Date.prototype")}}</p> diff --git a/files/de/web/javascript/reference/global_objects/date/setdate/index.html b/files/de/web/javascript/reference/global_objects/date/setdate/index.html new file mode 100644 index 0000000000..4fb7d6ac63 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setdate/index.html @@ -0,0 +1,91 @@ +--- +title: Date.prototype.setDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/setDate +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setDate()</code></strong> Methode setzt den Tag eines {{jsxref("Date")}} Objektes relativ zum Beginn des aktuellen Monats.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setdate.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setDate(<var>dayValue</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>dayValue</code></dt> + <dd>Eine ganze Zahl, die den Tag des Monats repräsentiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem geänderten {{jsxref("Date")}} Objektes (das Objekt wird auch geändert).</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn <code>dayValue</code> außerhalb des Wertes für einen Tag in einem Monat ist, wird <code>setDate()</code> das {{jsxref("Date")}} Objekt dementsprechend ändern. Zum Beispiel wird der Wert 0 für <code>dayValue</code> den letzen Tag des vorherigen Monats einstellen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setDate()">Einsatz von <code>setDate()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(1962, 6, 7); // 1962-07-07 +theBigDay.setDate(24); // 1962-07-24 +theBigDay.setDate(32); // 1962-08-01 +theBigDay.setDate(22); // 1962-08-22</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.36', 'Date.prototype.setDate')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setdate', 'Date.prototype.setDate')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setdate', 'Date.prototype.setDate')}}</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.Date.setDate")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setfullyear/index.html b/files/de/web/javascript/reference/global_objects/date/setfullyear/index.html new file mode 100644 index 0000000000..3dafd848dc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setfullyear/index.html @@ -0,0 +1,97 @@ +--- +title: Date.prototype.setFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/setFullYear +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setFullYear()</code></strong> Methode stellt das ganze Jahr eines Datums bezüglich der Ortszeit ein und gibt einen neuen Zeitstempel zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setfullyear.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dateValue</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>yearValue</code></dt> + <dd>Eine ganze Zahl, welche den nummerischen Wert des Jahres angibt (z. B. 1995).</dd> + <dt><code>monthValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 11, welche den Monat von Januar bis Dezember angibt.</dd> + <dt><code>dateValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 1 und 31, welche den Tag des Monats angibt. Wenn der <code>dateValue</code> Parameter angegeben wird, muss auch der <code>monthValue</code> Parameter angegeben werden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem geänderten date Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn die Parameter <code>monthValue</code> und <code>dateValue</code> nicht gesetzt sind, werden die Rückgabewerte der Methoden {{jsxref("Date.prototype.getMonth()", "getMonth()")}} und {{jsxref("Date.prototype.getDate()", "getDate()")}} eingesetzt.</p> + +<p>Wenn ein gesetzter Parameter außerhalb seiner erwarteten Grenzen ist, ändert <code>setFullYear()</code> entsprechenden die anderen Parameter und die Informationen im {{jsxref("Date")}} Objekt. Wird zum Beispiel 15 für <code>monthValue</code> Übergeben, so wird das Jahr um 1 inkrementiert und der Wert 3 wird für den Monat genutzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setFullYear">Einsatz von <code>setFullYear()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setFullYear(1997); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.40', 'Date.prototype.setFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setfullyear', 'Date.prototype.setFullYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setfullyear', 'Date.prototype.setFullYear')}}</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.Date.setFullYear")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/sethours/index.html b/files/de/web/javascript/reference/global_objects/date/sethours/index.html new file mode 100644 index 0000000000..3b40e647b6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/sethours/index.html @@ -0,0 +1,102 @@ +--- +title: Date.prototype.setHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/setHours +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setHours()</code></strong> Methode setzt die Stunden für eine Zeit bezüglich der Ortszeit und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC nachdem die Zeit des {{jsxref("Date")}} geändert wurde.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-sethours.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre> + +<h3 id="Versionen_vor_JavaScript_1.3">Versionen vor JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setHours(<var>hoursValue</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>hoursValue</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 23, die die Stunde repräsentiert. Wenn der Wert größer als 23 ist, werden die extra Stunden auf die Zeit addiert.</dd> + <dt><code>minutesValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 59, die die Minuten repräsentiert. Wenn ein Wert größer als 59 angegeben wird, werden die extra Minuten auf die Zeit addiert.</dd> + <dt><code>secondsValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 59, die die Sekunden repräsentiert. Wenn der Wert größer als 59 ist, werden die extra Sekunden auf die Zeit addiert. Wenn <code>secondsValue</code> angegeben ist, muss auch <code>minutesValue</code> angegeben werden.</dd> + <dt><code>msValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 999, die die Millisekunden repräsentiert. Wenn der Wert größer als 999 ist, werden die extra Millisekunden auf die Zeit addiert. Wenn der <code>msValue</code> Parameter angegeben ist, müssen auch die <code>minutesValue</code> und <code>secondsValue</code> Parameter angegeben werden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 UTC und dem geänderten date Objekte</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn die Parameter <code>minutesValue</code>, <code>secondsValue</code>, und <code>msValue</code> nicht angegeben werden, werden die Rückgabewerte der Methoden {{jsxref("Date.prototype.getMinutes()", "getMinutes()")}}, {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} und {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}} genutzt.</p> + +<p>Wenn ein Parameter einen Wert außerhalb seiner Grenzen hat, wird <code>setHours()</code> das Informationen im {{jsxref("Date")}} Objekt dementsprechend ändern. Wenn zum Beispiel der Wert 100 für den Parameter <code>secondsValue</code> angegeben wird, wird die Minute um 1 inkrementiert und die Sekunden bekommen den Wert 40.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setHours()">Einsatz von <code>setHours()</code></h3> + +<pre class="brush:js">var theBigDay = new Date(); +theBigDay.setHours(7); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.34', 'Date.prototype.setHours')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.sethours', 'Date.prototype.setHours')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.sethours', 'Date.prototype.setHours')}}</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.Date.setHours")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setmilliseconds/index.html b/files/de/web/javascript/reference/global_objects/date/setmilliseconds/index.html new file mode 100644 index 0000000000..51f2e069ab --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setmilliseconds/index.html @@ -0,0 +1,90 @@ +--- +title: Date.prototype.setMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setMilliseconds()</code></strong> Methode setzt die Millisekunden einer Zeit bezüglich der Ortszeit.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setmilliseconds.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMilliseconds(<var>millisecondsValue</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>millisecondsValue</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 999, welche die Millisekunden repräsentiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem geänderten date Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn der Parameter außerhalb seiner Grenzen definiert wird, wird diese Information bei der änderung des {{jsxref("Date")}} Objektes beachtet. Wenn zum Beispiel 1005 übergeben wird, wird die Sekunde um 1 inkrementiert und die Millisekunden werden auf 5 gesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setMilliseconds()">Einsatz von <code>setMilliseconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setMilliseconds(100); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.28', 'Date.prototype.setMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setmilliseconds', 'Date.prototype.setMilliseconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setmilliseconds', 'Date.prototype.setMilliseconds')}}</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.Date.setMilliseconds")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setminutes/index.html b/files/de/web/javascript/reference/global_objects/date/setminutes/index.html new file mode 100644 index 0000000000..75918fb16b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setminutes/index.html @@ -0,0 +1,100 @@ +--- +title: Date.prototype.setMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/setMinutes +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setMinutes()</code></strong> Methode setzt die Minuten für ein Datum (Zeit) bezüglich der Ortszeit</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setminutes.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre> + +<h3 id="Versionen_vor_JavaScript_1.3">Versionen vor JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>minutesValue</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 59, die die Minuten repräsentiert.</dd> + <dt><code>secondsValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 59, die die Sekunden repräsentiert.</dd> + <dt><code>msValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 999, die die Millisekunden repräsentiert. Wenn der Parameter <code>msValue</code> angegeben ist, muss auch der Parameter <code>secondsValue</code> angegeben werden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem geänderten date Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn die Parameter <code>secondsValue</code> and <code>msValue</code> nicht angegeben werden, wird die Rückgabewerte der Methoden {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} und {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}} eingesetzt.</p> + +<p>Wenn der Wert eines Parameters außerhalb seiner Grenzen liegt, wird dieses von der <code>setMinutes()</code> Methode berücksichtigt. Wenn zum Beispiel 100 für den Parameter <code>secondsValue</code> genutzt wird, werden die Minuten um 1 inkrementiert und die Sekunden werden auf 40 gesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setMinutes()">Einsatz von <code>setMinutes()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setMinutes(45); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.32', 'Date.prototype.setMinutes')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setminutes', 'Date.prototype.setMinutes')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setminutes', 'Date.prototype.setMinutes')}}</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.Date.setMinutes")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setmonth/index.html b/files/de/web/javascript/reference/global_objects/date/setmonth/index.html new file mode 100644 index 0000000000..02d659ad50 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setmonth/index.html @@ -0,0 +1,103 @@ +--- +title: Date.prototype.setMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/setMonth +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setMonth()</code></strong> Methode setzt den Monat eines Datums bezüglich des aktuellen Jahres.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setmonth.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre> + +<h3 id="Versionen_vor_JavaScript_1.3">Versionen vor JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setMonth(<var>monthValue</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>monthValue</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 11, die die Monate Januar bis Dezember repräsentiert.</dd> + <dt><code>dayValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 1 und 31, die die Tage eines Monats repräsentiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem geänderten date Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn der <code>dayValue</code> Parameter nicht gesetzt wird, bekommt er den Rückgabewert der {{jsxref("Date.prototype.getDate()", "getDate()")}} Methode.</p> + +<p>Wenn ein Parameter mit einem Wert außerhalb seiner Grenzen übergebn wird, berücksichtigt die <code>setMonth()</code> Methode diese Information in dem {{jsxref("Date")}} Objekt. Wird zum Beispiel der Wert 15 für den <code>monthValue</code> Parameter übergeben, so wird das Jahr um 1 inkrementiert und der Monat auf dem Wert 3 gesetzt.</p> + +<p>Der aktuelle Tag des Monats hat einen Einfluss auf diese Methode. Konzeptionell wird die Anzahl der Tage des aktuellen Monats hinzugefügt, um zum 1. des neuen Monats zu bekommen. Wird zum Beispiel auf dem 31. August 2016 setMonth mit dem Wert 1 aufgerufen, so wird der 2. März 2016 zurückgegeben. Dieses liegt daran, dass der Februar im Jahr 2016 nur 29 Tage hat.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setMonth()">Einsatz von <code>setMonth()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setMonth(6); + +//Achtet auf die Übergänge am Ende des Monats +var endOfMonth = new Date(2016, 7, 31); +endOfMonth.setMonth(1); +console.log(endOfMonth); //Wed Mar 02 2016 00:00:00 +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.38', 'Date.prototype.setMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setmonth', 'Date.prototype.setMonth')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setmonth', 'Date.prototype.setMonth')}}</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.Date.setMonth")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setseconds/index.html b/files/de/web/javascript/reference/global_objects/date/setseconds/index.html new file mode 100644 index 0000000000..9a10f186ec --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setseconds/index.html @@ -0,0 +1,98 @@ +--- +title: Date.prototype.setSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setSeconds +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setSeconds()</code></strong> Methode setzt die Sekunden eines Datums bezüglich der Ortzseit.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setseconds.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre> + +<h3 id="Versionen_vor_JavaScript_1.3">Versionen vor JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>secondsValue</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 59, die die Sekunden repräsentiert.</dd> + <dt><code>msValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 999, die die Millisekunden repräsentiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem geänderten date Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn der Parameter <code>msValue</code> nicht gesetzt ist, wird der Rückgabewert der Methode {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}} eingesetzt.</p> + +<p>Wenn der Wert eines Parameters seine Grenzen überschreitet, wird die <code>setSeconds()</code> Methode diese Information in dem {{jsxref("Date")}} Objekt berücksichtigen. Wenn zum Beispiel für den Parameter <code>secondsValue</code> der Wert 100 benutzt wird, werden die Minuten um 1 inkrementiert und und für die Sekunden wird der Wert 40 benutzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setSeconds()">Einsatz von <code>setSeconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setSeconds(30); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.30', 'Date.prototype.setSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setseconds', 'Date.prototype.setSeconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setseconds', 'Date.prototype.setSeconds')}}</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.Date.setSeconds")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/settime/index.html b/files/de/web/javascript/reference/global_objects/date/settime/index.html new file mode 100644 index 0000000000..aaf72c378a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/settime/index.html @@ -0,0 +1,91 @@ +--- +title: Date.prototype.setTime() +slug: Web/JavaScript/Reference/Global_Objects/Date/setTime +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setTime +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>setTime()</code></strong> setzt das {{jsxref("Date")}} Objekt auf die Zeit, die durch eine Anzahl Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC angegeben wird.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-settime.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setTime(<var>timeValue</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>timeValue</code></dt> + <dd>Ein integer, der die Anzahl Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC angibt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem geänderten date Objekt (effektiv dem Wert des übergebenen Parameters).</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die Methode <code>setTime()</code> ist hilfreich, um Datum und Zeit einem anderen {{jsxref("Date")}} Objekt zuzuweisen.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_setTime" name="Example:_Using_setTime">Einsatz von <code>setTime()</code></h3> + +<pre class="brush: js">var theBigDay = new Date('July 1, 1999'); +var sameAsBigDay = new Date(); +sameAsBigDay.setTime(theBigDay.getTime()); +</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>Erste Definition. Implementiert JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.27', 'Date.prototype.setTime')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}</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.Date.setTime")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getTime()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setutcdate/index.html b/files/de/web/javascript/reference/global_objects/date/setutcdate/index.html new file mode 100644 index 0000000000..15f05b5109 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setutcdate/index.html @@ -0,0 +1,90 @@ +--- +title: Date.prototype.setUTCDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setUTCDate()</code></strong> Methode setzt den Monatstag eines Datums bezüglich der Weltzeit.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcdate.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCDate(<var>dayValue</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>dayValue</code></dt> + <dd>Eine ganze Zahl zwischen 1 und 31, die die Date eines Monats repräsentiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem aktualisierten date Objekte.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn ein Parameter außerhalb seiner spezifizierten Grenzen liegt, berücksichtigt die <code>setUTCDate()</code> Methode diese Information beim aktualisieren eines {{jsxref("Date")}} Objektes. Wenn zum Beispiel 40 für <code>dayValue</code> angegeben wird, so wird ein {{jsxref("Date")}} Objekt mit dem Monat Juni auf den Tag 10 und den Monat Juli (Monat um 1 inkrementiert) aktualisiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setUTCDate()">Einsatz von <code>setUTCDate()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCDate(20); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.37', 'Date.prototype.setUTCDate')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcdate', 'Date.prototype.setUTCDate')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcdate', 'Date.prototype.setUTCDate')}}</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.Date.setUTCDate")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setutcfullyear/index.html b/files/de/web/javascript/reference/global_objects/date/setutcfullyear/index.html new file mode 100644 index 0000000000..c901540225 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setutcfullyear/index.html @@ -0,0 +1,96 @@ +--- +title: Date.prototype.setUTCFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setUTCFullYear()</code></strong> Methode setzt das volle Jahr für ein Datum bezüglich der Weltzeit.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcfullyear.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>yearValue</code></dt> + <dd>Eine ganze Zahl, die das Jahr repräsentiert (z. B. 1995).</dd> + <dt><code>monthValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 11, die die Monate Januar bis Dezember repräsentiert.</dd> + <dt><code>dayValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 1 und 31, die den Tag eines Monats repräsentiert. Wenn <code>dayValue</code> benutzt wird, muss auch der Parameter <code>monthValue</code> benutzt werden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem aktualisierten date Objekte.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn die Parameter <code>monthValue</code> und <code>dayValue</code> nicht angegeben werden, so werden für diese die Rückgabewerte der Methoden {{jsxref("Date.prototype.getUTCMonth()", "getUTCMonth()")}} und {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}} benutzt.</p> + +<p>Wenn ein Parameter außerhalb seiner spezifizierten Grenzen liegt, berücksichtigt die <code>setUTCFullYear()</code> Methode diese Information beim aktualisieren eines {{jsxref("Date")}} Objektes. Wenn zum Beispiel 15 für <code>monthValue</code> angegeben wird, so wird das Jahr um 1 inkrementiert (<code>yearValue + 1</code>) und der Monat wird auf 3 gesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setUTCFullYear()">Einsatz von <code>setUTCFullYear()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCFullYear(1997); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.41', 'Date.prototype.setUTCFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcfullyear', 'Date.prototype.setUTCFullYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcfullyear', 'Date.prototype.setUTCFullYear')}}</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.Date.setUTCFullYear")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setutchours/index.html b/files/de/web/javascript/reference/global_objects/date/setutchours/index.html new file mode 100644 index 0000000000..6194eceb91 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setutchours/index.html @@ -0,0 +1,98 @@ +--- +title: Date.prototype.setUTCHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setUTCHours()</code></strong> Methode setzt die Stunde eines Datums (mit Zeit) bezüglich der Weltzeit und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC nach dem Aktualisieren der {{jsxref("Date")}} Instanz zurück-</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutchours.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>hoursValue</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 23, die die Stunden repräsentiert.</dd> + <dt><code>minutesValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 and 59, die die Minuten repräsentiert.</dd> + <dt><code>secondsValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 and 59, die die Sekunden repräsentiert. Wenn der <code>secondsValue</code> Parameter angegeben wird, muss auch der <code>minutesValue</code> Parameter angegeben werden.</dd> + <dt><code>msValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 and 999, die die Millisekunden repräsentiert. Wenn der <code>msValue</code> Parameter angegeben ist, müssen auch die Parameter <code>minutesValue</code> und <code>secondsValue</code> angegeben werden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem aktualisierten date Objekte.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn die Parameter <code>minutesValue</code>, <code>secondsValue</code>, und <code>msValue</code> nicht angegeben werden, wird für diese der Rückgabewert der Methoden {{jsxref("Date.prototype.getUTCMinutes()", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}}, und {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}} verwendet.</p> + +<p>Wenn ein Parameter außerhalb seiner Grenzen angegeben wird, wird die <code>setUTCHours()</code> Methode diese Information beim aktualisieren des {{jsxref("Date")}} Objektes berücksichtigen. Wenn zum Beispiel 100 für den <code>secondsValue</code> Parameter genutzt wird, werden die Minuten um 1 inkrementiert (<code>minutesValue + 1</code>) und der Wert 40 wird für die Sekunden verwendet.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setUTCHours()">Einsatz von <code>setUTCHours()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCHours(8); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.35', 'Date.prototype.setUTCHours')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutchours', 'Date.prototype.setUTCHours')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setutchours', 'Date.prototype.setUTCHours')}}</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.Date.setUTCHours")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html b/files/de/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html new file mode 100644 index 0000000000..14cbca2f90 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html @@ -0,0 +1,90 @@ +--- +title: Date.prototype.setUTCMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setUTCMilliseconds()</code></strong> Methode setzt die Millisekunden eines Datums bezüglich der Weltzeit</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcmilliseconds.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMilliseconds(<var>millisecondsValue</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>millisecondsValue</code></dt> + <dd>Eine Zahl zwischen 0 und 999, die die Millisekunden repräsentiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem aktualisierten date Objekte.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn ein Parameter außerhalb seiner spezifizierten Grenzen liegt, berücksichtigt die <code>setUTCMilliseconds</code><code>()</code> Methode diese Information beim aktualisieren eines {{jsxref("Date")}} Objektes. Wenn zum Beispiel 1100 für <code>millisecondsValue</code> angegeben wird, so werden die Sekunden um 1 inkrementiert und die Millisekunden werden auf 100 gesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setUTCMilliseconds()">Einsatz von <code>setUTCMilliseconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCMilliseconds(500); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.29', 'Date.prototype.setUTCMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcmilliseconds', 'Date.prototype.setUTCMilliseconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcmilliseconds', 'Date.prototype.setUTCMilliseconds')}}</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.Date.setUTCMilliseconds")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setutcminutes/index.html b/files/de/web/javascript/reference/global_objects/date/setutcminutes/index.html new file mode 100644 index 0000000000..b56abc94d6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setutcminutes/index.html @@ -0,0 +1,96 @@ +--- +title: Date.prototype.setUTCMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setUTCMinutes()</code></strong> Methode setzt die Minuten eines Datums bezüglich der Weltzeit.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcminutes.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>minutesValue</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 59, die die Minuten repräsentiet.</dd> + <dt><code>secondsValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 59, die die Sekunden repräsentiert.</dd> + <dt><code>msValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 999, die die Millisekunden repräsentiert. Wenn der Parameter <code>msValue</code> angegeben wird, muss auch der Parameter <code>secondsValue</code> gesetzt werden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem aktualisierten date Objekte.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn die Parameter <code>secondsValue</code> und <code>msValue</code> nicht angegeben werden, so werden für diese die Rückgabewerte der Methoden {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} und {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}} benutzt.</p> + +<p>Wenn ein Parameter außerhalb seiner spezifizierten Grenzen liegt, berücksichtigt die <code>setUTCMinutes</code><code>()</code> Methode diese Information beim aktualisieren eines {{jsxref("Date")}} Objektes. Wenn zum Beispiel 100 für <code>secondsValue</code> angegeben wird, so werden die Minuten um 1 inkrementiert (<code>minutesValue + 1</code>) und die Sekunden werden auf 40 gesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setUTCMinutes()">Einsatz von <code>setUTCMinutes()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCMinutes(43); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.33', 'Date.prototype.setUTCMinutes')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcminutes', 'Date.prototype.setUTCMinutes')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcminutes', 'Date.prototype.setUTCMinutes')}}</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.Date.setUTCMinutes")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setutcmonth/index.html b/files/de/web/javascript/reference/global_objects/date/setutcmonth/index.html new file mode 100644 index 0000000000..d4f393051d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setutcmonth/index.html @@ -0,0 +1,94 @@ +--- +title: Date.prototype.setUTCMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setUTCMonth()</code></strong> Methode setzt den Monat eines Datums bezüglich der Weltzeit.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcmonth.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>monthValue</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 11, die die Monate Januar bis Dezember repräsentiert.</dd> + <dt><code>dayValue</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 1 und 31, die den Tag eines Monats repräsentiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem aktualisierten date Objekte.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn die Parameter <code>dayValue</code> nicht angegeben werden, so wird für diesen der Rückgabewert der Methode {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}} benutzt.</p> + +<p>Wenn ein Parameter außerhalb seiner spezifizierten Grenzen liegt, berücksichtigt die <code>setUTCMonth()</code> Methode diese Information beim aktualisieren eines {{jsxref("Date")}} Objektes. Wenn zum Beispiel 15 für <code>monthValue</code> angegeben wird, so wird das Jahr um 1 inkrementiert und der Monat wird auf 3 gesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setUTCMonth()">Einsatz von <code>setUTCMonth()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCMonth(11); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.39', 'Date.prototype.setUTCMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcmonth', 'Date.prototype.setUTCMonth')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcmonth', 'Date.prototype.setUTCMonth')}}</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.Date.setUTCMonth")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setutcseconds/index.html b/files/de/web/javascript/reference/global_objects/date/setutcseconds/index.html new file mode 100644 index 0000000000..52ce280245 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setutcseconds/index.html @@ -0,0 +1,94 @@ +--- +title: Date.prototype.setUTCSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>setUTCSeconds()</code></strong> Methode setzt die Sekunden eines Datums bezüglich der Weltzeit.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcseconds.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setUTCSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>secondsValue</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 59, die die Sekunden repräsentiert.</dd> + <dt><code>msValue</code></dt> + <dd>Optional. Eine ganze Zahl zwische 0 und 999, die die Millisekunden repräsentiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem aktualisierten date Objekte.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn der Parameter <code>msValue</code> nicht angegeben wird, so wird für diesen der Rückgabewert der Methode {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}} benutzt.</p> + +<p>Wenn ein Parameter außerhalb seiner spezifizierten Grenzen liegt, berücksichtigt die <code>setUTCSeconds</code><code>()</code> Methode diese Information beim aktualisieren eines {{jsxref("Date")}} Objektes. Wenn zum Beispiel 100 für <code>secondsValue</code> angegeben wird, so werden die Minuten um 1 inkrementiert und die Sekunden werden auf 40 gesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setUTCSeconds()">Einsatz von <code>setUTCSeconds()</code></h3> + +<pre class="brush: js">var theBigDay = new Date(); +theBigDay.setUTCSeconds(20); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.31', 'Date.prototype.setUTCSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcseconds', 'Date.prototype.setUTCSeconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcseconds', 'Date.prototype.setUTCSeconds')}}</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.Date.setUTCSeconds")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/setyear/index.html b/files/de/web/javascript/reference/global_objects/date/setyear/index.html new file mode 100644 index 0000000000..8eb3627370 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/setyear/index.html @@ -0,0 +1,96 @@ +--- +title: Date.prototype.setYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/setYear +tags: + - Date + - Deprecated + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setYear +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<div>Die <strong><code>setYear()</code></strong> Methode setzt das Jahr für eine Datum bezüglich der Ortszeit. Weil <code>setYear()</code> nicht das volle Jahr setzt ("Jahr 2000 Probem"), wird es nicht länger eingesetzt und wird von der Methode {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} ersetzt. </div> + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setYear(<var>yearValue</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>yearValue</code></dt> + <dd>Eine ganze Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem geänderten date Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn <code>yearValue</code> eine Nummer zwische 0 und 99 (inklusiv) ist, wird das Jahr eines {{jsxref("date")}} Objekt mit dem Wert <code>1900 + yearValue</code> gesetzt. Ansernfalls wird das Jahr des Objektes mit dem Wert <code>yearValue</code> gesetzt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_setYear()">Einsatz von <code>setYear()</code></h3> + +<p>Die ersten beiden Zeilen setzen das Jahr auf 1996. Die dritte Zeile setzt das Jahr auf 2000</p> + +<pre class="brush: js">var theBigDay = new Date(); + +theBigDay.setYear(96); +theBigDay.setYear(1996); +theBigDay.setYear(2000); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.5', 'Date.prototype.setYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definiert in dem (informativen) Kompatibilitäts-Anhang</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setyear', 'Date.prototype.setYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td><span id="result_box" lang="de"><span>Definiert in</span> dem <span>(normativ)</span> <span>Anhang</span> <span>für</span> <span>zusätzliche Funktionen</span> <span>für Web-Browser</span><span>.</span></span></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.setyear', 'Date.prototype.setYear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td><span id="result_box" lang="de"><span>Definiert in</span> dem <span>(normativ)</span> <span>Anhang</span> <span>für</span> <span>zusätzliche Funktionen</span> <span>für Web-Browser</span><span>.</span></span></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.Date.setYear")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/todatestring/index.html b/files/de/web/javascript/reference/global_objects/date/todatestring/index.html new file mode 100644 index 0000000000..00440243e6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/todatestring/index.html @@ -0,0 +1,92 @@ +--- +title: Date.prototype.toDateString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toDateString +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toDateString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toDateString()</code></strong> Methode gibt den Datumsteil eines {{jsxref("Date")}} Objektes für Menschen lesbar, im amerikanisch-englischen Format, zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-todatestring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toDateString()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der den Datumsteil des gegebenen {{jsxref("Date")}} Objektes für menschen lesbar im amerikanisch-englischen Format enthält</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("Date")}} Instanzen referenzieren einen spezifischen Zeitpunkt. Mit dem Aufruf von {{jsxref("Date.prototype.toString()", "toString()")}} wird dieser Zeitpunkt für Menschen lesbar, im amerikanisch-englischen Format, zurückgegeben. In <a href="/de/docs/SpiderMonkey">SpiderMonkey</a> enthält diese Format den Datumsteil (Tag, Monat und Jahr) gefolgt von dem Zeitteil (Stunden, Minuten, Sekunden und Zeitzone). Manchmal ist es erwünscht, nur die Zeit zu bekommen. In diesen Fällten wird die <code>toTimeString()</code> Methode eingesetzt.</p> + +<p>Die <code>toDateString()</code> Methode ist besonders nützlich, weil JavaScript-Umgebungen die <a href="/en-US/docs/ECMAScript">ECMA-262</a> implementieren. manchmal unterschiedliche Ergebnisse bei der Ausführung der {{jsxref("Date.prototype.toString()", "toString()")}} Methode eines {{jsxref("Date")}} Objektes liefern. Dieses liegt daran, weil das zurückgegebene Format der {{jsxref("Date.prototype.toString()", "toString()")}} Methode implementierungsabhängig ist, über mehrere Plattformen hinweg zu inkonsistenten Ergebnissen führen kann.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toDateString()">Einsatz von <code>toDateString()</code></h3> + +<pre class="brush: js">var d = new Date(1993, 5, 28, 14, 39, 7); + +console.log(d.toString()); // logs Wed Jun 28 1993 14:39:07 GMT-0600 (PDT) +console.log(d.toDateString()); // logs Wed Jun 28 1993 +</pre> + +<div class="note"> +<p><strong>Anmerkung:</strong> Der Monat ist 0-basiert wenn er als Argument in {{jsxref("Date")}} benutzt wird (0 entspricht Januar und 11 entspricht Dezember).</p> +</div> + +<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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.3', 'Date.prototype.toDateString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}</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.Date.toDateString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/togmtstring/index.html b/files/de/web/javascript/reference/global_objects/date/togmtstring/index.html new file mode 100644 index 0000000000..c80dfdc5b9 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/togmtstring/index.html @@ -0,0 +1,87 @@ +--- +title: Date.prototype.toGMTString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toGMTString +tags: + - Date + - Deprecated + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toGMTString +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<div>Die <strong><code>toGMTString()</code></strong> Methode konvertiert ein Datum in ein String unter Benutzung der mittleren Greenwich Zeit. Das exakte Format des Rückgabewertes der <code>toGMTString()</code> Methode variierte von Browser zu Browser. Generel wird ein für Menschen lesbarer String zurückgegeben.</div> + +<div> </div> + +<div>{{noteStart}}<code>toGMTString()</code> ist deprecated und sollte nicht mehr benutzt werden. Es ist nur noch für die Rückwärtskompatibilität vorhanden; nutzt stattdessen {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}{{noteEnd}}</div> + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toGMTString()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der das gegebene {{jsxref("Date")}} Objekt nach den Internet Greenwich Mean Zeit (GMT) Konventionen repräsentiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einfaches_Beispiel">Einfaches Beispiel</h3> + +<p>In diesem Beispiel konvertiert die <code>toGMTString()</code> Methode das {{jsxref("date")}} Objekt zu einem String mit der GMT (UTC) unter benutzung der Systemzeitzone. Die exakte Formatierung des String hängt von der Implementierung ab.</p> + +<pre class="brush: js">var today = new Date(); +var str = today.toGMTString(); // deprecated! use toUTCString() + +console.log(str); // Mon, 18 Dec 1995 17:28:35 GMT +</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, aber schon als deprecated markiert. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.6', 'Date.prototype.toGMTString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Im (informativen) Anhang B "Compatibility" definiert.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.togmtstring', 'Date.prototype.toGMTString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Im (normativen) Anhang B "Additional ECMAScript Features for Web Browsers" definiert.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.togmtstring', 'Date.prototype.toGMTString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Im (normativen) Anhang B "Additional ECMAScript Features for Web Browsers" definiert.</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.Date.toGMTString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/toisostring/index.html b/files/de/web/javascript/reference/global_objects/date/toisostring/index.html new file mode 100644 index 0000000000..8d84d65c3c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/toisostring/index.html @@ -0,0 +1,109 @@ +--- +title: Date.prototype.toISOString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toISOString +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toISOString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toISOString()</code></strong> Methode gibt einen String im einfach erweitertem ISO format (<a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>) zurück, welcher immer 24 oder 27 Zeichen lang ist (<strong><code>YYYY-MM-DDTHH:mm:ss.sssZ</code></strong> oder <strong><code>±YYYYYY-MM-DDTHH:mm:ss.sssZ</code></strong>). Die Zeitzone ist immer 0 UTC, wie es durch den Suffix "<code>Z</code>" angedeutet wird.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-toisostring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toISOString()</code> +</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der das gegebene {{jsxref("Date")}} Objekt im <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a> Format bezüglich der Weltzeit (UTC) repräsentiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Using_toISOString()">Using <code>toISOString()</code></h3> + +<pre class="brush: js">var today = new Date('05 October 2011 14:48 UTC'); + +console.log(today.toISOString()); // Returns 2011-10-05T14:48:00.000Z +</pre> + +<p>Das obere Beispiel nutzt das Einlesen eines nicht standartisierten String Wert, welcher in nicht-Mozilla Browsern manchmal nicht richtig eingelesen wird.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Die Methode wurde in ECMA-262 5th edition standartisiert. In Umgebungen, die diese Methode nicht unterstützen (z. B. weil sie nicht aktualisiert werden), kann folgende Methode genutzt werden:</p> + +<pre class="brush: js">if (!Date.prototype.toISOString) { + (function() { + + function pad(number) { + if (number < 10) { + return '0' + number; + } + return number; + } + + Date.prototype.toISOString = function() { + return this.getUTCFullYear() + + '-' + pad(this.getUTCMonth() + 1) + + '-' + pad(this.getUTCDate()) + + 'T' + pad(this.getUTCHours()) + + ':' + pad(this.getUTCMinutes()) + + ':' + pad(this.getUTCSeconds()) + + '.' + (this.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + + 'Z'; + }; + + }()); +} +</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('ES5.1', '#sec-15.9.5.43', 'Date.prototype.toISOString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.8.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.toisostring', 'Date.prototype.toISOString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.toisostring', 'Date.prototype.toISOString')}}</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.Date.toISOString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/tojson/index.html b/files/de/web/javascript/reference/global_objects/date/tojson/index.html new file mode 100644 index 0000000000..1d65876585 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/tojson/index.html @@ -0,0 +1,81 @@ +--- +title: Date.prototype.toJSON() +slug: Web/JavaScript/Reference/Global_Objects/Date/toJSON +tags: + - Date + - JavaScript + - Methode(2) + - Prototype + - Referenz +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toJSON +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toJSON()</code></strong> Methode gibt einen String zurück, der das {{jsxref("Date")}} Objekt darstellt.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-tojson.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toJSON()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der das gegebene date Objekt repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("Date")}} Instanzen repräsentieren einen bestimmten Zeitpunkt. Ein Aufruf von <code>toJSON()</code> gibt unter Verwendung von {{jsxref("Date.prototype.toISOString()", "toISOString()")}} einen String zurück, der den Wert des {{jsxref("Date")}} Objekts darstellt. Diese Methode ist dafür vorgesehen, {{jsxref("Date")}} Objekte während der {{Glossary("JSON")}} Serialisierung standardisiert zu serialisieren.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toJSON()">Einsatz von <code>toJSON()</code></h3> + +<pre class="brush:js">var jsonDate = (new Date()).toJSON(); +var backToDate = new Date(jsonDate); + +console.log(jsonDate); //2015-10-26T07:46:36.611Z +</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">Bemerkung</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.44', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Erstmalige Definition. Implementiert in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</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.Date.toJSON")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/tolocaledatestring/index.html b/files/de/web/javascript/reference/global_objects/date/tolocaledatestring/index.html new file mode 100644 index 0000000000..21248d939a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/tolocaledatestring/index.html @@ -0,0 +1,188 @@ +--- +title: Date.prototype.toLocaleDateString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString +tags: + - Date + - IANA Timezone Forma + - Internationalization + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toLocaleDateString()</code></strong> Methode gibt einen sprachsensitiven String mit dem Datumsteil des Zeitpunktes zurück. Die neuen Argumente <code>locales</code> und <code>options</code> können eingesetzt werden, um die Sprache (und damit die Formatierung) einzustellen oder benutzerdefinierte Formatierungen vorzunehmen. In älteren Implementierungen, die <code>locales</code> und <code>options</code> ignorieren, ist die Formatierung des String implementierungsabhängig.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-tolocaledatestring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dateObj</var>.toLocaleDateString([<var>locales</var> [, <var>options</var>]])</pre> + +<h3 id="Parameter">Parameter</h3> + +<p>Überprüfe das Kapitel {{anch("Browser_compatibility", "Browserkompatibilität")}}, um zu erfahren, welcher Browser die Argumente <code>locales</code> and <code>options</code> unterstützt. Zudem sollte das Beispiel {{anch("Checking_for_support_for_locales_and_options_arguments", "Unterstützung der Argumente <code>locales</code> und <code>options</code>")}} beachtet werden.</p> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameter')}}</div> + +<div>Der Standardwert für jede Eigenschaft einer Datums-Zeitkomponente ist {{jsxref("undefined")}}, wenn aber die Eigenschaften <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code> {{jsxref("undefined")}} sind, sind die Eigenschaften <code>year</code>, <code>month</code>, und <code>day</code> <code>"numeric"</code>.</div> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der den Datumsteil des gegebenen {{jsxref("Date")}} Objektes mit sprachspezifischen Konventionen repräsentiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toLocaleDateString()">Einsatz von <code>toLocaleDateString()</code></h3> + +<p>Standardeinsatz ohne Angaben zur Sprache und Formatierung. Ein formatierter String in der Standardsprache mit Standardoption wird zurückgegeben.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0)); + +// toLocaleDateString() ohne Argumente abhängig von der Implementierung, +// der Standardsprache und der Standardzeitzone. +console.log(date.toLocaleDateString()); +// → "12/11/2012" wenn in der Sprache en-US mit America/Los_Angeles Zeitzone ausgeführt +</pre> + +<h3 id="Unterstützung_der_Argumente_locales_und_options">Unterstützung der Argumente <code>locales</code> und <code>options</code></h3> + +<p>Die Argumente <code>locales</code> and <code>options</code> sind noch nicht in allen Browsern unterstützt. Um herauszufinden, ob eine Implementierung die Argumente unterstützt, kann die Anforderung benutzt werden, dass bei nicht existierenden Sprachen ein {{jsxref("RangeError")}} erzeugt wird:</p> + +<pre class="brush: js">function toLocaleDateStringSupportsLocales() { + try { + new Date().toLocaleDateString('i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<h3 id="Einsatz_von_locales">Einsatz von <code>locales</code></h3> + +<p>Das Beispiel zeigt einige Variation von internationalisierten Datumsformaten. Um das Format der Sprache der Benutzerschnittstelle (z. B. Webseite) zu bekommen, muss die Sprache (und manchmal eine Fallback-Sprache) mit dem Argument <code>locales</code> gesetzt werden:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// Die unteren Formate setzen ein lokale Zeitzone voraus: +// America/Los_Angeles für die US + +// US Englischer Einsatz von Monat-Tag-Jahr +console.log(date.toLocaleDateString('en-US')); +// → "12/19/2012" + +// British Englischer Einsatz von Tag-Monat-Jahr +console.log(date.toLocaleDateString('en-GB')); +// → "20/12/2012" + +// Koreanischer Einsatz von Jahr-Monat-Tag +console.log(date.toLocaleDateString('ko-KR')); +// → "2012. 12. 20." + +// Event für Persien. Es ist schwer manuell in Solar Hijri zu konvertieren +console.log(date.toLocaleDateString('fa-IR')); +// → "۱۳۹۱/۹/۳۰" + +// In den meisten arabischen Ländern werden arabische Ziffern genutzt. +console.log(date.toLocaleDateString('ar-EG')); +// → "<span dir="rtl">٢٠/١٢/٢٠١٢</span>" + +// Für mansche japanische Anwendungen wird er japanische Kalender benutzt, +// bei dem das Jahr 2012 das Jahr 24 der Heisei-Zeit ist. +console.log(date.toLocaleDateString('ja-JP-u-ca-japanese')); +// → "24/12/20" + +// Wenn eine Sprache angegeben wird, die vielleicht nicht unterstützt wird, +// wie Balinesisch, wird eine fallback Sprache (Indonesisch) definiert. +console.log(date.toLocaleDateString(['ban', 'id'])); +// → "20/12/2012" +</pre> + +<h3 id="Einsatz_von_options">Einsatz von <code>options</code></h3> + +<p>Das Ergebnis der <code>toLocaleDateString()</code> Methode kann benutzerdefiniert mit dem Argument <code>options</code> beeinflusst werden.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// Gibt einen Wochentag und ein langes Datum zurück. +var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }; +console.log(date.toLocaleDateString('de-DE', options)); +// → "Donnerstag, 20. Dezember 2012" + +// Macht UTC sichtbar +options.timeZone = 'UTC'; +options.timeZoneName = 'short'; +console.log(date.toLocaleDateString('en-US', options)); +// → "Thursday, December 20, 2012, GMT" +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Wenn viele Daten formatiert werden sollen, ist es besser ein {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Objekt zu erstellen und die Funktion {{jsxref("DateTimeFormat.prototype.format", "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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', 'sec-15.9.5.6', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Definition der <code>locales</code> und <code>options</code> Argumente.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleDateString', 'Date.prototype.toLocaleDateString')}}</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.Date.toLocaleDateString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/tolocaleformat/index.html b/files/de/web/javascript/reference/global_objects/date/tolocaleformat/index.html new file mode 100644 index 0000000000..f8f596983f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/tolocaleformat/index.html @@ -0,0 +1,81 @@ +--- +title: Date.prototype.toLocaleFormat() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleFormat +tags: + - Date + - Java + - Method + - Non-standard + - Prototype + - Reference +translation_of: Archive/Web/JavaScript/Date.toLocaleFormat +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die nicht standardisierte Methode <strong><code>toLocaleFormat()</code></strong> konvertiert einen {{jsxref("date")}} Objekt zu einem String im übergebenen Format. {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} ist einen standardisierte Alternative zum Formatieren von {{jsxref("Date")}} Objekten. Siehe auch die neuere Version der {{jsxref("Date.prototype.toLocaleDateString()")}} Methode an.</p> + +<div><strong>Diese Funktion wurde Entfernt und wird ab Firefox 58 nicht mehr Funktionieren.</strong> Für mehr Information un Migrationshilfe siehe in den Artikel {{jsxref("Errors/Deprecated_toLocaleFormat","Warning: Date.prototype.toLocaleFormat is deprecated")}}.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dateObj</var>.toLocaleFormat(<var>formatString</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>formatString</code></dt> + <dd>Ein Formatstring, welche im selben Format sein muss, wie es die C Funktion <a class="external" href="http://www.opengroup.org/onlinepubs/007908799/xsh/strftime.html"><code>strftime()</code></a> erwartet.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der das gegebenen {{jsxref("Date")}} Objekt im spezifizierten Format repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toLocaleFormat()</code> Methode ermöglicht es eine größere Kontrolle über das Formatieren von generierten Daten und/oder Zeiten zu haben. Namen für Monate und Wochentage werden mit den Spracheinstellungen des Betriebssystem formatiert. Die Anordnung von Tagen, Monaten und anderen Bestandteilen in der Formatierung wird nicht automatisch vorgenommen. Sie sind von den Angaben in dem Formatierungsstring abhängig. Man muss dafür sorgen, dass der Formatierungsstring zu richtigen Ergebnissen auf dem Benutzersystem führt. Man sollte vorsichtig sein, weil die Spracheinstellungen im Browser nicht die gleichen sein müssen, wie die des Betriebssystems.</p> + +<p>Extension und XULRunner Entwickler wissen, dass das Laden von Formatstring aus <code>.dtd</code> oder <code>.properties</code> Dateien mit dem Einsatz von URIs (z. B. <code>chrome://<em>somedomain</em>/locale/<em>somefile.ext</em></code>) <strong>vermieden werden sollte</strong>, weil <code>.dtd</code>/<code>.properties</code> Dateien und die <code>toLocaleFormat()</code> Methode nicht notwendiger Weise der gleichen Sprache folgen. Dieses kann zu nicht lesbaren oder merkwürdig formatierten Daten führen.</p> + +<p>Außerdem ist zu beachten, dass der Einsatz von Formatierungen abhängig von der Plattform und den benutzerdefinierten Einstellungen des Benutzers nicht immer gewollt ist. Man sollte stattdessen die allgemeineren <code>toLocale*</code> Methoden des {{jsxref("Global_Objects/Date", "Date")}} Objektes nutzen oder ein eigenes Format mit den <code>get*</code> Methoden einer {{jsxref("Global_Objects/Date", "Date")}} Instanz erstellen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toLocaleFormat()">Einsatz von <code>toLocaleFormat()</code></h3> + +<pre class="brush: js example-bad">var today = new Date(); +var date = today.toLocaleFormat('%A, %B %e, %Y'); // Schlechtes Beispiel +</pre> + +<p>Im Beispiel gibt <code>toLocaleFormat()</code> einen String wie "Mittwoch, Oktober 3, 2007" zurück. Zu beachten ist, dass der String nicht unbedingt den Sprachegegebenheiten angepasst ist, was auf die oben genannten Probleme zurückzuführen ist.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Wenn die <a href="https://github.com/abritinthebay/datejs/wiki/Format-Specifiers">DateJS</a> Bibliothek benutzt wird, kann folgender Polyfill benutzt werden:</p> + +<pre class="brush: js">if (!Date.prototype.toLocaleFormat) { + (function() { + Date.prototype.toLocaleFormat = function(formatString) { + return this.format(formatString); + }; + }()); +}</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Nicht spezifiziert. Implementiert in JavaScript 1.6.</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.Date.toLocaleFormat")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/tolocalestring/index.html b/files/de/web/javascript/reference/global_objects/date/tolocalestring/index.html new file mode 100644 index 0000000000..4db8f38c1e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/tolocalestring/index.html @@ -0,0 +1,188 @@ +--- +title: Date.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString +tags: + - Date + - Internationalization + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toLocaleString</code></strong><strong><code>()</code></strong> Methode gibt einen sprachsensitiven String mit dem Zeitpunkt zurück. Die neuen Argumente <code>locales</code> und <code>options</code> können eingesetzt werden, um die Sprache (und damit die Formatierung) einzustellen oder benutzerdefinierte Formatierungen vorzunehmen. In älteren Implementierungen, die <code>locales</code> und <code>options</code> ignorieren, ist die Formatierung des String implementierungsabhängig.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-tolocalestring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleString([<var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<p>Überprüfe das Kapitel {{anch("Browser_compatibility", "Browserkompatibilität")}}, um zu erfahren, welcher Browser die Argumente <code>locales</code> and <code>options</code> unterstützt. Zudem sollte das Beispiel {{anch("Checking_for_upport_for_locales_and_options_arguments", "Unterstützung der Argumente <code>locales</code> und <code>options</code>")}} beachtet werden.</p> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameter')}}</div> + +<div> </div> + +<div>Der Standardwert für jede Eigenschaft einer Datums-Zeitkomponente ist {{jsxref("undefined")}}, wenn aber die Eigenschaften <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, <code>second</code> {{jsxref("undefined")}} sind, sind die Eigenschaften <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code> und <code>second</code> <code>"numeric"</code>.</div> + +<div> </div> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der das gegebenen {{jsxref("Date")}} Objektes mit sprachspezifischen Konventionen repräsentiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toLocaleString()">Einsatz von <code>toLocaleString()</code></h3> + +<p>Standardeinsatz ohne Angaben zur Sprache und Formatierung. Ein formatierter String in der Standardsprache mit Standardoption wird zurückgegeben.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0)); + +// toLocaleString() ohne Argumente abhängig von der Implementierung, +// der Standardsprache und der Standardzeitzone. +console.log(date.toLocaleString()); +// → "12/11/2012, 7:00:00 PM" wenn in der Sprache en-US mit America/Los_Angeles Zeitzone ausgeführt +</pre> + +<h3 id="Unterstützung_der_Argumente_locales_und_options">Unterstützung der Argumente <code>locales</code> und <code>options</code></h3> + +<p>Die Argumente <code>locales</code> and <code>options</code> sind noch nicht in allen Browsern unterstützt. Um herauszufinden, ob eine Implementierung die Argumente unterstützt, kann die Anforderung benutzt werden, dass bei nicht existierenden Sprachen ein {{jsxref("RangeError")}} erzeugt wird:</p> + +<pre class="brush: js">function toLocaleStringSupportsLocales() { + try { + new Date().toLocaleString('i'); + } catch (e) { + return e instanceof RangeError; + } + return false; +} +</pre> + +<h3 id="Einsatz_von_locales">Einsatz von <code>locales</code></h3> + +<p>Das Beispiel zeigt einige Variation von internationalisierten Datums- und Zeitformaten. Um das Format der Sprache der Benutzerschnittstelle (z. B. Webseite) zu bekommen, muss die Sprache (und manchmal eine fallback Sprache) mit dem Argument <code>locales</code> gesetzt werden:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// US englischer einsatz mit Monat-Tag-Jahr und 12-Stunden Zeit mit AM/PM +console.log(date.toLocaleString('en-US')); +// → "12/19/2012, 7:00:00 PM" + +// Britisch englischer Einsatz mit Tag-Monat-Jahr und 24-Stunden Zeit ohne AM/PM +console.log(date.toLocaleString('en-GB')); +// → "20/12/2012 03:00:00" + +// Koreanischer Einsatz mit Jahr-Monat-Tag und 12-Stunden Zeit mit AM/PM +console.log(date.toLocaleString('ko-KR')); +// → "2012. 12. 20. 오후 12:00:00" + +// In den meisten arabischen Ländern werden arabische Ziffern genutzt. +console.log(date.toLocaleString('ar-EG')); +// → "<span dir="rtl">٢٠/١٢/٢٠١٢ ٥:٠٠:٠٠ ص</span>" + +// Für mansche japanische Anwendungen wird er japanische Kalender benutzt, +// bei dem das Jahr 2012 das Jahr 24 der Heisei-Zeit ist. +console.log(date.toLocaleString('ja-JP-u-ca-japanese')); +// → "24/12/20 12:00:00" + +// Wenn eine Sprache angegeben wird, die vielleicht nicht unterstützt wird, +// wie Balinesisch, wird eine fallback Sprache (Indonesisch) definiert. +console.log(date.toLocaleString(['ban', 'id'])); +// → "20/12/2012 11.00.00" +</pre> + +<h3 id="Einsatz_von_options">Einsatz von <code>options</code></h3> + +<p>Das Ergebnis der <code>toLocaleString</code><code>()</code> Methode kann benutzerdefiniert mit dem Argument <code>options</code> beeinflusst werden.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// Gibt einen Wochentag und ein langes Datum zurück +var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }; +console.log(date.toLocaleString('de-DE', options)); +// → "Donnerstag, 20. Dezember 2012" + +// Macht UTC sichtbar +options.timeZone = 'UTC'; +options.timeZoneName = 'short'; +console.log(date.toLocaleString('en-US', options)); +// → "Thursday, December 20, 2012, GMT" + +// Manchal brauchen US-Sprachen auch 24-Stunden Zeiten +console.log(date.toLocaleString('en-US', { hour12: false })); +// → "12/19/2012, 19:00:00" +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Wenn viele Daten formatiert werden sollen, ist es besser ein {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Objekt zu erstellen und die Funktion {{jsxref("DateTimeFormat.prototype.format", "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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.5', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Definition der <code>locales</code> und <code>options</code> Argumente.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleString', 'Date.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.Date.toLocaleString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/tolocaletimestring/index.html b/files/de/web/javascript/reference/global_objects/date/tolocaletimestring/index.html new file mode 100644 index 0000000000..da74e548cf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/tolocaletimestring/index.html @@ -0,0 +1,177 @@ +--- +title: Date.prototype.toLocaleTimeString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString +tags: + - Date + - Internationalization + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toLocaleTimeString</code></strong><strong><code>()</code></strong> Methode gibt einen sprachsensitiven String mit dem Zeitsteil des Zeitpunktes zurück. Die neuen Argumente <code>locales</code> und <code>options</code> können eingesetzt werden, um die Sprache (und damit die Formatierung) einzustellen oder benutzerdefinierte Formatierungen vorzunehmen. In älteren Implementierungen, die <code>locales</code> und <code>options</code> ignorieren, ist die Formatierung des String implementierungsabhängig.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-tolocaletimestring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleTimeString([<var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<p>Überprüfe das Kapitel {{anch("Browser_compatibility", "Browserkompatibilität")}}, um zu erfahren, welcher Browser die Argumente <code>locales</code> and <code>options</code> unterstützt. Zudem sollte das Beispiel {{anch("Checking_for_support_for_locales_and_options_arguments", "Unterstützung der Argumente <code>locales</code> und <code>options</code>")}} beachtet werden.</p> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameter')}}</div> + +<div>Der Standardwert für jede Eigenschaft einer Datums-Zeitkomponente ist {{jsxref("undefined")}}, wenn aber die Eigenschaften <code>hour</code>, <code>minute</code>, <code>second</code> {{jsxref("undefined")}} sind, sind die Eigenschaften <code>hour</code>, <code>minute</code> und <code>second</code> <code>"numeric"</code>.</div> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der den Zeitteil des gegebenen {{jsxref("Date")}} Objektes mit sprachspezifischen Konventionen repräsentiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toLocaleTimeString()">Einsatz von <code>toLocaleTimeString()</code></h3> + +<p>Standardeinsatz ohne Angaben zur Sprache und Formatierung. Ein formatierter String in der Standardsprache mit Standardoption wird zurückgegeben.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0)); + +// toLocaleTimeString() ohne Argumente abhängig von der Implementierung, +// der Standardsprache und der Standardzeitzone. +console.log(date.toLocaleTimeString()); +// → "7:00:00 PM" wenn in der Sprache en-US mit America/Los_Angeles Zeitzone ausgeführt +</pre> + +<h3 id="Unterstützung_der_Argumente_locales_und_options">Unterstützung der Argumente <code>locales</code> und <code>options</code></h3> + +<p>Die Argumente <code>locales</code> and <code>options</code> sind noch nicht in allen Browsern unterstützt. Um herauszufinden, ob eine Implementierung die Argumente unterstützt, kann die Anforderung benutzt werden, dass bei nicht existierenden Sprachen ein {{jsxref("RangeError")}} erzeugt wird:</p> + +<pre class="brush: js">function toLocaleTimeStringSupportsLocales() { + try { + new Date().toLocaleTimeString('i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<h3 id="Einsatz_von_locales">Einsatz von <code>locales</code></h3> + +<p>Das Beispiel zeigt einige Variation von internationalisierten Zeitformaten. Um das Format der Sprache der Benutzerschnittstelle (z. B. Webseite) zu bekommen, muss die Sprache (und manchmal eine fallback Sprache) mit dem Argument <code>locales</code> gesetzt werden:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// die folgenden Formate setzen voraus, dass man die Zeitzone +// America/Los_Angeles für US eingestellt hat. + +// US Englische Sprache; 12-Stunden Zeit mit AM/PM +console.log(date.toLocaleTimeString('en-US')); +// → "7:00:00 PM" + +// British Englishe Sprache; 24-Stunden Zeit ohne AM/PM +console.log(date.toLocaleTimeString('en-GB')); +// → "03:00:00" + +// Koreanische Sprache; 12-Stunden Zeit mit AM/PM +console.log(date.toLocaleTimeString('ko-KR')); +// → "오후 12:00:00" + +// In den meisten arabischen Ländern werden arabische Ziffern genutzt. +console.log(date.toLocaleTimeString('ar-EG')); +// → "<span dir="rtl">٧:٠٠:٠٠ م</span>" + +// Wenn eine Sprache angegeben wird, die vielleicht nicht unterstützt wird, +// wie Balinesisch, wird eine fallback Sprache (Indonesisch) definiert. +console.log(date.toLocaleTimeString(['ban', 'id'])); +// → "11.00.00" +</pre> + +<h3 id="Einsatz_von_options">Einsatz von <code>options</code></h3> + +<p>Das Ergebnis der <code>toLocaleTimeString</code><code>()</code> Methode kann benutzerdefiniert mit dem Argument <code>options</code> beeinflusst werden.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// Macht UTC sichtbar +var options = { timeZone: 'UTC', timeZoneName: 'short' }; +console.log(date.toLocaleTimeString('en-US', options)); +// → "3:00:00 AM GMT" + +// Manchal brauchen US-Sprachen auch 24-Stunden Zeiten +console.log(date.toLocaleTimeString('en-US', { hour12: false })); +// → "19:00:00" +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Wenn viele Zeiten formatiert werden sollen, ist es besser ein {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Objekt zu erstellen und die Funktion {{jsxref("DateTimeFormat.prototype.format", "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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.7', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Definition der <code>locales</code> und <code>options</code> Argumente.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleTimeString', 'Date.prototype.toLocaleTimeString')}}</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.Date.toLocaleTimeString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/tosource/index.html b/files/de/web/javascript/reference/global_objects/date/tosource/index.html new file mode 100644 index 0000000000..12764ae672 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/tosource/index.html @@ -0,0 +1,61 @@ +--- +title: Date.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Date/toSource +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<div>Die <strong><code>toSource()</code></strong> Methode gibt eine String Repräsentation des Quelltextes des Objektes zurück.</div> + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dateObj</var>.toSource() +Date.toSource()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der den Quelltext des gegebenen {{jsxref("Date")}} Objekt repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toSource()</code> Methode gibt die folgenden Werte zurück:</p> + +<ul> + <li>Für das eingebaute {{jsxref("Date")}} Objekt, git die <code>toSource()</code> Methode den folgenden String zurück, der bedeutet, dass der Quelltext nicht verfügbar ist: + + <pre class="brush: js">function Date() { + [native code] +} +</pre> + </li> +</ul> + +<ul> + <li>Für Instanzen von {{jsxref("Date")}} gibt die <code>toSource()</code> Methode eine String Repräsentation des Quelltextes zurück.</li> +</ul> + +<p>Diese Methode wird intern von JavaScript aufgerufen und wird nicht explizit im Quelltext eingesetzt.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Kein 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.Date.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/date/tostring/index.html b/files/de/web/javascript/reference/global_objects/date/tostring/index.html new file mode 100644 index 0000000000..470fd1903c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/tostring/index.html @@ -0,0 +1,94 @@ +--- +title: Date.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toString +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toString()</code></strong> Methode gibt einen String zurück, der ein spezifisches {{jsxref("Date")}} Objekt repräsentiert.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-tostring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dateObj</var>.toString()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der das gegebene {{jsxref("Date")}} Objekt repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das {{jsxref("Date")}} Objekt überschreibt die <code>toString()</code> Methode des {{jsxref("Object")}} Objekts. Es wird nicht von {{jsxref("Object.prototype.toString()")}} geerbt. Für {{jsxref("Date")}} Objekte gibt die <code>toString()</code> Methode einen String zurück, der das Objekt repräsentiert.</p> + +<p>Die <code>toString()</code> Methode gibt immer einen String zurück, der den Zeitpunkt repräsentiert. Dieser String wird in einem amerikanisch-englischen Format zurückgegeben.</p> + +<p>JavaScript ruft die <code>toString()</code> Methode automatisch auf, wenn ein {{jsxref("Date")}} Objekte als Text-Wert benötigt wird oder wenn das Objekt in einer String-Konkatination verwendet wird.</p> + +<p><code>toString()</code> ist eine generische Methode. Wenn <code>this</code> keine Instanz vom Typ {{jsxref("Date")}} ist, gibt die Methode "Invalid Date" zurück.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toString()">Einsatz von <code>toString()</code></h3> + +<p>Im folgenden wird die Variable <code>myVar</code> mit dem Rückgabewert der <code>toString()</code> Methode eines {{jsxref("Date")}} Objektes beschrieben.</p> + +<pre class="brush: js">var x = new Date(); +myVar = x.toString(); // Weist der Variablen myVar folgenden Wert zu: + // Mon Sep 28 1998 14:36:22 GMT-0700 (PDT) +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.2', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tostring', 'Date.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tostring', 'Date.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.Date.toString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/totimestring/index.html b/files/de/web/javascript/reference/global_objects/date/totimestring/index.html new file mode 100644 index 0000000000..65d643c72a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/totimestring/index.html @@ -0,0 +1,88 @@ +--- +title: Date.prototype.toTimeString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toTimeString +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toTimeString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toDateString()</code></strong> Methode gibt den Zeitteil eines {{jsxref("Date")}} Objektes für Menschen lesbar, im amerikanisch-englischen Format, zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-totimestring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toTimeString()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der den Zeitteil des gegebenen {{jsxref("Date")}} Objektes für menschen lesbar im amerikanisch-englischen Format enthält</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("Date")}} Instanzen referenzieren einen spezifischen Zeitpunkt. Mit dem Aufruf von {{jsxref("Date.prototype.toString()", "toString()")}} wird dieser Zeitpunkt für Menschen lesbar, im amerikanisch-englischen Format, zurückgegeben. In <a href="/de/docs/SpiderMonkey">SpiderMonkey</a> enthält diese Format den Datumsteil (Tag, Monat und Jahr) gefolgt von dem Zeitteil (Stunden, Minuten, Sekunden und Zeitzone). Manchmal ist es erwünscht, nur den Datumsteil zu bekommen. In diesen Fällen wird die <code>toDateString()</code> Methode eingesetzt.</p> + +<p>Die <code>toTimeString()</code> Methode ist besonders nützlich, weil JavaScript-Umgebungen die <a href="/en-US/docs/ECMAScript">ECMA-262</a> implementieren, manchmal unterschiedliche Ergebnisse bei der Ausführung der {{jsxref("Date.prototype.toString()", "toString()")}} Methode eines {{jsxref("Date")}} Objektes liefern. Dieses liegt daran, weil das zurückgegebene Format der {{jsxref("Date.prototype.toString()", "toString()")}} Methode implementierungsabhängig ist und über mehrere Plattformen hinweg zu inkonsistenten Ergebnissen führen kann.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toTimeString()">Einsatz von <code>toTimeString()</code></h3> + +<pre class="brush: js">var d = new Date(1993, 6, 28, 14, 39, 7); + +console.log(d.toString()); // logs Wed Jul 28 1993 14:39:07 GMT-0600 (PDT) +console.log(d.toTimeString()); // logs 14:39:07 GMT-0600 (PDT) +</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.4', 'Date.prototype.toTimeString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.totimestring', 'Date.prototype.toTimeString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.totimestring', 'Date.prototype.toTimeString')}}</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.Date.toTimeString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/toutcstring/index.html b/files/de/web/javascript/reference/global_objects/date/toutcstring/index.html new file mode 100644 index 0000000000..02dc9d414b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/toutcstring/index.html @@ -0,0 +1,84 @@ +--- +title: Date.prototype.toUTCString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toUTCString +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toUTCString +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toUTCString()</code></strong> Methode konvertiert ein {{jsxref("Date")}} in einen String. Dabei wird die UTC Zeitzone verwendet.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-toutcstring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toUTCString()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der das gegebene {{jsxref("Date")}} Objekt mit Zuhilfenahme der UTC Zeitzonen repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Der Rückgabewert der <code>toUTCString()</code> Methode ist ein für menschen lesbarer String, der die UTC Zeitzone nutzt. Das Format des zurückgegebenen String kann von Plattform zu Plattform variieren. Der am häufigsten eingesetzte Wert ist ein RFC-1123 formatierter Zeitstempel, welcher ein Update des Zeitstempels in der Version RFC-822 ist.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_toUTCString()">Einsatz von <code>toUTCString()</code></h3> + +<pre class="brush: js">var today = new Date('Wed, 14 Jun 2017 00:00:00 PDT'); +var UTCstring = today.toUTCString(); // Wed, 14 Jun 2017 07:00:00 GMT +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.42', 'Date.prototype.toUTCString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.toutcstring', 'Date.prototype.toUTCString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.toutcstring', 'Date.prototype.toUTCString')}}</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.Date.toUTCString")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toISOString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/utc/index.html b/files/de/web/javascript/reference/global_objects/date/utc/index.html new file mode 100644 index 0000000000..56aa3fde32 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/utc/index.html @@ -0,0 +1,133 @@ +--- +title: Date.UTC() +slug: Web/JavaScript/Reference/Global_Objects/Date/UTC +tags: + - Date + - JavaScript + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Date.UTC()</code></strong> Methode akzeptiert die gleichen Parameter, wie der längste Konstruktor von {{jsxref("Date")}} und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 UTC zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-utc.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Date.UTC(<var>year</var>, <var>month</var>[, <var>day</var>[, <var>hour</var>[, <var>minute</var>[, <var>second</var>[, <var>millisecond</var>]]]]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>year</code></dt> + <dd>Ein volles Jahr</dd> + <dt><code>month</code></dt> + <dd>Eine ganze Zahl zwischen 0 und 11, die den Monat repräsentiert.</dd> + <dt><code>day</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 1 und 31 den Tag des Monats repräsentiert.</dd> + <dt><code>hour</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 23, die die Stunde des Tages repräsentiert.</dd> + <dt><code>minute</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 59, die die Minute der Stunde repräsentiert.</dd> + <dt><code>second</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 59, die die Sekunden der Minute repräsentiert.</dd> + <dt><code>millisecond</code></dt> + <dd>Optional. Eine ganze Zahl zwischen 0 und 999, die die Millisekunden einer Sekunde repräsentiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Zahl, die die Anzahl der Millisekunden des gegebenen {{jsxref("Date")}} Objektes, die seit dem 1. Januar 1970 00:00:00 Weltzeit (UTC) vergangen sind, repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>UTC()</code> Methode bekommt mit Komma getrennte Parameter des Datums / der Zeit und gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 in Weltzeit zurück.</p> + +<p>Es muss ein volles Jahr für <code>year</code> spezifiziert werden (z. B. 1998). Wenn ein Jahr zwischen 0 und 99 ist, wird die Methode das Jahr zu einem Jahr im zwanzigsten Jahrhundert konvertieren (<code>1900 + year</code>). Zum Beispiel wird 95 zu 1995 konvertiert.</p> + +<p>Die <code>UTC()</code> Methode unterscheidet sich in zwei Punkten von dem {{jsxref("Date")}} Konstruktor:</p> + +<ul> + <li><code>Date.UTC()</code> benutzt die Weltzeit anstatt der Ortszeit.</li> + <li><code>Date.UTC()</code> gibt die Zeit als Ganzzahl zurück anstatt ein {{jsxref("Date")}} Objekt zu erzeugen.</li> +</ul> + +<p>Wenn ein Parameter außerhalb seiner spezifizierten Grenzen ist, wird die <code>UTC()</code> Methode andere Parameter verändern, um den Wert zu realisieren. Wird zum Beispiel 15 als Monat angegeben, so wird das Jahr um 1 inkrementiert (<code>year + 1</code>) und der Monat wird auf 3 gesetzt.</p> + +<p>Weil <code>UTC()</code> eine statische Methode von {{jsxref("Date")}} ist, wird sie immer als <code>Date.UTC()</code> genutzt und nicht als Methode einer {{jsxref("Date")}} Instanz.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Date.UTC()">Einsatz von <code>Date.UTC()</code></h3> + +<p>Im folgenden Beispiel wird ein {{jsxref("Date")}} Objekt mithilfe der UTC (nicht der Ortszeit) erstellt:</p> + +<pre class="brush:js">var utcDate = new Date(Date.UTC(2018, 11, 1, 0, 0, 0)); +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.utc', 'Date.UTC')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.utc', 'Date.UTC')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.4.3', 'Date.UTC')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</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.Date.UTC")}}</p> + +<h2 id="Anmerkungen_zur_Kompatibilität">Anmerkungen zur Kompatibilität</h2> + +<h3 id="Date.UTC_mit_weniger_als_zwei_Argumenten"><code>Date.UTC</code> mit weniger als zwei Argumenten</h3> + +<p>Wenn <code>Date.UTC</code> weniger als zwei Argumenten erhält, wird {{jsxref("NaN")}} zurückgegeben. Dieses Verhalten wurde in ECMAScript 2017 spezifiziert. Umgebungen, welche dieses Verhalten nicht unterstützen, werden aktualisiert (siehe {{bug(1050755)}}, <a href="https://github.com/tc39/ecma262/pull/642">ecma-262 #642</a>).</p> + +<pre class="brush: js">Date.UTC(); +Date.UTC(1); + +// Safari: NaN +// Chrome/Opera/V8: NaN + +// Firefox <54: nicht NaN +// Firefox 54+: NaN + +// IE: nicht NaN +// Edge: NaN +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.parse()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/date/valueof/index.html b/files/de/web/javascript/reference/global_objects/date/valueof/index.html new file mode 100644 index 0000000000..18f540fa4d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/date/valueof/index.html @@ -0,0 +1,85 @@ +--- +title: Date.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Date/valueOf +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/valueOf +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>valueOf()</code></strong> Methode gibt den primitiven Wert eines {{jsxref("Date")}} Objektes zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-valueof.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.valueOf()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der Millisekunden zwischen dem 1. Januar 1970 00:00:00 UTC und dem gegebenen date Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>valueOf()</code> Methode gibt den primitiven Wert eines {{jsxref("Date")}} Objektes als Nummern-Datentyp (number) zurück. Diese Nummer entspricht der Anzahl der Millisekunden seit dem 1. Januar 1970 UTC.</p> + +<p>Diese Methode hat den gleiche Funktionsumfang wie die {{jsxref("Date.prototype.getTime()")}} Methode.</p> + +<p>Diese Methode wird intern von JavaScript aufgerufen und muss nicht explizit im Quelltext verwendet werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_valueOf()">Einsatz von <code>valueOf()</code></h3> + +<pre class="brush: js">var x = new Date(56, 6, 17); +var myVar = x.valueOf(); // schreibt -424713600000 auf myVar +</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.9.5.8', 'Date.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.valueof', 'Date.prototype.valueOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.valueof', 'Date.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.Date.valueOf")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> + <li>{{jsxref("Date.prototype.getTime()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/decodeuricomponent/index.html b/files/de/web/javascript/reference/global_objects/decodeuricomponent/index.html new file mode 100644 index 0000000000..7eb2c2c905 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/decodeuricomponent/index.html @@ -0,0 +1,127 @@ +--- +title: decodeURIComponent() +slug: Web/JavaScript/Reference/Global_Objects/decodeURIComponent +translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die Funktion <code><strong>decodeURIComponent()</strong> dekodiert eine URI-Komponente die zuvor durch </code>{{jsxref("encodeURIComponent")}} (oder einer ähnlichen Funktion) kodiert wurden.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>decodeURIComponent(<em>encodedURI</em>)</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>encodedURI</code></dt> + <dd>Die kodierte Komponente einer URI.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer String der die decodierte Version der übergebenen URI-Komponente repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Ersetzt jede Escape-Sequenz der übergebenen kodierten Komponente durch ihre entsprechenden Zeichen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Dekodieren_einer_kyrillischen_URL-Komponente">Dekodieren einer kyrillischen URL-Komponente</h3> + +<pre class="brush: js">decodeURIComponent("JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B"); +// "JavaScript_шеллы" +</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>Anfangs-Definition</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.3.2', 'decodeURIComponent')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-decodeuricomponent-encodeduricomponent', 'decodeURIComponent')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-decodeuricomponent-encodeduricomponent', 'decodeURIComponent')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe">Siehe</h2> + +<ul> + <li>{{jsxref("decodeURI")}}</li> + <li>{{jsxref("encodeURI")}}</li> + <li>{{jsxref("encodeURIComponent")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/encodeuri/index.html b/files/de/web/javascript/reference/global_objects/encodeuri/index.html new file mode 100644 index 0000000000..2b8521f9e7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/encodeuri/index.html @@ -0,0 +1,163 @@ +--- +title: encodeURI() +slug: Web/JavaScript/Reference/Global_Objects/encodeURI +translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die <code><strong>encodeURI()</strong></code> Funktion kodiert ein Uniform Resource Identifier (Abk. URI, englisch für einheitlicher Bezeichner für Ressurcen), indem sie jedes Vorkommen von speziellen Zeichen durch die jeweilige UTF-8 Zeichenkette ersetzt, die das Zeichen repräsentiert.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>encodeURI(<em>URI</em>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>URI</code></dt> + <dd>Ein vollständiger Uniform Resource Identifier.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Ein neuer String, kodiert als Uniform Resource Identifier (URI).</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die Funktion geht davon aus, dass die URI eine richtige URI ist, sodass sie keine Zeichen kodiert die spezielle Bedeutungen haben.</p> + +<p><code>encodeURI</code> ersetzt alle Zeichen <strong>außer </strong>die folgenden<strong> </strong>mit ihrer zugehörigen UTF-8 Escape-Sequenz:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">Typ</td> + <td class="header">Beinhaltet</td> + </tr> + <tr> + <td>Zurückgehaltene Zeichen</td> + <td><code>;</code> <code>,</code> <code>/</code> <code>?</code> <code>:</code> <code>@</code> <code>&</code> <code>=</code> <code>+</code> <code>$</code></td> + </tr> + <tr> + <td>Unescapte </td> + <td>alphanumerische Zeichen, <code>-</code> <code>_</code> <code>.</code> <code>!</code> <code>~</code> <code>*</code> <code>'</code> <code>(</code> <code>)</code></td> + </tr> + <tr> + <td>Zeichen für Nummern</td> + <td><code>#</code></td> + </tr> + </tbody> +</table> + +<p>Beachten Sie, dass die <code>encodeURI</code> Funktion keine richtigen HTTP GET und POST Requests erzeugen kann, wie für XMLHTTPRequests benötigt, da "&", "+", und "=" nicht kodiert werden. Diese werden in GET und POST als spezielle Zeichen behandelt. Für solche Verwendungen steht die {{jsxref("encodeURIComponent")}} Funktion zur Verfügung.</p> + +<p>Beachten Sie auch, dass ein {{jsxref("URIError")}} erzeugt wird, sobald versucht wird, ein <a href="https://de.wikipedia.org/wiki/UTF-16#Kodierung">surrogate</a>, welches nicht zu einem high-low Paar gehört, zu kodieren.</p> + +<pre class="brush: js">// high-low paar ok +console.log(encodeURI('\uD800\uDFFF')); + +// einzelnes high surrogate erzeugt ein "URIError: malformed URI sequence" +console.log(encodeURI('\uD800')); + +// einzelnes low surrogate erzeugt ein "URIError: malformed URI sequence" +console.log(encodeURI('\uDFFF')); </pre> + +<p>Wenn Sie den neueren <a href="http://tools.ietf.org/html/rfc3986">RFC3986</a> Standart für URLs benutzen möchten, der eckige Klammern beachtet (für IPv6) und Teile die zur URL gehören könnten (wie der Host) nicht kodiert, könnte der kleine Code-Auszug helfen:</p> + +<pre class="brush: js">function fixedEncodeURI(str) { + return encodeURI(str).replace(/%5B/g, '[').replace(/%5D/g, ']'); +}</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>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.3.3', 'encodeURI')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-encodeuri-uri', 'encodeURI')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-encodeuri-uri', 'encodeURI')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_kompatibilität">Browser kompatibilität</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Normale Unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td> + <p>Normale Unterstützung</p> + </td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("decodeURI")}}</li> + <li>{{jsxref("encodeURIComponent")}}</li> + <li>{{jsxref("decodeURIComponent")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/encodeuricomponent/index.html b/files/de/web/javascript/reference/global_objects/encodeuricomponent/index.html new file mode 100644 index 0000000000..a632775085 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/encodeuricomponent/index.html @@ -0,0 +1,163 @@ +--- +title: encodeURIComponent() +slug: Web/JavaScript/Reference/Global_Objects/encodeURIComponent +tags: + - JavaScript + - URI +translation_of: Web/JavaScript/Reference/Global_Objects/encodeURIComponent +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die Methode <strong><code>encodeURIComponent()</code></strong> kodiert eine Komponente des Uniform Resource Identifier (URI) indem jedes Vorkommen bestimmter Zeichen durch ein, zwei, drei oder vier Escape-Sequenzen ersetzt werden, die der UTF8-Kodierung des Zeichens entsprechen. Vier Escape-Sequenzen werden nur bei Zeichen bestehend aus zwei "Surrogate"-Zeichen verwendet.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">encodeURIComponent(str);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>str</code></dt> + <dd>String. Eine URI-Komponente.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>encodeURIComponent</code> kodiert alle Zeichen außer den Folgenden: alphabetische, dezimale Ziffern, <code>- _ . ! ~ * ' ( )</code></p> + +<p>Beachte, dass {{jsxref("URIError")}} beim Versuch geworfen wird, ein Surrogate-Zeichen zu kodieren, das nicht Teil eines High-Low-Paares ist, z.B.:</p> + +<pre class="brush: js">// Zulässiges High-Low-Paar +console.log(encodeURIComponent('\uD800\uDFFF')); + +// alleinstehendes High-Surrogate-Zeichen wirft "URIError: malformed URI sequence" +console.log(encodeURIComponent('\uD800')); + +// alleinstehendes Low-Surrogate-Zeichen wirft "URIError: malformed URI sequence" +console.log(encodeURIComponent('\uDFFF')); +</pre> + +<p>Um unerwartete Anfragen an den Server zu vermeiden, sollte <code>encodeURIComponent</code> für jeden benutzerdefinierten Parameter, der als Teil der URI übergeben wird, verwendet werden. Z.B. könnte ein Benutzer in einem variablen Kommentar "<code>Thyme &time=again</code>" schreiben. Ohne Verwendung von <code>encodeURIComponent</code> erhältst Du <code>comment=Thyme%20&time=again</code>. Beachte, dass das Kaufmännische Und (Ampersand) und das Gleich-Zeichen ein neues Schlüssel-Wert-Paar bedeuten. Das bedeutet, dass statt dem POST-Schlüssel "<code>Thyme &time=again</code>" zwei POST-Schlüssel verwendet werden, der eine mit dem Wert "<code>Thyme </code>", der andere (<code>time</code>) mit <code>again</code>.</p> + +<p>Bei <a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#application/x-www-form-urlencoded-encoding-algorithm"><code>application/x-www-form-urlencoded</code></a> werden Leerzeichen mit '+' ersetzt, so dass es u.U. erwünscht ist, nach der Ersetzung durch <code>encodeURIComponent</code> eine weitere Ersetzung von "%20" mit "+" durchzuführen.</p> + +<p>Um streng konform mit <a href="http://tools.ietf.org/html/rfc3986">RFC 3986</a> zu sein (welches !, ', (, ) und * reserviert), obwohl diese Zeichen keine formalisierten Trennzeichen sind, kann das Folgende sicher verwendet werden:</p> + +<pre class="brush: js">function fixedEncodeURIComponent (str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function(c) { + return '%' + c.charCodeAt(0).toString(16); + }); +} +</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Das folgende Beispiel stellt die spezielle Kodierung sicher, die in UTF-8-kodierten Parameterwerten der Server-Antwort-Headern <code>Content-Disposition</code> und <code>Link</code> benötigt wird (z.B. UTF-8-kodierte Dateinamen):</p> + +<pre class="brush: js">var fileName = 'my file(2).txt'; +var header = "Content-Disposition: attachment; filename*=UTF-8''" + + encodeRFC5987ValueChars(fileName); + +console.log(header); +// logs "Content-Disposition: attachment; filename*=UTF-8''my%20file%282%29.txt" + + +function encodeRFC5987ValueChars (str) { + return encodeURIComponent(str). + // Beachte, dass obwohl RFC3986 "!" reserviert, es nicht kodiert + // werden muss, weil RFC5987 es nicht reserviert. + replace(/['()]/g, escape). // i.e., %27 %28 %29 + replace(/\*/g, '%2A'). + // Die folgenden Zeichen müssen nicht nach RFC5987 kodiert werden, + // daher können wir bessere Lesbarkeit übers Netzwerk sicherstellen: + // |`^ + replace(/%(?:7C|60|5E)/g, unescape); +} +</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>Ursprüngliche Definition</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.3.4', 'encodeURIComponent')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-encodeuricomponent-uricomponent', 'encodeURIComponent')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome für Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Weitere_Infos">Weitere Infos</h2> + +<ul> + <li>{{jsxref("decodeURI")}}</li> + <li>{{jsxref("encodeURI")}}</li> + <li>{{jsxref("decodeURIComponent")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/columnnumber/index.html b/files/de/web/javascript/reference/global_objects/error/columnnumber/index.html new file mode 100644 index 0000000000..8335fd02d6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/columnnumber/index.html @@ -0,0 +1,43 @@ +--- +title: Error.prototype.columnNumber +slug: Web/JavaScript/Reference/Global_Objects/Error/columnNumber +tags: + - Error + - JavaScript + - Non-standard + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/columnNumber +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <code><strong>columnNumber</strong></code> Eigenschaft enthält die Spaltennummer in der Zeile in der Datei, in der der Fehler erzeugt wurde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_columnNumber">Einsatz von <code>columnNumber</code></h3> + +<pre class="brush: js">var e = new Error('Could not parse input'); +throw e; +console.log(e.columnNumber) // 0 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>In keiner Spezifikation enthalten. Kein Standard.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.columnNumber")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/filename/index.html b/files/de/web/javascript/reference/global_objects/error/filename/index.html new file mode 100644 index 0000000000..df7383803e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/filename/index.html @@ -0,0 +1,47 @@ +--- +title: Error.prototype.fileName +slug: Web/JavaScript/Reference/Global_Objects/Error/fileName +tags: + - Error + - JavaScript + - Non-standard + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/fileName +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <code><strong>fileName</strong></code> Eigenschaft enthält den Pfad der Datei, in der der Fehler erzeugt wurde.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese nicht standardisierte Eigenschaft enthält den Pfad der Datei, in der der Fehler erzeugt wurde. Wenn diese Eigenschaft von aus einem Debugger heraus aufgerufen wird (z. B. Firefox Developer Tools), wird "debugger eval code" zurückgegeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_fileName">Einsatz von <code>fileName</code></h3> + +<pre class="brush: js">var e = new Error('Could not parse input'); +throw e; +// e.fileName könnte aussehen wie: "file:///C:/example.html" +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>In keiner Spezifikation enthalten. Kein Standard.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.fileName")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/index.html b/files/de/web/javascript/reference/global_objects/error/index.html new file mode 100644 index 0000000000..293f0927fc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/index.html @@ -0,0 +1,241 @@ +--- +title: Error +slug: Web/JavaScript/Reference/Global_Objects/Error +tags: + - Error + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Error +--- +<div>{{JSRef}}</div> + +<p>Der <strong><code>Error</code></strong> Konstruktor erstellt ein Fehler (Error) Objekt. Instanzen von <code>Error</code> Objekten werden geworfen (thrown), wenn zur Laufzeit ein Fehler auftritt. Das <code>Error</code> Objekt kann zudem als Basis für benutzerdefinierte Fehler benutzt werden. Weiter unten werden schon eingebaute Fehlertypen beschrieben.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new Error([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Optional. Für Menschen lesbare Beschreibung des Errors.</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Optional. Der Wert für die <code>fileName</code> Eigenschaft eines erstellten <code>Error</code> Objekts. Der Standardwert ist der Name der Datei, in dem der Quelltext <code>Error()</code> aufgerufen wird.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Optional. Der Wert für die <code>lineNumber</code> Eigenschaft eines erstellten <code>Error</code> Objekts. Der Standardwert ist die Zeilennummer, in dem der Quelltext <code>Error()</code> aufgerufen wird.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Laufzeitfehler resultieren in einem neu erstellten und geworfenen <code>Error</code> Objekt.</p> + +<p>Diese Seite Dokumentiert den Einsatz des <code>Error</code> Objektes und den Einsatz als Konstruktorfunktion. Für eine Liste der Eigenschaften und Methoden, die eine <code>Error</code> Instanz erbt, siehe auf der Seite {{jsxref("Error.prototype")}}.</p> + +<h3 id="Einsatz_als_Funktion">Einsatz als Funktion</h3> + +<p>Wenn <code>Error</code> als Funktion genutzt wird -- ohne <code>new</code>, wird diese ein <code>Error</code> Objekt zurückgeben. Daher wird der Aufruf der Funktion das gleiche zurückgeben wie der Aufruf des <code>Error</code> Konstruktors (mit <code>new</code> Schlüsselwort).</p> + +<pre class="brush: js">// dieser Aufruf: +const x = Error('Ich wurde mit einem Funktionsaufruf erstellt!'); +// hat die gleiche Funktion wie folgender: +const y = new Error('Ich wurde mit dem "new" Schlüsselwort erstellt!');</pre> + +<h3 id="Fehlertypen">Fehlertypen</h3> + +<p>Neben dem generischen <code>Error</code> Konstruktor sind in JavaScript noch sieben weitere Error-Konstruktoren eingebaut. Für benutzerdefinierte Fehler siehe <a href="/de/docs/Web/JavaScript/Guide/Statements#Statements_zur_Fehler-_bzw._Ausnahmebehandlung">Statements zur Fehler- und Ausnahmebehandlung</a>.</p> + +<dl> + <dt>{{jsxref("EvalError")}}</dt> + <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der bei der globalen {{jsxref("Global_Objects/eval", "eval()")}} Funktion auftritt.</dd> + <dt>{{jsxref("InternalError")}} {{non-standard_inline}}</dt> + <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn ein interner Fehler in JavaScript auftaucht (z. B. zu viel Rekursion).</dd> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn eine nummerische Variable oder ein nummerischer Parameter außerhalb seiner validen Grenzen ist.</dd> + <dt>{{jsxref("ReferenceError")}}</dt> + <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn eine nicht valide Referenz referenziert werden soll.</dd> + <dt>{{jsxref("SyntaxError")}}</dt> + <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn die Syntax von Quellcode, der in der {{jsxref("Global_Objects/eval", "eval()")}} Funktion übergeben wird, nicht richtig ist.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn eine Variable oder ein Parameter einen nicht validen Typen enthält.</dd> + <dt>{{jsxref("URIError")}}</dt> + <dd>Erstellt ein Instanz, die einen Fehler repräsentiert, der auftritt, wenn die Methode {{jsxref("Global_Objects/encodeURI", "encodeURI()")}} oder {{jsxref("Global_Objects/decodeURI", "decodeURI()")}} nicht valide Parameter übergeben bekommt.</dd> +</dl> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("Error.prototype")}}</dt> + <dd>Erlaubt es die Eigenschaften aller <code>Error</code> Instanzen zu verändern.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p>Das globale <code>Error</code> Objekt besitzt keine eigenen Methoden. Stattdessen erbt es einige Methoden durch die Prototypenkette.</p> + +<h2 id="Error_Instanzen">Error Instanzen</h2> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype', 'Beschreibung')}}</div> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype', 'Methoden')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Werfen_eines_generischen_Errors">Werfen eines generischen Errors</h3> + +<p>Typischerweise erstellt man ein <code>Error</code> Objekt mit der Intention es mit dem {{jsxref("Statements/throw", "throw")}} Schlüsselwort zu werfen. Man kann den Fehler auffangen, indem man ein {{jsxref("Statements/try...catch", "try...catch")}} Konstrukt benutzt.</p> + +<pre class="brush: js">try { + throw new Error('Whoops!'); +} catch (e) { + console.log(e.name + ': ' + e.message); +} +</pre> + +<h3 id="Einen_Spezifischen_Error_behandeln">Einen Spezifischen Error behandeln</h3> + +<p>Man kann sich aussuchen, welche spezifischen Fehlertypen behandelt werden sollen, indem man die {{jsxref("Object.prototype.constructor", "constructor")}} Eigenschaft des Errors abfragt. In modernen JavaScript-Umgebungen kann stattdessen das {{jsxref("Operators/instanceof", "instanceof")}} Schlüsselwort verwendet werden:</p> + +<pre class="brush: js">try { + foo.bar(); +} catch (e) { + if (e instanceof EvalError) { + console.log(e.name + ': ' + e.message); + } else if (e instanceof RangeError) { + console.log(e.name + ': ' + e.message); + } + // ... etc +} +</pre> + +<h3 id="Benutzerdefinierte_Fehlertypen">Benutzerdefinierte Fehlertypen</h3> + +<p>Manchmal möchte man aber einen eigenen Error erstellen, der von <code>Error</code> abgeleitet ist, durch den Aufruf <code>throw new CustomError()</code> geworfen werden kann und durch <code>instanceof CustomError</code> abgefragt werden kann. Eigene Fehlertypen führen zu einer besseren und konsistenten Fehlerbehandlung. Für eine tiefer gehende Diskussion schaue bitte auf <a href="https://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript">Stack Overflow</a> nach.</p> + +<h4 id="ES6_benutzerdefinierte_Error_Klasse">ES6 benutzerdefinierte Error Klasse</h4> + +<div class="warning"> +<p>Babel und andere Transpiler werden den folgenden Quelltext nicht ohne <a href="https://github.com/loganfsmyth/babel-plugin-transform-builtin-extend">zusätzliche Konfigurationen</a> verarbeiten können.</p> +</div> + +<div class="note"> +<p>Einige Browser enthalten den CustomError Konstruktor im Stack Trace, wenn ES2015 Klassen eingesetzt werden</p> +</div> + +<pre class="brush: js">class CustomError extends Error { + constructor(foo = 'bar', ...params) { + // Übergibt die verbleibenden Parameter (einschließlich Vendor spezifischer Parameter) dem Error Konstruktor + super(...params); + + // Behält den richtigen Stack-Trace für die Stelle bei, an der unser Fehler ausgelöst wurde (nur bei V8 verfügbar) + if (Error.captureStackTrace) { + Error.captureStackTrace(this, CustomError); + } + + // Benutzerdefinierte Debugging Informationen + this.foo = foo; + this.date = new Date(); + } +} + +try { + throw new CustomError('buz', 'buzMessage'); +} catch(e){ + console.log(e.foo); // baz + console.log(e.message); // bazMessage + console.log(e.stack); // stacktrace +}</pre> + +<h4 id="ES5_benutzerdefiniertes_Error_Objekt">ES5 benutzerdefiniertes Error Objekt</h4> + +<div class="warning"> +<p><strong>Alle</strong> Browser enthalten den CustomError Konstruktor im Stack Trace, wenn eine Prototypische Deklaration verwendet wird.</p> +</div> + +<pre class="brush: js">function CustomError(foo, message, fileName, lineNumber) { + var instance = new Error(message, fileName, lineNumber); + instance.foo = foo; + Object.setPropertyOf(instance, Object.getPrototypeOf(this)); + if(Error.captureStackTrace) { + Error.captureStackTrace(instance, CustomError); + } + return instance; +} + +CustomError.prototype = Object.create(Error.prototype, { + constructor: { + value: Error, + enumerable: false, + writable: true, + configurable: true + } +}); + +if(typeof Object.setPropertyOf != 'undefined') { + Object.setPrototypeOf(CustomError, Error); +} else { + CustomError.__proto__ = Error; +} + + +try { + throw new CustomError('baz', 'bazMessage'); +} catch (e) { + console.log(e.foo); // 'baz' + console.log(e.message); // 'bazMessage' +} +</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.11', 'Error')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-error-objects', 'Error')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-error-objects', 'Error')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Statements/throw", "throw")}}</li> + <li>{{jsxref("Statements/try...catch", "try...catch")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/linenumber/index.html b/files/de/web/javascript/reference/global_objects/error/linenumber/index.html new file mode 100644 index 0000000000..63bb6a59c2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/linenumber/index.html @@ -0,0 +1,55 @@ +--- +title: Error.prototype.lineNumber +slug: Web/JavaScript/Reference/Global_Objects/Error/lineNumber +tags: + - Error + - JavaScript + - Non-standard + - Property + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Error/lineNumber +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <code><strong>lineNumber</strong></code> Eigenschaft enthält die Zeilennummer in der Datei, in der der Fehler erzeugt wurde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_lineNumber">Einsatz von <code>lineNumber</code></h3> + +<pre class="brush: js">var e = new Error('Could not parse input'); +throw e; +console.log(e.lineNumber) // 2 +</pre> + +<h3 id="Alternatives_Beispiel_mit_error_Events">Alternatives Beispiel mit <code>error</code> Events</h3> + +<pre class="brush: js">window.addEventListener('error', function(e) { + console.log(e.lineNumber); // 5 +}); +var e = new Error('Could not parse input'); +throw e; +</pre> + +<p>Das ist keine Standardfunktion und es gibt auch keine breite Unterstützung (siehe Browserkompatibilitätstabelle unten).</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Ist in keiner Spezifikation enthalten. Kein Standard.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.lineNumber")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/message/index.html b/files/de/web/javascript/reference/global_objects/error/message/index.html new file mode 100644 index 0000000000..559f457cb2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/message/index.html @@ -0,0 +1,75 @@ +--- +title: Error.prototype.message +slug: Web/JavaScript/Reference/Global_Objects/Error/message +tags: + - Error + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/message +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>message</strong></code> Eigenschaft ist eine für Menschen lesbare Beschreibung von Errors.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Eigenschaft enthält eine knappe Beschreibung des Errors, wenn eine verfügbar ist oder gesetzt wird. Zum Beispiel setzt <a href="/de/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> diese Eigenschaft sehr oft ein. Die <code>message</code> Eigenschaft kombiniert mit der {{jsxref("Error.prototype.name", "name")}} Eigenschaft werden in der {{jsxref("Error.prototype.toString()")}} Methode eingesetzt, um eine String-Repräsentation des Errors zu erstellen.</p> + +<p>Der Standardwert für die <code>message</code> Eigenschaft ist ein leerer String, jedoch kann diese von einer Instanz überschrieben werden, indem der erste Parameter des {{jsxref("Error", "Error Konstruktors")}} gesetzt wird.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einen_benutzerdefinierten_Fehler_erzeugen">Einen benutzerdefinierten Fehler erzeugen</h3> + +<pre class="brush: js">var e = new Error('Falsches Eingabeformat'); +// e.message ist 'Falsches Eingabeformat' +throw e; +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.4.3', 'Error.prototype.message')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype.message', 'Error.prototype.message')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-error.prototype.message', 'Error.prototype.message')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.message")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype.name")}}</li> + <li>{{jsxref("Error.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/name/index.html b/files/de/web/javascript/reference/global_objects/error/name/index.html new file mode 100644 index 0000000000..abf77777fc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/name/index.html @@ -0,0 +1,58 @@ +--- +title: Error.prototype.name +slug: Web/JavaScript/Reference/Global_Objects/Error/name +tags: + - Error + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/name +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>name</strong></code> Eigenschaft repräsentiert einen Namen für die Art des Errors. Der Initialwert ist "Error".</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Als Standard wird für einer {{jsxref("Error")}} Instanz der Name "Error" gegeben. Die <code>name</code> Eigenschaft und die {{jsxref("Error.prototype.message", "message")}} Eigenschaft werden eingesetzt, um in der {{jsxref("Error.prototype.toString()")}} Methode eine Repräsentation des Fehlers als String zu erstellen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einen_benutzerdefinierten_Fehler_erzeugen">Einen benutzerdefinierten Fehler erzeugen</h3> + +<pre class="brush: js">var e = new Error('Malformed input'); // e.name ist 'Error' + +e.name = 'ParseError'; +throw e; +// e.toString() wird 'ParseError: Malformed input' zurückgeben. +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-error.prototype.name', 'Error.prototype.name')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.Error.name")}}</p> +</div> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype.message")}}</li> + <li>{{jsxref("Error.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/prototype/index.html b/files/de/web/javascript/reference/global_objects/error/prototype/index.html new file mode 100644 index 0000000000..f383b474ea --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/prototype/index.html @@ -0,0 +1,113 @@ +--- +title: Error.prototype +slug: Web/JavaScript/Reference/Global_Objects/Error/prototype +tags: + - Error + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Error +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Error.prototype</strong></code> Eigenschaft repräsentiert den Prototypen für den {{jsxref("Error")}} Konstruktor.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Alle {{jsxref("Error")}} Instanzen und Instanzen von {{jsxref("Global_Objects/Error", "nicht generischen Errors", "#Error_types", 1)}} erben von <code>Error.prototype</code>. Wie bei jeder Konstruktorfunktion, kann man den Prototypen des Konstruktors einsetzen, um Eigenschaften oder Methoden bei allen erstellten Instanzen hinzuzufügen.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<h3 id="Standard-Eigenschaften">Standard-Eigenschaften</h3> + +<dl> + <dt><code>Error.prototype.constructor</code></dt> + <dd>Spezifiziert die Funktion, die einen Prototypen einer Instanz erstellt.</dd> + <dt>{{jsxref("Error.prototype.message")}}</dt> + <dd>Errornachricht.</dd> + <dt>{{jsxref("Error.prototype.name")}}</dt> + <dd>Errorname.</dd> +</dl> + +<h3 id="Vendor-spezifische_Erweiterungen">Vendor-spezifische Erweiterungen</h3> + +<div>{{non-standard_header}}</div> + +<h4 id="Microsoft">Microsoft</h4> + +<dl> + <dt>{{jsxref("Error.prototype.description")}} {{non-standard_inline}}</dt> + <dd>Errorbeschreibung. Ist das gleiche wie {{jsxref("Error.prototype.message")}}</dd> + <dt>{{jsxref("Error.prototype.number")}} {{non-standard_inline}}</dt> + <dd>Errornummer.</dd> +</dl> + +<h4 id="Mozilla">Mozilla</h4> + +<dl> + <dt>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</dt> + <dd>Pfad zu der Datei, die der der Error ausgelöst wurde.</dd> + <dt>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</dt> + <dd>Zeilennummer in der Datei, in der der Error ausgelöst wurde.</dd> + <dt>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</dt> + <dd>Spaltennummer in der Zeile, in der der Error ausgelöst wurde.</dd> + <dt>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</dt> + <dd>Stacktrace.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Gibt einen String zurück, der den Quelltext eines spezifischen {{jsxref("Error")}} Objektes beinhaltet. Man kann diesen einsetzen, um ein neues Objekt zu erstellen. Überschreibt die {{jsxref("Object.prototype.toSource()")}} Methode.</dd> + <dt>{{jsxref("Error.prototype.toString()")}}</dt> + <dd>Gibt einen String zurück, der das Objekt repräsentiert. Überschreibt die {{jsxref("Object.prototype.toString()")}} 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.11.3.1', 'Error')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype', 'Error')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.prototype")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("Object.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/stack/index.html b/files/de/web/javascript/reference/global_objects/error/stack/index.html new file mode 100644 index 0000000000..ed930983bc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/stack/index.html @@ -0,0 +1,124 @@ +--- +title: Error.prototype.stack +slug: Web/JavaScript/Reference/Global_Objects/Error/Stack +tags: + - Error + - JavaScript + - Non-standard + - Property + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Error/Stack +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die nicht standardisierte <strong><code>stack</code></strong> Eigenschaft des {{jsxref("Error")}} Objektes zeigt den Verlauf der aufgerufenen Funktionen. Dabei wird die Reihenfolge der Aufrufe, der Zeile und die Datei der Aufrufes und die übergebenen Argumenten angegeben. Der stack String verläuft von den jüngsten Aufrufen zu den vorherigen Aufrufen, bis zum globalen Scope zurück.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Jeder Schritt wird durch einen neue Zeile getrennt. Der erste Teil einer Zeile besteht aus dem Funktionsnamen (wenn es kein Aufruf vom globalen Scope ist), gefolgt von einem @-Zeichen, dem Dateiort (ausgenommen, wenn die Funktion der Error-Konstruktor des geworfenen Errors ist), einem Doppelpunkt und einer Zeilennummer, wenn ein Dateiort existiert. Zu beachten ist, dass das {{jsxref("Error")}} Objekt auch die Eigenschaften <code>fileName</code>, <code>lineNumber</code> und <code>columnNumber</code> besitzt, um dieses von geworfenen Error wiederherzustellen (aber nur dem Fehler und nicht seinem trace).</p> + +<p>Zu beachten ist, dass dieses das Format von Firefox ist. Es gibt keine Standardformat, auch wenn Safari 6+ und Opera 12- ein ähnliches Format verwenden. Browser die die V8 JavaScript Umgebung benutzen (z. B. Chrome, Opera 15+, Android Browser) und IE10+ nutzen ein anderes Format (zusehen in den MSDN <a class="external" href="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">error.stack</a> docs).</p> + +<p><strong>Parameter Werte im Stack:</strong> Bis Firefox 14 ({{bug("744842")}}) folgten auf den Funktionsnamen die zu Strings konvertierten Werte der Parameter in runden Klammern vor dem @-Zeichen. Während ein Objekt (oder Array, etc.) zu<code> "[object Object]"</code> konvertiert werden und diese Werte nicht zurück zu einem existierenden Objekt ausgewertet werden können, können skalare Werte zurückverfolgt werden (manchmal kann es einfacher sein — nur in Firefox 14 möglich — <code>arguments.callee.caller.arguments</code> zu benutzen, der Funktionsname kann mit <code>arguments.callee.caller.name</code> erfragt werden). <code>"undefined"</code> wird mit <code>"(void 0)"</code> dargestellt. Zu beachten ist, dass String Argumente (oder auch Dateinamen), die Zeichen wie "@", "(", ")" beinhalten dazu führen, dass es nicht einfach ist, die Zeile in seine Komponenten aufzuteilen. In Firefox 14+ ist dieses kein Problem mehr.</p> + +<p>Verschiedene Browser setzen den this Wert zu verschiedenen Zeitpunkten. Zum Beispiel setzt Firefox diesen beim erstellen eines {{jsxref("Error")}} Objektes, während PhantomJS dieses nur setzt, wenn das {{jsxref("Error")}} Objekt geworfen wird und <a href="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">MSDN docs</a> scheinen diesem verhalten auch zu folgen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Der folgende HTML-Quelltext demonstriert den Einsatz der <code>stack</code> Eigenschaft.</p> + +<pre class="brush: html"><!DOCTYPE HTML> +<meta charset="UTF-8"> +<title>Stack Trace Example</title> +<body> +<script> +function trace() { + try { + throw new Error('myError'); + } + catch(e) { + alert(e.stack); + } +} +function b() { + trace(); +} +function a() { + b(3, 4, '\n\n', undefined, {}); +} +a('first call, firstarg'); +</script> +</pre> + +<p>Angenommen der oben stehende Quelltext ist auf einen Windows Datei System unter <code>C:\example.html</code> gespeichert, wird der folgende Text ausgegeben:</p> + +<p>Mit Firefox 30+ wird die Spaltennummer mit angegeben ({{bug("762556")}}):</p> + +<pre><samp>trace@file:///C:/example.html:9:17 +b@file:///C:/example.html:16:13 +a@file:///C:/example.html:19:13 +@file:///C:/example.html:21:9</samp></pre> + +<p>Von Firefox 14 bis Firefox 29:</p> + +<pre><samp>trace@file:///C:/example.html:9 +b@file:///C:/example.html:16 +a@file:///C:/example.html:19 +@file:///C:/example.html:21</samp></pre> + +<p>Bis Firefox 13 wird folgender Text ausgegeben:</p> + +<pre><samp>Error("myError")@:0 +trace()@file:///C:/example.html:9 +b(3,4,"\n\n",(void 0),[object Object])@file:///C:/example.html:16 +a("first call, firstarg")@file:///C:/example.html:19 +@file:///C:/example.html:21</samp></pre> + +<h3 id="Stacks_von_eval_Quelltext">Stacks von eval Quelltext</h3> + +<p>Angefangen mit Firefox 30 {{geckoRelease("30")}} enthällt der Stack von Errors auch Informationen von <code>Function()</code> und <code>eval()</code> Aufrufen mit detailierten Spalten- und Zeilennummern innerhalb dieser Aufrufe. Funktionsaufrufe werden mit <code>"> Function"</code> angezeigt, Aufrufe mit eval werden mit <code>"> eval"</code> angezeigt. Siehe {{bug("332176")}}.</p> + +<pre class="brush: js">try { + new Function('throw new Error()')(); +} catch (e) { + console.log(e.stack); +} + +// anonymous@file:///C:/example.html line 7 > Function:1:1 +// @file:///C:/example.html:7:6 + + +try { + eval("eval('FAIL')"); +} catch (x) { + console.log(x.stack); +} + +// @file:///C:/example.html line 7 > eval line 1 > eval:1:1 +// @file:///C:/example.html line 7 > eval:1:1 +// @file:///C:/example.html:7:6 +</pre> + +<p>Man kann auch die <code>//# sourceURL</code> Direktive benutzen, um den eval-Code zu benennen. Siehe auch <a href="/de/docs/Tools/Debugger/How_to/Debug_eval_sources">Debug eval sources</a> in den <a href="/de/docs/Tools/Debugger">Debugger</a> docs und diesen <a href="http://fitzgeraldnick.com/weblog/59/">Blogeintrag</a>.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Ist kein Teil einer Spezifikation, nicht standardisiert.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.stack")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Components.stack">Components.stack</a></li> + <li>Externe Projekte: <a class="link-https" href="https://github.com/csnover/TraceKit/">TraceKit</a> und <a class="link-https" href="https://github.com/eriwen/javascript-stacktrace">javascript-stacktrace</a></li> + <li>MSDN: <a class="external" href="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx" title="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">error.stack</a> docs</li> + <li><a href="https://github.com/v8/v8/wiki/Stack%20Trace%20API">Überblick über die V8 JavaScript Stack Trace API</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/tosource/index.html b/files/de/web/javascript/reference/global_objects/error/tosource/index.html new file mode 100644 index 0000000000..59025435f5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/tosource/index.html @@ -0,0 +1,57 @@ +--- +title: Error.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Error/toSource +tags: + - Error + - JavaScript + - Method + - Non-standard + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <code><strong>toSource()</strong></code> Methode gibt den Quelltext zurück, der zu dem selben Error ausgewertet werden kann.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>e</var>.toSource()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der den Quelltext des Fehlers enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das Aufrufen der <code>toSource</code> Methode auf einer {{jsxref("Error")}} Instanz (auch bei<em> <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_Typen">NativeErrors</a></em>) gibt einen String zurück, der den Quelltext der Instanz enthält. Dieser String kann ausgeführt werden, um (annähernd) gleiches Objekt zu erzeugen. Normalerweise enthält der String den Quelltext des {{jsxref("Error")}} Konstruktors. Zum Beispiel:</p> + +<pre class="brush: js">(new<em>name</em>(<em>message</em> ,<em>fileName</em>,<em>lineNumber</em>)) +</pre> + +<p>wo die Attribute den Eigenschaften der Error-Instanz entsprechen.</p> + +<div class="note"> +<p><strong>Bemerkung:</strong> <span id="result_box" lang="de"><span>Seien Sie sich bewusst</span><span>, dass die Eigenschaften</span>, <span>die</span> <span>durch die toSource</span> <span>Methode</span> <span>bei der Erstellung</span> des Strings <span>verwendet</span>, veränderbar <span>sind</span> <span>und</span> <span>nicht genau die</span> <span>Funktion</span> <span>widerspiegeln</span><span>, die eine Fehler</span> <span>Instanz erstellt habt. Das betrifft</span><span> den Dateinamen </span><span>und</span> <span>die Zeilennummer.</span></span></p> +</div> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>In keine Spezifikation enthalten. Implementiert in JavaScript 1.3.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.toSource")}}</p> +</div> + +<h2 id="See_auch">See auch</h2> + +<ul> + <li>{{jsxref("Error.prototype.fileName")}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}}</li> + <li>{{jsxref("Error.prototype.message")}}</li> + <li>{{jsxref("Error.prototype.name")}}</li> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/error/tostring/index.html b/files/de/web/javascript/reference/global_objects/error/tostring/index.html new file mode 100644 index 0000000000..15565bd296 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/error/tostring/index.html @@ -0,0 +1,116 @@ +--- +title: Error.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Error/toString +tags: + - Error + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString +--- +<div>{{JSRef}}</div> + +<div>Die <code><strong>toString()</strong></code> Methode gibt einen String zurück, der das {{jsxref("Error")}} Objekt repräsentiert.</div> + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>e</var>.toString()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Einen String, der das gegebenen {{jsxref("Error")}} Objekt repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das {{jsxref("Error")}} Objekt überschreibt die {{jsxref("Object.prototype.toString()")}} Methode, die an allen Objekte vererbt werden. Die Semanik ist die folgende (angenommen {{jsxref("Object")}} und {{jsxref("String")}} wurden nicht verändert):</p> + +<pre class="brush: js">Error.prototype.toString = function() { + 'use strict'; + + var obj = Object(this); + if (obj !== this) { + throw new TypeError(); + } + + var name = this.name; + name = (name === undefined) ? 'Error' : String(name); + + var msg = this.message; + msg = (msg === undefined) ? '' : String(msg); + + if (name === '') { + return msg; + } + if (msg === '') { + return name; + } + + return name + ': ' + msg; +}; +</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var e = new Error('fatal error'); +console.log(e.toString()); // 'Error: fatal error' + +e.name = undefined; +console.log(e.toString()); // 'Error: fatal error' + +e.name = ''; +console.log(e.toString()); // 'fatal error' + +e.message = undefined; +console.log(e.toString()); // 'Error' + +e.name = 'hello'; +console.log(e.toString()); // 'hello' +</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.11.4.4', 'Error.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.toString")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype.toSource()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/escape/index.html b/files/de/web/javascript/reference/global_objects/escape/index.html new file mode 100644 index 0000000000..84ad406566 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/escape/index.html @@ -0,0 +1,132 @@ +--- +title: escape() +slug: Web/JavaScript/Reference/Global_Objects/escape +tags: + - JavaScript + - Veraltet +translation_of: Web/JavaScript/Reference/Global_Objects/escape +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die veraltete Funktion <code><strong>escape()</strong></code> erzeugt einen neuen Text, in welchem gewisse Zeichen durch eine Hexadezimal-Escape-Sequenz ersetzt wurden. Es wird empfohlen, {{jsxref("encodeURI")}} oder {{jsxref("encodeURIComponent")}} stattdessen zu nutzen.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>escape(str)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>str</code></dt> + <dd>Ein Text welcher verarbeitet wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer Text, in welchem gewisse Zeichen escaped wurden.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>escape</code>-Funktion ist Teil des <em>globalen Objektes</em>. Hierbei werden spezielle Zeichen codiert. Außnahme bilden hier: @*_+-./</p> + +<p>Die hexadezimale Form für Zeichen, deren Code-Einheitswert 0xFF oder weniger ist, enspricht einer zwei Ziffern großen Escape-Sequenz: %xx. Für Zeichen mit einem größeren Code-Einheitswert wird ein vier-Ziffern-Format genutzt: %<strong>u</strong>xxxx</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">escape("abc123"); // "abc123" +escape("äöü"); // "%E4%F6%FC" +escape("ć"); // "%u0107" + +// Spezielle Zeichen +escape("@*_+-./"); // "@*_+-./"</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.1', 'escape')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Informativ definiert in Compatibility Annex B</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-escape-string', 'escape')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Normativ definitiert in Annex B für Erweiterte ECMAScript-Features in Webbrowsern</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-escape-string', 'escape')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Normativ definitiert in Annex B für Erweiterte ECMAScript-Features in Webbrowsern</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_Auch">Siehe Auch</h2> + +<ul> + <li>{{jsxref("encodeURI")}}</li> + <li>{{jsxref("encodeURIComponent")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/evalerror/index.html b/files/de/web/javascript/reference/global_objects/evalerror/index.html new file mode 100644 index 0000000000..3043bdf908 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/evalerror/index.html @@ -0,0 +1,118 @@ +--- +title: EvalError +slug: Web/JavaScript/Reference/Global_Objects/EvalError +tags: + - Error + - EvalError + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/EvalError +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>EvalError</code></strong> Objekt bedeutet einen Fehler in Verbindung mit der globalen {{jsxref("Global_Objects/eval", "eval()")}} Funktion. Dieser Fehler wird nicht von JavaScript erzeugt, jedoch gibt es das <code>EvalError</code> Objekt noch aus Kompatibilitätsgründen.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new EvalError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Optional. Für Menschen lesbare Beschreibung des Fehlers.</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Optional. Der Name der Datei, die den Code enthält, welcher zu dem Fehler führt.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Optional. Die Zeilennummer, die den Code enthält, welcher zu dem Fehler führt.</dd> +</dl> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("EvalError.prototype")}}</dt> + <dd>Erlaubt das Hinzufügen von Eigenschaften zu einem <code>EvalError</code> Objekt.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p>Das globale <code>EvalError</code> Objekt enthält keine eigen Methoden, jedoch erbt es einige Methoden über die Prototypenkette.</p> + +<h2 id="EvalError_Instanzen"><code>EvalError</code> Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Methoden')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<p><code>EvalError</code> wird nicht in der aktuellen ECMAScript Spezifikation verwendet und wird daher auch nicht von der Laufzeitumgebung erzeugt. Jedoch wird das Objekt aus Gründen der Rückwärtskompatibilität zu älteren Versionen der Spezifikation erhalten.</p> + +<h3 id="Erstellen_eines_EvalError">Erstellen eines <code>EvalError</code></h3> + +<pre class="brush: js">try { + throw new EvalError('Hello', 'someFile.js', 10); +} catch (e) { + console.log(e instanceof EvalError); // true + console.log(e.message); // "Hello" + console.log(e.name); // "EvalError" + console.log(e.fileName); // "someFile.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:2:9\n" +} +</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.1', 'EvalError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Nicht benutzt in dieser Spezifikation. Erhalten für Rückwärtskompatibilität.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Nicht benutzt in dieser Spezifikation. Erhalten für Rückwärtskompatibilität.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.EvalError")}}</p> +</div> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("EvalError.prototype")}}</li> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/evalerror/prototype/index.html b/files/de/web/javascript/reference/global_objects/evalerror/prototype/index.html new file mode 100644 index 0000000000..03783a0294 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/evalerror/prototype/index.html @@ -0,0 +1,89 @@ +--- +title: EvalError.prototype +slug: Web/JavaScript/Reference/Global_Objects/EvalError/prototype +tags: + - Error + - EvalError + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/EvalError +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>EvalError.prototype</strong></code> Eigenschaft repräsentiert den Prototypen des {{jsxref("EvalError")}} Konstruktors.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Alle {{jsxref("EvalError")}} Instanzen erben von <code>EvalError.prototype</code>. Man kann den Prototypen benutzen, um Eigenschaften oder Methoden für alle Instanzen hinzuzufügen.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>EvalError.prototype.constructor</code></dt> + <dd>Spezifiziert die Funktion, die einen Instanzprototypen erstellt.</dd> + <dt>{{jsxref("Error.prototype.message", "EvalError.prototype.message")}}</dt> + <dd>Fehlernachricht. Obwohl ECMA-262 spezifiziert, dass {{jsxref("EvalError")}} seine eigene <code>message</code> Eigenschaft haben soll, wird diese in <a href="/de/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> von {{jsxref("Error.prototype.message")}} geerbt.</dd> + <dt>{{jsxref("Error.prototype.name", "EvalError.prototype.name")}}</dt> + <dd>Fehlername. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "EvalError.prototype.fileName")}}</dt> + <dd>Pfad zur Datei, die der der Fehler ausgelöst hat. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "EvalError.prototype.lineNumber")}}</dt> + <dd>Zeilennummer in der Datei, in der der Fehler ausgelöst wurde. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "EvalError.prototype.columnNumber")}}</dt> + <dd>Dpaltennummer in der Zeile, in der der Fehler ausgelöst wurde. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "EvalError.prototype.stack")}}</dt> + <dd>Stacktrace. Geerbt von {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p>Obwohl des {{jsxref("EvalError")}} Prototypobjekt keine eigene Methode enthält, erben {{jsxref("EvalError")}} Instanzen einige Methoden durch die Prototypenkette.</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.EvalError")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/float32array/index.html b/files/de/web/javascript/reference/global_objects/float32array/index.html new file mode 100644 index 0000000000..bb59fcf59f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/float32array/index.html @@ -0,0 +1,204 @@ +--- +title: Float32Array +slug: Web/JavaScript/Reference/Global_Objects/Float32Array +tags: + - Constructor + - JavaScript + - TypedArray + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/Float32Array +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Float32Array</code></strong> getypte Array repräsentiert ein Array von 32 Bit Gleitkommazahlen (entspricht dem C Datengyp <code>float</code>) in der Plattform-Byte-Reihenfolge. Wenn Kontrolle über die Byte-Reihenfolge erforderlich ist, muss {{jsxref("DataView")}} stattdessen benutz werden. Die Inhalte werden mit <code>0</code> initialisiert. Wie erwartet, kann man Element in einem Array mit Objektmethoden referenzieren oder man benutzt die normale Arrayindex-Syntax (das ist die Klammernotation).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new Float32Array(); // new in ES2017 +new Float32Array(length); +new Float32Array(typedArray); +new Float32Array(object); +new Float32Array(buffer [, byteOffset [, length]]);</pre> + +<p>Für mehr Informationen über die Konstruktorensyntax und die Parameter, siehe auf der Seite <em><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float32Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Gibt die Größe der Elemente zurück. <code>4</code> im Falle eines <code>Float32Array</code>.</dd> + <dt>Float32Array.length</dt> + <dd>Statische Längeneigenschaft welche den Wert 0 hat. Für die aktuelle Länge (Anzahl der Elemente) siehe {{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}}.</dd> + <dt>{{jsxref("TypedArray.name", "Float32Array.name")}}</dt> + <dd>Gibt den Stringwert des Konstruktornamens zurück. In Fall eines <code>Float32Array</code> Typs: <code>"Float32Array"</code>.</dd> + <dt>{{jsxref("TypedArray.prototype", "Float32Array.prototype")}}</dt> + <dd>Prototyp für das <em>TypedArray</em> Objekt.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Float32Array.from()")}}</dt> + <dd>Erstelle ein neues <code>Float32Array</code> von einem Array-Ähnlichen oder Iterable Objekt. Siehe auch {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Float32Array.of()")}}</dt> + <dd>Erstellt ein neues <code>Float32Array</code> mit einer variablen Anzahl an Argumenten. Sie auch {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Float32Array_Prototyp"><code>Float32Array</code> Prototyp</h2> + +<p>Alle <code>Float32Array</code> Objekte erben von {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<dl> + <dt><code>Float32Array.prototype.constructor</code></dt> + <dd>Gibt die Funktion, die einen Instanzprototyp erstellt zurück. Diese ist auf den <code>Float32Array</code> Konstruktor voreingestellt.</dd> + <dt>{{jsxref("TypedArray.prototype.buffer", "Float32Array.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Gibt die {{jsxref("ArrayBuffer")}} Referenz zurück, welche nach der Erstellung eines <code>Float32Array</code> fest ist und nicht mehr geändert werden kann.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Float32Array.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Gibt die Länge (in Bytes) des <code>Float32Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float32Array.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Gibt das Offset (in Bytes) des <code>Float32Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}} {{readonlyInline}}</dt> + <dd>Gibt Anzahl der Elemente des <code>Float32Array</code> zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> +</dl> + +<h3 id="Methoden_2">Methoden</h3> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}</dt> + <dd>Kopiert eine Sequenz von Arrayelementen in das Array. Siehe auch {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Float32Array.prototype.entries()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Schlüssel/Wertepaare für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Float32Array.prototype.every()")}}</dt> + <dd>Teste, ob alle Elemente einem, als Funktion übergebenen, Test erfüllen. Siehe auch Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Float32Array.prototype.fill()")}}</dt> + <dd>Füllt alle Elemente eines Arrays vom Startindex bis zum Endindex mit einem statischen Wert. Siehe auch {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Float32Array.prototype.filter()")}}</dt> + <dd>Erstellt ein neues Array mit allen Elementen des alten Arrays, für die eine übergebene Filterfunktion <code>true</code> zurückgibt. Siehe auch {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Float32Array.prototype.find()")}}</dt> + <dd>Gibt ein gefundenes Element des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>undefined</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Float32Array.prototype.findIndex()")}}</dt> + <dd>Gibt den Index eines gefundenen Elements des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Float32Array.prototype.forEach()")}}</dt> + <dd>Ruft für jedes Element in einem Array eine Funktion auf. Siehe auch {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Float32Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Überprüft, ob ein getyptes Array ein bestimmtes Element enthält und gibt gegebenfalls <code>true</code> oder<code>false</code> zurück. Siehe auch {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Float32Array.prototype.indexOf()")}}</dt> + <dd>Gibt den ersten Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Float32Array.prototype.join()")}}</dt> + <dd>Führt alle Elemente eines Arrays zu einem String zusammen. Siehe auch {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Float32Array.prototype.keys()")}}</dt> + <dd>Gibt ein neuen <code>Array Iterator</code> zurück, der alle Schlüssel für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Float32Array.prototype.lastIndexOf()")}}</dt> + <dd>Gibt den letzen Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Float32Array.prototype.map()")}}</dt> + <dd>Erstellt ein neues Array mit den Resultaten spezifizierten Funktion, die für jedes Element aufgerufen wird. Siehe auch {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.move", "Float32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt> + <dd>Ehemalige nicht Standardisierte Version von {{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Float32Array.prototype.reduce()")}}</dt> + <dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von links nach rechts), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Float32Array.prototype.reduceRight()")}}</dt> + <dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von rechts nach links), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Float32Array.prototype.reverse()")}}</dt> + <dd>Kehrt die Reihenfolge von jedem Element eines Arrays um — das Erste wird das Letzte und das Letzte wird das Erste. Siehe auch {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Float32Array.prototype.set()")}}</dt> + <dd>Speichert mehrere Werte in einem getypten Array und ließt Eingabewerte aus einem spezifiziertem Array.</dd> + <dt>{{jsxref("TypedArray.slice", "Float32Array.prototype.slice()")}}</dt> + <dd>Extrahiert einen Bereich aus einem Array und gibt diesen in einem neuen Array zurück. Siehe auch {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Float32Array.prototype.some()")}}</dt> + <dd>Gibt <code>true</code> zurück, wenn nur ein Element in einem Array den als Funktion übergebenen Test erfüllt. Siehe auch {{jsxref("Array.prototype.some()")}}</dd> + <dt>{{jsxref("TypedArray.sort", "Float32Array.prototype.sort()")}}</dt> + <dd>Sortiert die Elemente eines Arrays in-Place und gibt das Array zurück. Siehe auch {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Float32Array.prototype.subarray()")}}</dt> + <dd>Gibt ein neues <code>Float32Array</code> vom gegebenen Start- und Endindex zurück.</dd> + <dt>{{jsxref("TypedArray.values", "Float32Array.prototype.values()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Werte von jedem Index im Array enthält. Siehe auch {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Float32Array.prototype.toLocaleString()")}}</dt> + <dd>Gibt einen Ortsabhängige Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Float32Array.prototype.toString()")}}</dt> + <dd>Gibt einen Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Float32Array.prototype[@@iterator]()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die zugehörigen Werte für jeden Index im Array enthalten.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Verschiedene Wege, um ein <code>Float32Array</code> zu erstellen:</p> + +<pre class="brush: js">// From a length +var float32 = new Float32Array(2); +float32[0] = 42; +console.log(float32[0]); // 42 +console.log(float32.length); // 2 +console.log(float32.BYTES_PER_ELEMENT); // 4 + +// From an array +var arr = new Float32Array([21,31]); +console.log(arr[1]); // 31 + +// From another TypedArray +var x = new Float32Array([21, 31]); +var y = new Float32Array(x); +console.log(y[0]); // 21 + +// From an ArrayBuffer +var buffer = new ArrayBuffer(16); +var z = new Float32Array(buffer, 0, 4); + +// From an iterable +var iterable = function*(){ yield* [1,2,3]; }(); +var float32 = new Float32Array(iterable); +// Float32Array[1, 2, 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt in ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition in einem ECMA Standard. Spezifiziert, dass ein <code>new</code> benötigt wird.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>ECMAScript 2017 ändert den <code>Float32Array</code> Konstruktor, um die <code>ToIndex</code> Operation zu benutzen und erlaubt einen Konstruktor ohne Parameter.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Float32Array")}}</p> + +<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2> + +<p>Mit Beginn von ECMAScript 2015, müssen <code>Float32Array</code> Konstruktoren mit einem {{jsxref("Operators/new", "new")}} benutzt werden. Der Aufruf eines <code>Float32Array</code> Konstruktors als eine Funktion ohne <code>new</code>, Führt jetzt zu einem {{jsxref("TypeError")}}.</p> + +<pre class="brush: js example-bad">var dv = Float32Array([1, 2, 3]); +// TypeError: calling a builtin Float32Array constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new Float32Array([1, 2, 3]);</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript getypte Arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/float64array/index.html b/files/de/web/javascript/reference/global_objects/float64array/index.html new file mode 100644 index 0000000000..6d3b5003d8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/float64array/index.html @@ -0,0 +1,204 @@ +--- +title: Float64Array +slug: Web/JavaScript/Reference/Global_Objects/Float64Array +tags: + - Constructor + - JavaScript + - TypedArray + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/Float64Array +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Float64Array</code></strong> getypte Array repräsentiert ein Array von 64 Bit Gleitkommazahlen (entspricht dem C Datentyp <code>double</code>) in der Plattform-Byte-Reihenfolge. Wenn Kontrolle über die Byte-Reihenfolge erforderlich ist, muss stattdessen {{jsxref("DataView")}} benutz werden. Die Inhalte werden mit <code>0</code> initialisiert. Wie erwartet, kann man Elemente in einem Array mit Objektmethoden referenzieren oder man benutzt die normale Array-Index-Syntax (das ist die Klammernotation).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new Float64Array(); // new in ES2017 +new Float64Array(length); +new Float64Array(typedArray); +new Float64Array(object); +new Float64Array(buffer [, byteOffset [, length]]);</pre> + +<p>Für mehr Informationen über die Konstruktorensyntax und die Parameter, siehe auf der Seite <em><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float64Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Gibt die Größe der Elemente zurück. <code>8</code> im Falle eines <code>Float64Array</code>.</dd> + <dt>Float64Array.length</dt> + <dd>Statische Längeneigenschaft, welche den Wert 0 hat. Für die aktuelle Länge (Anzahl der Elemente) siehe {{jsxref("TypedArray.prototype.length", "Float64Array.prototype.length")}}.</dd> + <dt>{{jsxref("TypedArray.name", "Float64Array.name")}}</dt> + <dd>Gibt den Stringwert des Konstruktornamens zurück. In Fall eines <code>Float64Array</code> Typs: <code>"Float64Array"</code>.</dd> + <dt>{{jsxref("TypedArray.prototype", "Float64Array.prototype")}}</dt> + <dd>Prototyp für das <em>TypedArray</em> Objekt</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Float64Array.from()")}}</dt> + <dd>Erstellt ein neues <code>Float64Array</code> von einem Array-ähnlichen oder iterierbaren Objekt. Siehe auch {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Float64Array.of()")}}</dt> + <dd>Erstellt ein neues <code>Float64Array</code> mit einer variablen Anzahl an Argumenten. Sie auch {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Float64Array_Prototyp"><code>Float64Array</code> Prototyp</h2> + +<p>Alle <code>Float64Array</code> Objekte erben von {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<dl> + <dt><code>Float64Array.prototype.constructor</code></dt> + <dd>Gibt die Funktion, die einen Instanzprototyp erstellt, zurück. Diese ist auf den <code>Float64Array</code> Konstruktor voreingestellt.</dd> + <dt>{{jsxref("TypedArray.prototype.buffer", "Float64Array.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Gibt die {{jsxref("ArrayBuffer")}} Referenz zurück, welche nach der Erstellung eines <code>Float64Array</code> fest ist und nicht mehr geändert werden kann.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Float64Array.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Gibt die Länge (in Bytes) des <code>Float64Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. Wird beim Erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float64Array.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Gibt das Offset (in Bytes) des <code>Float64Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. Wird beim Erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.length", "Float64Array.prototype.length")}} {{readonlyInline}}</dt> + <dd>Gibt die Anzahl der Elemente des <code>Float64Array</code> zurück. Wird beim Erstellen festgesetzt und kann nicht geändert werden.</dd> +</dl> + +<h3 id="Methoden_2">Methoden</h3> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Float64Array.prototype.copyWithin()")}}</dt> + <dd>Kopiert eine Sequenz von Arrayelementen in das Array. Siehe auch {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Float64Array.prototype.entries()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Schlüssel/Wertepaare für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Float64Array.prototype.every()")}}</dt> + <dd>Teste, ob alle Elemente einem, als Funktion übergebenen, Test erfüllen. Siehe auch Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Float64Array.prototype.fill()")}}</dt> + <dd>Füllt alle Elemente eines Arrays vom Startindex bis zum Endindex mit einem statischen Wert. Siehe auch {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Float64Array.prototype.filter()")}}</dt> + <dd>Erstellt ein neues Array mit allen Elementen des alten Arrays, für die eine übergebene Filterfunktion <code>true</code> zurückgibt. Siehe auch {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Float64Array.prototype.find()")}}</dt> + <dd>Gibt ein gefundenes Element des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>undefined</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Float64Array.prototype.findIndex()")}}</dt> + <dd>Gibt den Index eines gefundenen Elements des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Float64Array.prototype.forEach()")}}</dt> + <dd>Ruft für jedes Element in einem Array eine Funktion auf. Siehe auch {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Float64Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Überprüft, ob ein getyptes Array ein bestimmtes Element enthält und gibt gegebenfalls <code>true</code> oder <code>false</code> zurück. Siehe auch {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Float64Array.prototype.indexOf()")}}</dt> + <dd>Gibt den ersten Index eines Elementes zurück, welches kongruent eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Float64Array.prototype.join()")}}</dt> + <dd>Führt alle Elemente eines Arrays zu einem String zusammen. Siehe auch {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Float64Array.prototype.keys()")}}</dt> + <dd>Gibt ein neuen <code>Array Iterator</code> zurück, der alle Schlüssel für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Float64Array.prototype.lastIndexOf()")}}</dt> + <dd>Gibt den letzen Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Float64Array.prototype.map()")}}</dt> + <dd>Erstellt ein neues Array mit den Resultaten einer für jedes Element aufgerufenen Funtion. Siehe auch {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.move", "Float64Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt> + <dd>Ehemalige, nicht standardisierte Version von {{jsxref("TypedArray.copyWithin", "Float64Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Float64Array.prototype.reduce()")}}</dt> + <dd>Führt eine Funktion gegen einen Akkumulator und jeden Wert des Array aus (von links nach rechts), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Float64Array.prototype.reduceRight()")}}</dt> + <dd>Führt eine Funktion gegen einen Akkumulator und jeden Wert des Array aus (von rechts nach links), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Float64Array.prototype.reverse()")}}</dt> + <dd>Kehrt die Reihenfolge von jedem Element eines Arrays um — das Erste wird das Letzte und das Letzte wird das Erste. Siehe auch {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Float64Array.prototype.set()")}}</dt> + <dd>Speichert mehrere Werte in einem getypten Array und liest Eingabewerte aus einem spezifiziertem Array.</dd> + <dt>{{jsxref("TypedArray.slice", "Float64Array.prototype.slice()")}}</dt> + <dd>Extrahiert einen Bereich aus einem Array und gibt diesen in einem neuen Array zurück. Siehe auch {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Float64Array.prototype.some()")}}</dt> + <dd>Gibt <code>true</code> zurück, wenn nur ein Element in einem Array, den als Funktion übergebenen, Test erfüllt. Siehe auch {{jsxref("Array.prototype.some()")}}</dd> + <dt>{{jsxref("TypedArray.sort", "Float64Array.prototype.sort()")}}</dt> + <dd>Sortiert die Elemente eines Arrays in-Place und gibt das Array zurück. Siehe auch {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Float64Array.prototype.subarray()")}}</dt> + <dd>Gibt ein neues <code>Float64Array</code> vom gegebenen Start- und Endindex zurück.</dd> + <dt>{{jsxref("TypedArray.values", "Float64Array.prototype.values()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Werte von jedem Index im Array enthält. Siehe auch {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Float64Array.prototype.toLocaleString()")}}</dt> + <dd>Gibt eine ortsabhängige Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Float64Array.prototype.toString()")}}</dt> + <dd>Gibt eine Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Float64Array.prototype[@@iterator]()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die zugehörigen Werte für jeden Index im Array enthalten.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Verschiedene Wege, um ein <code>Float64Array</code> zu erstellen:</p> + +<pre class="brush: js">// From a length +var float64 = new Float64Array(2); +float64[0] = 42; +console.log(float64[0]); // 42 +console.log(float64.length); // 2 +console.log(float64.BYTES_PER_ELEMENT); // 8 + +// From an array +var arr = new Float64Array([21,31]); +console.log(arr[1]); // 31 + +// From another TypedArray +var x = new Float64Array([21, 31]); +var y = new Float64Array(x); +console.log(y[0]); // 21 + +// From an ArrayBuffer +var buffer = new ArrayBuffer(32); +var z = new Float64Array(buffer, 0, 4); + +// From an iterable +var iterable = function*(){ yield* [1,2,3]; }(); +var float64 = new Float64Array(iterable); +// Float64Array[1, 2, 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt in ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA Standard. Spezifiziert, dass ein <code>new</code> benötigt wird.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>ECMAScript 2017 ändert den <code>Float64Array</code> Konstruktor, um die <code>ToIndex</code> Operation zu benutzen und erlaubt einen Konstruktor ohne Parameter.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Float64Array")}}</p> + +<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2> + +<p>Mit Beginn von ECMAScript 2015, müssen <code>Float64Array</code> Konstruktoren mit einem {{jsxref("Operators/new", "new")}} benutzt werden. Der Aufruf eines <code>Float64Array</code> Konstruktors als eine Funktion ohne <code>new</code> führt jetzt zu einem {{jsxref("TypeError")}}.</p> + +<pre class="brush: js example-bad">var dv = Float64Array([1, 2, 3]); +// TypeError: calling a builtin Float64Array constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new Float64Array([1, 2, 3]);</pre> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript getypte Arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/apply/index.html b/files/de/web/javascript/reference/global_objects/function/apply/index.html new file mode 100644 index 0000000000..784843e276 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/apply/index.html @@ -0,0 +1,226 @@ +--- +title: Function.prototype.apply() +slug: Web/JavaScript/Reference/Global_Objects/Function/apply +tags: + - Function + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>apply()</strong></code> Methode ruft eine Funktion mit gegebenem <code>this</code> Wert und <code>arguments</code> als Array (oder einem <a href="/de/docs/Web/JavaScript/Guide/Indexed_collections#Mit_Array-ähnlichen_Objekten_arbeiten">Array ähnlichem Objekt</a>).</p> + +<div class="note"> +<p><strong>Hinweis:</strong> Die Syntax dieser Funktion ist größtenteils identisch zu der Funktion {{jsxref("Function.call", "call()")}}. Der fundamentale Unterschied ist, dass <code>call()</code> <strong>eine Liste von Argumenten</strong> und <code>apply()</code> <strong>ein Array mit Argumenten</strong> übergeben bekommt.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/function-apply.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>function</var>.apply(<var>thisArg</var>, [<var>argsArray</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd>Optional. Der Wert von <code>this</code>, der für den Aufruf der Funktion <em><code>func</code></em> genutzt wird. Zu beachten ist, dass <code>this</code> möglicherweise nicht der Wert ist, den die Methode sieht: Wenn die Methode eine Funktion im {{jsxref("Functions_and_function_scope/Strict_mode", "non-strict mode", "", 1)}} ist, werden {{jsxref("Global_Objects/null", "null")}} und {{jsxref("Global_Objects/undefined", "undefined")}} mit dem globalen Objekt ersetzt und primitive Werte werden in ein Hüllobjekt umgewandelt.</dd> + <dt><code>argsArray</code></dt> + <dd>Optional. Ein Array ähnliches Objekt, welches die Argumente spezifiziert, welche beim Aufruf von <em><code>func</code></em> benutzt werden, oder {{jsxref("null")}} oder {{jsxref("undefined")}}, wenn keine Argumente übergeben werden. Mit Einführung von ECMAScript 5 können diese Argumente mit einem generische Array ähnliches Objekt statt einem Array übergeben werden. Für mehr Informationen sollte die {{anch("Browserkompatibilität", "Browserkompatibilität")}} geprüft werden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das Ergebnis der aufgerufenen Funktion mit dem spezifischen <code><strong>this</strong></code> Wert und Parametern.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Man kann ein anderes <code>this</code> Objekt für den Aufruf einer existierenden Funktion zuweisen. <code>this</code> referenziert zum aktuellen Objekte, dem aufrufenden Objekt. Mit <code>apply</code> kann eine Methode geschrieben und in einem anderen Objekt vererbt werden, ohne die Methode für das neue Objekte neu zu schreiben.</p> + +<p><code>apply</code> ist sehr ähnlich zu {{jsxref("Function.call", "call()")}}, mit der Ausnahme des Typen der übergebenen Argumente. Man kann ein Array von Argumenten statt einer Menge von benannten Parametern benutzen. Mit <code>apply</code> kann man ein Arrayliteral benutzen, wie zum Beispiel <code>fun.apply(this, ['eat', 'bananas'])</code> oder ein {{jsxref("Array")}} Objekt, wie zum Beispiel <code>fun.apply(this, new Array('eat', 'bananas'))</code>.</p> + +<p>Für den <code>argsArray</code> Parameter kann auch {{jsxref("Functions/arguments", "arguments")}} eingesetzt werden. <code>arguments</code> ist eine lokale Variable einer Funktion. Sie kann für alle nicht spezifizieren Argumente bei einem Aufruf benutzt werde. Dadurch muss man die Argumente eines Aufrufers nicht kennen, wenn die <code>apply</code> Methode genutzt wird. Man kann <code>arguments</code> nutzen, um alle Argumente eines Aufrufers zu übergeben. Das aufgerufene Objekt ist dann verantwortlich für das Verarbeiten der Argument.</p> + +<p>Seit ECMAScript in der 5. Ausgabe kann jedes Objekt übergeben werden, welches Array ähnlich ist, was in der Praxis bedeutet, dass es eine <code>length</code> Eigenschaft hat und Ganzzahlige Eigenschaften im Bereich von <code>0</code> bis <code>length-1</code> besitzt. Zum Beispiel kann man {{domxref("NodeList")}} oder benutzerdefinierte Objekte wie <code>{ 'length': 2, '0': 'eat', '1': 'bananas' }</code> benutzen.</p> + +<div class="note">Viele Browser, auch Chrome 14 und Internet Explorer 9, unterstützen keine Array ähnlichen Objekte, was zu einem Fehler führt.</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_apply_um_ein_Array_an_ein_anderes_zu_hängen">Einsatz von <code>apply</code> um ein Array an ein anderes zu hängen</h3> + +<p>Man kann <code>push</code> benutzen, um ein Element an ein Array anzufügen. Weil <code>push</code> eine variable Anzahl von Argumenten enthält, kann man auch mehrere Element mit einem Aufruf hinzufügen. Übergibt man jedoch ein Array an die <code>push</code> Methode, so wird das Array als ein Element hinzugefügt anstatt jedes Element des Arrays hinzuzufügen, was zu einem Array im Array führt. Was tun, wenn das nicht das ist, was gewollt ist? <code>concat</code> hat das gewünschte verhalten, jedoch erstellt es ein neues Array und fügt die Elemente nicht an das existierende Array. Was wenn man die Elemente unbedingt an das existierende Array hängen möchte? Eine Schleife schreiben? Sicher nicht!</p> + +<p><code>apply</code> ist die Funktion der Wahl!</p> + +<pre class="brush: js">var array = ['a', 'b']; +var elements = [0, 1, 2]; +array.push.apply(array, elements); +console.info(array); // ["a", "b", 0, 1, 2] +</pre> + +<h3 id="Einsatz_von_apply_und_eingebauten_Standardfunktionen">Einsatz von <code>apply</code> und eingebauten Standardfunktionen</h3> + +<p>Der clevere Einsatz von <code>apply</code> erlaubt es standard Functionen für Aufgaben zu benutzen, für die man sonst schleifen Schreiben müsste, um über alle Elemente eines Arrays zu iterieren. Im folgenden Beispiel wurde <code>Math.max</code>/<code>Math.min</code> benutzt, um das maximalen/minimalen Wert in einem Array zu finden.</p> + +<pre class="brush: js">// min/max number in an array +var numbers = [5, 6, 2, 3, 7]; + +// using Math.min/Math.max apply +var max = Math.max.apply(null, numbers); +// This about equal to Math.max(numbers[0], ...) +// or Math.max(5, 6, ...) + +var min = Math.min.apply(null, numbers); + +// vs. simple loop based algorithm +max = -Infinity, min = +Infinity; + +for (var i = 0; i < numbers.length; i++) { + if (numbers[i] > max) { + max = numbers[i]; + } + if (numbers[i] < min) { + min = numbers[i]; + } +} +</pre> + +<p>Jedoch muss man bei einem solchen Einsatz von <code>apply</code> vorsichtig sein, weil das Risiko da ist, dass man in das Limit der maximalen Argumente der JavaScriptumgebung überschreitet. Die Konsequenz aus dem ausführen von Funktionen mit zu vielen Argumenten (mehr als Zehntausend Argumente) ist, dass dieses Limit stark variiert (JavaScriptCore hat ein hart Codiertes <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=80797">Argumentlimit von 65536</a>), weil es in JavaScript nicht spezifiziert ist (<span id="result_box" lang="de"><span>tatsächlich sogar die Art eines übermäßig großen Stack-Verhaltens</span></span>). Einige Umgebungen erzeugen einen Fehler. Andere übergeben nicht alle Argumente der Funktion, um das Limit nicht zu überschreiten. Um diesen Fall man zu schildern: Wenn eine Umgebung ein Limit von 4 Argumenten hätte (aktuelle Limits sind natürlich signifikant höher), würde es so sein, als ob nur die Argumente <code>5, 6, 2, 3</code> über <code>apply</code> im oberen Beispiel übergeben werden, statt dem ganzen Array.</p> + +<p>Wenn das Array in einigen Fällen so groß wird, dass es zehntausend Element erreicht, sollte eine hybride Strategie genutzt werden: Man teilt das Array auf und übergibt diese Teile der Funktion:</p> + +<pre class="brush: js">function minOfArray(arr) { + var min = Infinity; + var QUANTUM = 32768; + + for (var i = 0, len = arr.length; i < len; i += QUANTUM) { + var submin = Math.min.apply(null, + arr.slice(i, Math.min(i+QUANTUM, len))); + min = Math.min(submin, min); + } + + return min; +} + +var min = minOfArray([5, 6, 2, 3, 7]); +</pre> + +<h3 id="apply_für_das_Verketten_von_Konstruktoren_verwenden"><code>apply</code> für das Verketten von Konstruktoren verwenden</h3> + +<p>Man kann <code>apply</code> einsetzen, um {{jsxref("Operators/new", "Konstruktoren", "", 1)}} für ein Objekt zu verketten, ähnlich wie in Java. Im folgenden Beispiel wird eine globale {{jsxref("Function")}} Methode namens <code>construct</code> erstellt, welche es ermöglicht ein Array ähnliches Objekt mit einem Konstruktor anstatt eines Argumentliste zu benutzen.</p> + +<pre class="brush: js">Function.prototype.construct = function (aArgs) { + var oNew = Object.create(this.prototype); + this.apply(oNew, aArgs); + return oNew; +}; +</pre> + +<div class="note" style="height: 250px; overflow: auto;"> +<p><strong>Hinweis:</strong> Die oben eingesetzte <code>Object.create()</code> Methode ist relativ neu. Alternativ kann eine der folgenden Ansätze verwendet werden:</p> + +<p>Einsatz von {{jsxref("Object/__proto__", "Object.__proto__")}}:</p> + +<pre class="brush: js">Function.prototype.construct = function (aArgs) { + var oNew = {}; + oNew.__proto__ = this.prototype; + this.apply(oNew, aArgs); + return oNew; +}; +</pre> + +<p>Einsatz von <a href="/de/docs/Web/JavaScript/Closures">Closures</a>:</p> + +<pre class="brush: js">Function.prototype.construct = function(aArgs) { + var fConstructor = this, fNewConstr = function() { + fConstructor.apply(this, aArgs); + }; + fNewConstr.prototype = fConstructor.prototype; + return new fNewConstr(); +};</pre> + +<p>Einsatz von {{jsxref("Function")}} Konstruktoren:</p> + +<pre class="brush: js">Function.prototype.construct = function (aArgs) { + var fNewConstr = new Function(""); + fNewConstr.prototype = this.prototype; + var oNew = new fNewConstr(); + this.apply(oNew, aArgs); + return oNew; +}; +</pre> +</div> + +<p>Beispiel für den Einsatz:</p> + +<pre class="brush: js">function MyConstructor() { + for (var nProp = 0; nProp < arguments.length; nProp++) { + this['property' + nProp] = arguments[nProp]; + } +} + +var myArray = [4, 'Hello world!', false]; +var myInstance = MyConstructor.construct(myArray); + +console.log(myInstance.property1); // logs 'Hello world!' +console.log(myInstance instanceof MyConstructor); // logs 'true' +console.log(myInstance.constructor); // logs 'MyConstructor' +</pre> + +<div class="note"> +<p><strong>Hinweis:</strong> Diese nicht native <code>Function.construct</code> Methode funktioniert nicht mit einigen nativen Konstruktoren (mit {{jsxref("Date")}} zum Beispiel). In diesem Fall muss man die {{jsxref("Function.prototype.bind")}} Methode (hat man zum Beispiel ein Array ähnliches Objekt wie folgt, um mit dem {{jsxref("Global_Objects/Date", "Date")}} Konstruktor <code>[2012, 11, 4]</code> einzusetzen; in diesem Fall muss folgendes geschrieben werden: <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()</code> — Jedoch ist das nicht die beste Art und Weise Probleme zu Lösen, weshalb diese Lösung nicht Praxistauglich ist).</p> +</div> + +<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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.apply")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Functions/arguments", "arguments")}} object</li> + <li>{{jsxref("Function.prototype.bind()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions", "Functions and function scope", "", 1)}}</li> + <li>{{jsxref("Reflect.apply()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/arguments/index.html b/files/de/web/javascript/reference/global_objects/function/arguments/index.html new file mode 100644 index 0000000000..271120bd9d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/arguments/index.html @@ -0,0 +1,92 @@ +--- +title: Function.arguments +slug: Web/JavaScript/Reference/Global_Objects/Function/arguments +tags: + - Deprecated + - Function + - JavaScript + - Property + - arguments +translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>Die <code><strong><em>function</em>.arguments</strong></code> Eigenschaft referenziert ein Array ähnliches Objekt, welches die übergebenen Parameter einer Funktion enthält. Stattdessen kann die Variable {{jsxref("Functions/arguments", "arguments")}} benutzt werden. Diese Eigenschaft ist im Strict Mode aufgrund von <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-addrestrictedfunctionproperties">taill Aufrufoptimierung</a> verboten.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die Syntax <code><em>function</em>.arguments</code> ist veraltet. Der empfolene Weg, um das {{jsxref("Functions/arguments", "arguments")}} Objekt zu erreichen, ist in einer Funktion die Variable {{jsxref("Functions/arguments", "arguments")}} zu benutzen.</p> + +<p>Im Fall von Rekursion, z. B. wenn die Funktion <code>f</code> mehrere Male auf dem Aufruf-Stack ist, repräsentiert <code>f.arguments</code> die Argumente des letzten Aufrufes der Funktion.</p> + +<p>Der Wert der <code>arguments</code> Eigenschaft ist normalerweise <code>null</code>, wenn keine Durchführung der Funktion vorhanden ist (Durchführung bedeutet, dass die Funktion aufgerufen wurde, aber noch nichts zurückgegeben hat).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">function f(n) { g(n - 1); } + +function g(n) { + console.log('before: ' + g.arguments[0]); + if (n > 0) { f(n); } + console.log('after: ' + g.arguments[0]); +} + +f(2); + +console.log('returned: ' + g.arguments); + +// Output + +// before: 1 +// before: 0 +// after: 0 +// after: 1 +// returned: null +</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.0. Deprecated zugunsten von {{jsxref("Functions/arguments", "arguments")}} in ES3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>{{jsxref("Functions/arguments", "arguments")}} Objekt</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>{{jsxref("Functions/arguments", "arguments")}} Objekt</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>{{jsxref("Functions/arguments", "arguments")}} Objekt</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.arguments")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Functions/arguments", "arguments")}} object</li> + <li>{{jsxref("Functions", "Funktionen und Funktionsscopes", "", 1)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/arity/index.html b/files/de/web/javascript/reference/global_objects/function/arity/index.html new file mode 100644 index 0000000000..f5ff00bd27 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/arity/index.html @@ -0,0 +1,32 @@ +--- +title: Function.arity +slug: Web/JavaScript/Reference/Global_Objects/Function/arity +tags: + - Function + - JavaScript + - Obsolete + - Property + - Unimplemented +translation_of: Archive/Web/JavaScript/Function.arity +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p class="note">Die <code><strong>arity</strong></code> Eigenschaft wurde benutzt, um die Anzahl der erwarteten Argumente einer Funktion zurückzugeben, jedoch existiert diese Eigenschaft nicht mehr und wurde durch die Eigenschaft {{jsxref("Function.prototype.length")}} ersetzt.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Implementiert in JavaScript 1.2. Veraltet seit JavaScript 1.4.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.arity")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Function.prototype.length")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/bind/index.html b/files/de/web/javascript/reference/global_objects/function/bind/index.html new file mode 100644 index 0000000000..9427e62299 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/bind/index.html @@ -0,0 +1,286 @@ +--- +title: Function.prototype.bind() +slug: Web/JavaScript/Reference/Global_Objects/Function/bind +tags: + - Class + - ECMAScript 2015 + - ECMAScript 5 + - Function + - JavaScript + - Method + - bind + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>bind()</code></strong> Methode erzeugt eine neue Funktion die beim Aufruf ihr <code>this</code> Schlüsselwort auf den ersten übergebenen Wert setzt. Alle weiteren Argumente werden den beim Funktionsaufruf übergebenen Werten vorangestellt.</p> + +<div>{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>fun</var>ction.bind(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd>Der für <code>this</code> zu übergebende Wert an die Zielfunktion sobald die gebundene Funktion aufgerufen wird. Der Wert wird ignoriert, wenn die gebundene Funktion mit dem {{jsxref("Operators/new", "new")}} Schlüsselwort initiiert wurde.</dd> + <dt><code>arg1, arg2, ...</code></dt> + <dd>An die bind Funktion übergebene Werte. Diese Werte werden an die gebundene Funktion überreicht.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Kopie der gegebenen Funktion mit dem spezifizierten <strong><code>this</code></strong> Wert und initialen Parametern.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <strong>bind()</strong> Funktion erstellt eine neue <strong>gebundene Funktion (BF)</strong>. Eine <strong>BF</strong> ist <strong>ein exotisches Funktionsobjekte</strong> (ein Teil von <strong>ECMAScript 2015</strong>) welches die eigentliche Funktion umhüllt. Das Aufrufen einer <strong>BF</strong> führt zum ausführen der <strong>umhüllten Funktion</strong>. Eine <strong>BF</strong> hat die folgenden internen Eigenschaften:</p> + +<ul> + <li><strong>[[BoundTargetFunction]]</strong> - das umhüllte Funktionsobjekt;</li> + <li><strong>[[BoundThis]]</strong> - der Wert, der immer als <strong>this</strong> Wert beim Aufruf der umhüllten Funktion genutzt wird.</li> + <li><strong>[[BoundArguments]]</strong> - eine Liste von Werten, wessen Elemente als erste Argumente bei jedem Aufruf der umhüllten Funktion genutzt werden.</li> + <li><strong>[[Call]]</strong> - führt Code aus, der mit dem Objekte verbunden ist. Wird über ein Funktionsaufruf ausgeführt. Die Argumente der internen Methode sind ein <strong>this</strong> Wert und eine Liste mit Argumenten, welche beim Aufruf der Funktion übergeben werden.</li> +</ul> + +<p>Wenn die gebundene Funktion aufgerufen wird, ruft diese die interne Methode <strong>[[Call]]</strong> auf <strong>[[BoundTargetFunction]]</strong> mit den Argumenten <strong>Call(<em>boundThis</em>, <em>args</em>)</strong> auf. Dabei ist <strong><em>boundThis </em></strong>gleich <strong>[[BoundThis]]</strong> und <em><strong>args </strong></em>gleich <strong>[[BoundArguments]]</strong> gefolgt von den übergebenen Parametern des Funktionsaufrufes.</p> + +<p>Eine gebundene Funktion kann zudem mit einen <a href="/de/docs/Web/JavaScript/Reference/Operators/new" title="The new operator creates an instance of a user-defined object type or of one of the built-in object types that has a constructor function."><code>new</code></a> Operator erstellt werden: <span id="result_box" lang="de"><span>Das sieht so aus, als ob die Zielfunktion stattdessen konstruiert worden wäre</span></span>. Dar übergebene <strong><code>this</code></strong> Wert wird ignoriert, während die voranstehenden Argumente für die Emulierte Funktion zur Verfügung stehen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Erstellen_einer_gebunden_Funktion">Erstellen einer gebunden Funktion</h3> + +<p><span id="result_box" lang="de"><span>Die einfachste Verwendung von <code>bind()</code> besteht darin, eine Funktion zu erstellen, die, egal wie sie aufgerufen wird, mit einem <code><strong>this</strong></code> Wert aufgerufen wird. Ein häufiger Fehler für neue JavaScript-Programmierer besteht darin, eine Methode aus einem Objekt zu extrahieren, diese Funktion später aufzurufen und zu erwarten, dass sie das ursprüngliche Objekt als <code><strong>this</strong></code> verwendet (z. B. durch Verwendung dieser Methode in Callback-basiertem Code). Ohne besondere Sorgfalt ist das ursprüngliche Objekt jedoch in der Regel verloren. </span></span><span id="result_box" lang="de"><span>Das Erstellen einer gebundenen Funktion aus der Funktion, die das ursprüngliche Objekt verwendet, löst dieses Problem sauber:</span></span></p> + +<pre class="brush: js">this.x = 9; // this refers to global "window" object here in the browser +var module = { + x: 81, + getX: function() { return this.x; } +}; + +module.getX(); // 81 + +var retrieveX = module.getX; +retrieveX(); +// returns 9 - The function gets invoked at the global scope + +// Create a new function with 'this' bound to module +// New programmers might confuse the +// global var x with module's property x +var boundGetX = retrieveX.bind(module); +boundGetX(); // 81 +</pre> + +<h3 id="Partiell_gebunden_Funktionen">Partiell gebunden Funktionen</h3> + +<p>Der nächste einfache Einsatz von <code>bind()</code> ist das Vordefinieren von Initialparameter einer Funktion. Diese Argumente (wenn welche vorhanden) folgen auf den übergebenen <code>this</code> Wert und Werten am Anfang der Zielfunktion den Parametern hinzugefügt, gefolgt von den Parametern, die der gebunden Funktion übergeben werden, immer wenn die gebunden Funktion aufgerufen wird.</p> + +<pre class="brush: js">function list() { + return Array.prototype.slice.call(arguments); +} + +var list1 = list(1, 2, 3); // [1, 2, 3] + +// Create a function with a preset leading argument +var leadingThirtysevenList = list.bind(null, 37); + +var list2 = leadingThirtysevenList(); +// [37] + +var list3 = leadingThirtysevenList(1, 2, 3); +// [37, 1, 2, 3] +</pre> + +<h3 id="Mit_setTimeout">Mit <code>setTimeout</code></h3> + +<p>Bei {{domxref("window.setTimeout()")}} wird im Standardfall das <code>this</code> Schlüsselwort mit dem {{ domxref("window") }} (oder <code>global</code>) Objekt versehen. Wenn mit Klassenmethoden gearbeitet wird, die es vorgesehen, dass <code>this</code> zu der Klasseninstanz verweist, muss <code>this</code> explizit an die Callback-Funktion gebunden werden, damit die Instanz vorhanden ist.</p> + +<pre class="brush: js">function LateBloomer() { + this.petalCount = Math.floor(Math.random() * 12) + 1; +} + +// Declare bloom after a delay of 1 second +LateBloomer.prototype.bloom = function() { + window.setTimeout(this.declare.bind(this), 1000); +}; + +LateBloomer.prototype.declare = function() { + console.log('I am a beautiful flower with ' + + this.petalCount + ' petals!'); +}; + +var flower = new LateBloomer(); +flower.bloom(); +// after 1 second, triggers the 'declare' method</pre> + +<h3 id="Gebunden_Funktion_mit_einem_Konstruktor">Gebunden Funktion mit einem Konstruktor</h3> + +<div class="warning"> +<p><strong>Warnung:</strong> Dieses Kapitel demonstriert JavaScript-möglichkeiten und dokumentiert Randfälle der <code>bind()</code> Methode. Die Methoden, die unten gezeigt werden, sind nicht die Besten, um Dinge zu lösen, weshalb sie nicht in einem Produktivsystem eingesetzt werden sollten.</p> +</div> + +<p>Gebundene Funktion sind automatisch verfügbar für den Einsatz mit dem {{jsxref("Operators/new", "new")}} Operator, um eine neue Instanz von einer Zielfunktion zu erstellen. Wenn eine gebundene Funktion eingesetzt wird, um einen Wert zu erstellen, wird das unterstützte <code>this</code> Argument ignoriert. Dahingegen werden unterstützte Argumente vor den Konstruktoraufrufe vorgehängt:</p> + +<pre class="brush: js">function Point(x, y) { + this.x = x; + this.y = y; +} + +Point.prototype.toString = function() { + return this.x + ',' + this.y; +}; + +var p = new Point(1, 2); +p.toString(); // '1,2' + +// not supported in the polyfill below, + +// works fine with native bind: + +var YAxisPoint = Point.bind(null, 0/*x*/); + + +var emptyObj = {}; +var YAxisPoint = Point.bind(emptyObj, 0/*x*/); + +var axisPoint = new YAxisPoint(5); +axisPoint.toString(); // '0,5' + +axisPoint instanceof Point; // true +axisPoint instanceof YAxisPoint; // true +new Point(17, 42) instanceof YAxisPoint; // true +</pre> + +<p>Zu beachten ist, dass nichts spezielles getan werden muss, um eine gebundene Funktion mit {{jsxref("Operators/new", "new")}} zu erstellen. <span id="result_box" lang="de"><span>Die Folge ist, dass man nichts Besonderes tun muss, um eine gebundene Funktion zu erzeugen, die einfach aufgerufen werden kann, selbst wenn es gewollt ist, dass die gebundene Funktion nur mit </span></span>{{jsxref("Operators/new", "new")}} <span lang="de"><span>aufgerufen wird:</span></span></p> + +<pre class="brush: js">// Example can be run directly in your JavaScript console +// ...continuing from above + +// Can still be called as a normal function +// (although usually this is undesired) +YAxisPoint(13); + +emptyObj.x + ',' + emptyObj.y; +// > '0,13' +</pre> + +<p>Wenn es gewünscht ist, dass der Einsatz von gebundenen Funktion nur mit {{jsxref("Operators/new", "new")}} oder einem einfachen Aufruf sein soll, so muss die Zielfunktion diese Einschränkung erzwingen.</p> + +<h3 id="Kurzformen_erstellen">Kurzformen erstellen</h3> + +<p><code>bind()</code> ist nützlich in fällen, in denen man kurzformen erstellen will, bei denen ein spezifischer <strong><code>this</code></strong> vorhanden sein soll.</p> + +<p>Nimmt man zum Beispiel {{jsxref("Array.prototype.slice")}}, welche man zum Konvertieren von Array ähnlichen Objekte zu einem richtigen Array einsetzen mögliche, dann kann man eine Kurzform wie diese erstellen:</p> + +<pre class="brush: js">var slice = Array.prototype.slice; + +// ... + +slice.apply(arguments); +</pre> + +<p>Mit <code>bind()</code>, kann dieses vereinfacht werden. Im folgenden Codestück ist <code>slice</code> eine gebunden Funktion zu der {{jsxref("Function.prototype.apply()", "apply()")}} Funktion von {{jsxref("Function.prototype")}} mit dem <strong><code>this</code></strong> Wert auf der {{jsxref("Array.prototype.slice()", "slice()")}} Funktion von {{jsxref("Array.prototype")}}. Das bedeutet, dass der zusätzliche Aufruf von <code>apply()</code> nicht nötig ist:</p> + +<pre class="brush: js">// same as "slice" in the previous example +var unboundSlice = Array.prototype.slice; +var slice = Function.prototype.apply.bind(unboundSlice); + +// ... + +slice(arguments); +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Wenn die <code>bind()</code> Funktion nicht vorhanden ist, kann ein Großteil der Funktionalität mit trotzdem hinzugefügt werden, indem der folgende Quelltext am Anfang des Skriptes hinzugefügt wird.</p> + +<pre class="brush: js">if (!Function.prototype.bind) { + Function.prototype.bind = function(oThis) { + if (typeof this !== 'function') { + // closest thing possible to the ECMAScript 5 + // internal IsCallable function + throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable'); + } + + var aArgs = Array.prototype.slice.call(arguments, 1), + fToBind = this, + fNOP = function() {}, + fBound = function() { + return fToBind.apply(this instanceof fNOP + ? this + : oThis, + aArgs.concat(Array.prototype.slice.call(arguments))); + }; + + if (this.prototype) { + // Function.prototype doesn't have a prototype property + fNOP.prototype = this.prototype; + } + fBound.prototype = new fNOP(); + + return fBound; + }; +} +</pre> + +<p><span id="result_box" lang="de"><span>Einige der vielen Unterschiede (es kann durchaus andere geben, weil bei dieser Liste nicht auf Vollständig geachtet wurde) zwischen diesem Algorithmus und dem angegebenen Algorithmus sind:</span></span></p> + +<ul> + <li>Die partielle Implementierung basiert auf der {{jsxref("Array.prototype.slice()")}}, {{jsxref("Array.prototype.concat()")}}, {{jsxref("Function.prototype.call()")}} und {{jsxref("Function.prototype.apply()")}} Methode, um die Originalen Werte zu erhalten.</li> + <li>Die partielle Implementierung erstellt Funktionen, die keinen unveränderbar {{jsxref("Function.caller", "caller")}} haben und eine <code>arguments</code> Eigenschaft die einen {{jsxref("Global_Objects/TypeError", "TypeError")}} auslöst, wenn get, set oder deletion benutzt wird. (Dieses kann hinzugefügt werden, wenn die Implementierung {{jsxref("Object.defineProperty")}} unterstützt oder partiell implementiert [ohne das Löschverhalten], wenn die Implementierung {{jsxref("Object.defineGetter", "__defineGetter__")}} und {{jsxref("Object.defineSetter", "__defineSetter__")}} Erweiterungen unterstützt.)</li> + <li>Die partielle Implementierung erstellt Funktionen, die einen <code>prototype</code> Eigenschaft haben. (Normale gebundene Funktionen haben keine)</li> + <li>Die partielle Implementierung erstellt gebundene Funktionen mit der {{jsxref("Function.length", "length")}} Eigenschaft, die nicht mit ECMA-262 übereinstimmt: Sie erstellt Funkton mit <code>length</code> 0, während bei der vollständigen Implementierung die Länge von der Zielfunktion und der Anzahl von vordefinierten Parametern abhängt und daher eine andere Länge zurück geben kann.</li> +</ul> + +<p>Wenn diese partielle Implementierung eingesetzt wird, <strong>muss man davon ausgehen, dass dessen Verhalten von dem in ECMA-262 in der 5. Auflage unterscheidet!</strong> Mit etwas Vorsicht (und vielleicht kleinen Modifizierungen für spezielle Anforderungen) kann diese partielle Implementierung eine gute Übergangslösung für die Zeit sein, in der <code>bind()</code> noch nicht in allen Umgebungen unterstützt wird.</p> + +<p>Auf <a href="https://github.com/Raynos/function-bind">https://github.com/Raynos/function-bind</a> könnte es eine gründlichere Lösung geben!</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('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.bind")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Function.prototype.apply()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions", "Functions", "", 1)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/call/index.html b/files/de/web/javascript/reference/global_objects/function/call/index.html new file mode 100644 index 0000000000..46bdb07442 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/call/index.html @@ -0,0 +1,163 @@ +--- +title: Function.prototype.call() +slug: Web/JavaScript/Reference/Global_Objects/Function/call +tags: + - Function + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Function/call +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>call()</strong></code> Methode ruft eine Funktion mit dem Argument this und den individuellen Parametern auf.</p> + +<div class="note"> +<p><strong>Hinweis:</strong> Die Syntax dieser Funktion ist nahezu identisch zu {{jsxref("Function.prototype.apply", "apply()")}}. Der Unterschied ist, dass <code>call()</code> eine <strong>Liste von Argumenten</strong> und <code>apply()</code> einen einzelnen <strong>Array von Argumenten</strong> akzeptiert.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/function-call.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>fun</var>ction.call(<var>thisArg</var>, <var>arg1</var>, <var>arg2</var>, ...)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd>Optional. Der Wert von <code>this</code>, der für den Aufruf der Funktion <em><code>function</code></em> genutzt wird. Zu beachten ist, dass <code>this</code> möglicherweise nicht der Wert ist, den die Methode sieht: Wenn die Methode eine Funktion in {{jsxref("Functions_and_function_scope/Strict_mode", "non-strict mode", "", 1)}} ist, werden {{jsxref("Global_Objects/null", "null")}} und {{jsxref("Global_Objects/undefined", "undefined")}} mit dem globalen Objekt ersetzt und primitive Werte werden in ein Hüllobjekt umgewandelt.</dd> + <dt><code>arg1, arg2, ...</code></dt> + <dd>Argumente für das Objekt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das Ergebnis der aufgerufenen Funktion mit dem spezifischen <code><strong>this</strong></code> Wert und Parametern.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Beim Aufruf einer existierenden Funktion können Sie für <code>this</code> ein neues Objekt zuweisen. <code>this</code> verweist auf das aktuelle Objekt, also das aufrufende Objekt. Mit call können Sie eine Methode schreiben und an ein anderes Objekt vererben, ohne die Methode für das neue Objekt neuzuschreiben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nutzung_von_call_um_Konstruktoren_für_ein_Objekt_zu_verketten">Nutzung von <code>call</code>, um Konstruktoren für ein Objekt zu verketten</h3> + +<p>Man kann <code>call</code> nutzen, um Konstruktoren für ein Objekt, ähnlich wie in Java, zu verketten. Im folgenden Beispiel wird der Konstruktor für das <code>Product</code> Objekt mit zwei Parametern, <code>name</code> und <code>price</code>, definiert. Zwei andere Funktionen <code>Food</code> und <code>Toy</code> rufen <code>Product</code> auf und übergeben <code>this</code>, <code>name</code> und <code>price</code>. <code>Product</code> initialisiert die Eigenschaften <code>name</code> und <code>price</code> und beide speziellen Funktionen definieren <code>category</code>.</p> + +<pre class="brush: js">function Product(name, price) { + this.name = name; + this.price = price; +} + +function Food(name, price) { + Product.call(this, name, price); + this.category = 'food'; +} + +function Toy(name, price) { + Product.call(this, name, price); + this.category = 'toy'; +} + +var cheese = new Food('feta', 5); +var fun = new Toy('robot', 40); +</pre> + +<h3 id="Nutzung_von_call_zum_Aufruf_einer_anonymen_Funktion">Nutzung von <code>call</code> zum Aufruf einer anonymen Funktion</h3> + +<p>In diesem komplett konstruierten Beispiel erstellen wir eine anonyme Funktion und nutzen <code>call</code>, um diese für jedes Objekt in einem Array aufzurufen. Der Hauptnutzen für die Nutzung anonymer Funktionen hier, ist das hinzufügen einer Print-Funktion für jedes Objekt, welche den rechten Index des Objekts in dem eingegebenen Array ausgeben kann. Die Übergabe des Objektes als <code>this</code>-Wert ist hier nicht zwingend erforderlich, wurde aber zur Veranschaulichung genutzt.</p> + +<pre class="brush: js">var animals = [ + { species: 'Lion', name: 'King' }, + { species: 'Whale', name: 'Fail' } +]; + +for (var i = 0; i < animals.length; i++) { + (function(x) { + this.print = function() { + console.log('#' + x + ' ' + this.species + + ': ' + this.name); + } + this.print(); + }).call(animals[i], i); +} +</pre> + +<h3 id="Einsatz_von_call_zum_aufrufen_einer_Funktion_mit_spezifiziertem_Kontext_für_'this'">Einsatz von <code>call</code> zum aufrufen einer Funktion mit spezifiziertem Kontext für '<code>this</code>'</h3> + +<p>Im unten stehenden Beispiel wird das <code>this</code>Objekt der <code>greet</code> Funktion beim Aufruf auf <code>obj</code> gesetzt.</p> + +<pre class="brush: js">function greet() { + var reply = [this.animal, 'typically sleep betreen', this.sleepDuration].join(' '); + console.log(reply); +} + +var obj = { + animal: 'cats', sleepDuration: '12 and 16 hours' +}; + +greet.call(obj); // cats typically sleep between 12 and 16 hours +</pre> + +<h3 id="Eine_Funktion_mit_call_ausführen_ohne_den_ersten_Parameter_zu_setzen.">Eine Funktion mit <code>call</code> ausführen ohne den ersten Parameter zu setzen.</h3> + +<p>Im unten stehenden Beispiel wird die <code>display</code> Funktion aufgerufen ohne den ersten Parameter zu übergeben. Wenn der erste Parameter nicht übergeben wird, ist <code>this</code> das globale Objekt.</p> + +<pre class="brush: js">var sData = 'Wisen'; + +function display(){ + console.log('sData value is %s', this.sData); +} + +display.call(); // sData value is Wisen +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function.prototype.call', 'Function.prototype.call')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.call")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Function.prototype.bind()")}}</li> + <li>{{jsxref("Function.prototype.apply()")}}</li> + <li><a href="/de/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Einführung in objektorientiertes JavaScript</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/caller/index.html b/files/de/web/javascript/reference/global_objects/function/caller/index.html new file mode 100644 index 0000000000..1b0b3f6c03 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/caller/index.html @@ -0,0 +1,84 @@ +--- +title: Function.caller +slug: Web/JavaScript/Reference/Global_Objects/Function/caller +tags: + - Function + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <code><strong><em>function</em>.caller</strong></code> Eigenschaft gibt die Funktion zurück, die eine spezifizierte Funktion aufgerufen hat. Diese Eigenschaft ist im Strict-Modus wegen <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-addrestrictedfunctionproperties">tail call Optimierungen</a> verboten.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn die Funktion <code>f</code> durch einen Quelltext auf höchster Ebene aufgerufen wird, ist der Wert von <code>f.caller</code> {{jsxref("null")}}, anderfalls die Funktion, die <code>f</code> aufgerufen hat.</p> + +<p>Diese Eigenschaft ersetzt die veraltete Eigenschaft {{jsxref("Functions/arguments/caller", "arguments.caller")}} des {{jsxref("Functions/arguments", "arguments")}} Objektes.</p> + +<p>Die spezielle Eigenschaft <code>__caller__</code>, <span class="short_text" id="result_box" lang="de"><span>welches das Objekt des Aufrufers zurück gab, erlaubt es den Stack zu rekonstruieren</span></span> und wurde aus Sicherheitsgründen entfernt.</p> + +<h3 id="Hinweise">Hinweise</h3> + +<p>Im Fall von Rekursion, kann der Stack nicht mit dieser Eigenschaft reproduziert werden. Gegeben:</p> + +<pre class="brush: js">function f(n) { g(n - 1); } +function g(n) { if (n > 0) { f(n); } else { stop(); } } +f(2); +</pre> + +<p>Im Moment, indem <code>stop()</code> aufgerufen wird, ist der Aufruferstack:</p> + +<pre class="brush: js">f(2) -> g(1) -> f(1) -> g(0) -> stop() +</pre> + +<p>Das folgende ergibt <code>true</code>:</p> + +<pre class="brush: js">stop.caller === g && f.caller === g && g.caller === f +</pre> + +<p>Wenn man versucht den Stacktrace in der <code>stop()</code> Funktion zu bekommen, wie hier:</p> + +<pre class="brush: js">var f = stop; +var stack = 'Stack trace:'; +while (f) { + stack += '\n' + f.name; + f = f.caller; +} +</pre> + +<p>wird die Schleife nie beendet.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Prüfen_des_Wertes_der_Funktionseigenschaft_caller">Prüfen des Wertes der Funktionseigenschaft <code>caller</code></h3> + +<p>Der folgende Quelltext prüft den Wert der Funktionseigenschaft <code>caller</code>.</p> + +<pre class="brush: js">function myFunc() { + if (myFunc.caller == null) { + return 'The function was called from the top!'; + } else { + return 'This function\'s caller was ' + myFunc.caller; + } +} +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>In keiner Spezifikation enthalten. Implementiert in JavaScript 1.5.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.caller")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>Implementation bug for SpiderMonkey {{bug(65683)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/displayname/index.html b/files/de/web/javascript/reference/global_objects/function/displayname/index.html new file mode 100644 index 0000000000..9e22b16fca --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/displayname/index.html @@ -0,0 +1,81 @@ +--- +title: Function.displayName +slug: Web/JavaScript/Reference/Global_Objects/Function/displayName +tags: + - Function + - JavaScript + - Non Standard + - Non-standard + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <code><strong><em>function</em>.displayName</strong></code> Eigenschaft gibt den sichtbaren Namen der Funktion zurück.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn definiert, gibt dit <code>displayName</code> Eigenschaft den sichtbaren Namen der Funktion zurück:</p> + +<pre class="brush: js">function doSomething() {} + +console.log(doSomething.displayName); // "undefined" + +var popup = function(content) { console.log(content); }; + +popup.displayName = 'Show Popup'; + +console.log(popup.displayName); // "Show Popup" +</pre> + +<p>Man kann eine Funktion mit sichtbaren Namen mit einem {{jsxref("Functions", "Funktionsausdruck", "", 1)}} definieren:</p> + +<pre class="brush: js">var object = { + someMethod: function() {} +}; + +object.someMethod.displayName = 'someMethod'; + +console.log(object.someMethod.displayName); // logs "someMethod" + +try { someMethod } catch(e) { console.log(e); } +// ReferenceError: someMethod is not defined +</pre> + +<p>Man kann den <code>displayName</code> einer Funktion dynamisch ändern:</p> + +<pre class="brush: js">var object = { + // anonymous + someMethod: function(value) { + arguments.callee.displayName = 'someMethod (' + value + ')'; + } +}; + +console.log(object.someMethod.displayName); // "undefined" + +object.someMethod('123') +console.log(object.someMethod.displayName); // "someMethod (123)" +</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Konsolen und Profiler präferieren die {{jsxref("Function.name", "func.name")}} zum anzeigen des Namens einer Funktion.</p> + +<p>Beim eingeben des Folgenden Quelltextes in der Konsole, wird etwas wie "<code>function My Function()</code>" ausgegeben:</p> + +<pre class="brush: js">var a = function() {}; +a.displayName = 'My Function'; + +a; // "function My Function()"</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>In keiner Spezifikation enthalten.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.displayName")}}</p> +</div> diff --git a/files/de/web/javascript/reference/global_objects/function/index.html b/files/de/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..dd2a7d5583 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,188 @@ +--- +title: Function +slug: Web/JavaScript/Reference/Global_Objects/Function +tags: + - Constructor + - Function + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +<div>{{JSRef}}</div> + +<p>Der <strong><code>Function</code> Konstruktor </strong>erstellt ein neues <code>Funktion</code> Objekt. Das direkte Aufrufen kann Funktionen dynamisch erstellen, hat aber Sicherheits- und Performanceprobleme genau wie der Einsatz von {{jsxref("eval")}}. Im Gegensatz zu <code>eval</code> ermöglicht der Function-Konstruktor die Ausführung von Code im globalen Gültigkeitsbereich, was zu besseren Programmiergewohnheiten führt und eine effizientere Code-Minimierung ermöglicht.</p> + +<div>{{EmbedInteractiveExample("pages/js/function-constructor.html")}}</div> + + + +<p>Jede JavaScript Funktion ist aktuell ein <code>Function</code> Objekt. Das kann mit dem Code <code>(function(){}).constructor === Function</code> gezeigt werden, der <code>true</code> zurückgibt.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Namen die von der Funktion als formelle Argumentname genutzt werden. Jeder davon muss ein String sein, welcher ein gültiger JavaScript Bezeichner ist oder einer Liste von solchen Strings, getrennt mit Kommata ist. Zum Beispiel: "<code>x</code>", "<code>derWert</code>", oder "<code>a,b</code>".</dd> + <dt><code>functionBody</code></dt> + <dd>Ein String, welcher den JavaScript Ausdruck als Funktions-Definition beinhaltet.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Mit dem <code>Function</code> Konstruktor erstellte <code>Function</code>-Objekte werden übersetzt, sobald die Funktion erstellt wurde. Das ist weniger effizient, als wenn man eine Funktion als <a href="/de/docs/Web/JavaScript/Reference/Operators/function">Funktionsausdruck</a> oder <a href="/de/docs/Web/JavaScript/Reference/Statements/function">Funktionsstatement</a> deklariert und diese innerhalb des Codes abruft, weil diese mit dem Rest des Codes übersetzt werden.</p> + +<p>Alle der Funktion übergegebenen Argumente werden als Namen der Bezeichner der Parameter in der zu erstellenden Funktion in der angegebenen Reihenfolge behandelt.</p> + +<p>Das Aufrufen des <code>Function</code> Konstruktors als Funktion (ohne den <code>new</code> Operator) hat dieselbe Wirkung, wie als Konstrukteuraufruf. Jedoch kann das Weglassen des <code>new</code> Operators eine kleinere minimierten Codegröße (4 Byte kleiner) erreichen, so dass es besser ist <code>Function</code> ohne <code>new</code> zu benutzen.</p> + +<h2 id="Eigenschaften_und_Methoden_von_Function">Eigenschaften und Methoden von <code>Function</code></h2> + +<p>Das globale <code>Function</code> Objekt hat eigene Methoden und Eigenschaften, doch, da es eine Funktion selbst ist, erbt es einige Methoden und Eigenschaften durch die Prototypkette aus {{jsxref("Function.prototype")}}.</p> + +<h2 id="Function_Prototyp_Objekt"><code>Function</code> Prototyp Objekt</h2> + +<h3 id="Eigenschaften">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methods" name="Methods">Methoden</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype', 'Methoden')}}</div> + +<h2 id="Function_instances" name="Function_instances"><code>Function</code> Instanzen</h2> + +<p>Funktions-Instanzen erben Methoden und Eigenschaften vom {{jsxref("Function.prototype")}}. Wie bei allen Konstruktoren kann das Prototypen Objekt verändern werden, um Änderungen an allen Funktions-Instanzen durchzuführen.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example.3A_Specifying_arguments_with_the_Function_constructor" name="Example.3A_Specifying_arguments_with_the_Function_constructor">Spezifizieren von Argumente mit dem <code>Function</code> Konstruktor</h3> + +<p>Der folgende Code erstellt ein Funktions-Objekt, mit zwei Argumenten.</p> + +<pre class="brush: js">// Das Beispiel kann direkt in der JavaScript Console ausgeführt werden. + +// Erstellt eine Funktion mit zwei Argumenten und gibt die Summe dieser Argumente zurück +var adder = new Function('a', 'b', 'return a + b'); + +// Aufruf der Funktion +adder(2, 6); +// > 8 +</pre> + +<p>Die Argumente "a" und "b" sind formale Argument-Namen, welche im Funktionskörper genutzt werden, "<code>return a + b</code>".</p> + +<h3 id="Unterschiede_zwischen_dem_Function_Konstruktor_und_Funktionsdeklarationen">Unterschiede zwischen dem <code>Function</code> Konstruktor und Funktionsdeklarationen</h3> + +<p>Funktionen, die mit dem <code>Function</code> Konstruktor erstellt werden, erstellen keine Closures in ihrem Erstellungskontext; Sie werden immer im globalen Scope erstellt. Wenn diese ausgeführt wird, kann sie nur auf eigene lokale oder globale Variablen zugreifen, jedoch nicht auf die aus dem Erstellungskontext des <code>Function</code> Konstruktor aufzufes. Dieses ist der Unterschied zum Einsatz von {{jsxref("eval")}} mit Quelltext für einen Funktionsausdruck.</p> + +<pre class="brush: js">var x = 10; + +function createFunction1() { + var x = 20; + return new Function('return x;'); // this |x| refers global |x| +} + +function createFunction2() { + var x = 20; + function f() { + return x; // this |x| refers local |x| above + } + return f; +} + +var f1 = createFunction1(); +console.log(f1()); // 10 +var f2 = createFunction2(); +console.log(f2()); // 20 +</pre> + +<p>Der "richtige" Weg für das Ausführen von externen Code mit <code>Function</code> (Für maximale Minimierung).</p> + +<pre class="brush: js">function makeFunction(code){ + return Funktion('"use strict";return ' + code)(); +} +var add = makeFunktion( + "" + function(a, b, c){ return a + b + c } // dieser Code ist in einer seperaten Datei irgendwo im Produktivprogramm +) +console.log( add(1, 2, 3) ); // gibt sechs aus +</pre> + +<p>Zu beachten ist, dass der obere Code komplett unpraktikabel ist. Man sollte <code>Function</code> niemals so missbrauchen. Stattdessen ist der obere Code nur als vereinfachtes Beispiel für eine Art Modulloader zu sehen, wobei es ein Basisskript gibt, welches dann hunderte von großen optionalen Modulen lädt. Dadurch muss ein Benutzer nicht lange warten, bis alle Module heruntergeladen sind, sondern der Clientcomputer lädt nur die benötigten Module und eine Seite lädt schneller. Dabei wird es beim auswerten von vielen Funktionen empfohlen, sie gebündelt zu übersetzen anstatt jede einzeln.</p> + +<pre class="brush: js">function bulkMakeFunctions(){ + var str = "", i = 1, Len = arguments.length; + if(Len) { + str = arguments[0]; + while (i !== Len) str += "," + arguments[i], ++i; + } + return Funktion('"use strict";return[' + str + ']')(); +} +const [ + add, + sub, + mul, + div +] = bulkMakeFunctions( + "function(a,b){return a+b}", + "function(a,b){return a-b}", + "function(a,b){return a*b}", + "function(a,b){return a/b}" +); +console.log(sub(add(mul(4, 3), div(225, 5)), 7)); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-objects', 'Function')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Functions", "Functions and function scope")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Statements/function*", "function* statement")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("AsyncFunction")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/isgenerator/index.html b/files/de/web/javascript/reference/global_objects/function/isgenerator/index.html new file mode 100644 index 0000000000..5897905e92 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/isgenerator/index.html @@ -0,0 +1,56 @@ +--- +title: Function.prototype.isGenerator() +slug: Web/JavaScript/Reference/Global_Objects/Function/isGenerator +tags: + - Function + - JavaScript + - Method + - Non-standard + - Obsolete +translation_of: Archive/Web/JavaScript/Function.isGenerator +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die nicht standardisierte <code><strong>isGenerator()</strong></code> Methode wird benutzt, um festzustellen, ob eine Funktion ein <a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">Generator</a> ist. In Firefox Version 58 wurde diese Methode entfernt.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>fun</var>.isGenerator()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Boolean")}} Welcher angibt, ob eine Funktion ein <a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">Generator</a> ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>isGenerator()</code> Methode stellt fest, ob eine Funktion <em><code>fun</code></em> ein <a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">Generator</a> ist. Diese war in einem frühen Vorschlag, wurde jedoch nicht in der ECMAScript 2015 Spezifikation eingefügt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">function f() {} + +function* g() { + yield 42; +} + +console.log('f.isGenerator() = ' + f.isGenerator()); // f.isGenerator() = false +console.log('g.isGenerator() = ' + g.isGenerator()); // g.isGenerator() = true +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Ist in keiner Spezifikation vorhanden. Implementiert in JavaScript 1.8.6.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.isGenerator")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iteratoren und Generatoren</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/length/index.html b/files/de/web/javascript/reference/global_objects/function/length/index.html new file mode 100644 index 0000000000..3eca57b92a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/length/index.html @@ -0,0 +1,92 @@ +--- +title: Function.length +slug: Web/JavaScript/Reference/Global_Objects/Function/length +tags: + - Function + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/length +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>length</strong></code> Eigenschaft gibt die Anzahl der von der Funktion erwarteten Parameter an.</p> + +<div>{{EmbedInteractiveExample("pages/js/function-length.html")}}</div> + + + +<div>{{js_property_attributes(0,0,1)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>length</code> ist eine Eigenschaft eines Funktionsobjekts und zeigt an, wie viele Argumente die Funktion erwartet, d.h. die Anzahl der formalen Parameter. Diese Anzahl beinhaltet jedoch nicht den {{jsxref("rest_parameters", "rest Parameter", "", 1)}} und bezieht außerdem auch nur die Parameter ein, die in der Reihenfolge vor dem ersten Parameter mit einem Default-Wert sind. Im Gegensatz dazu ist {{jsxref("Functions/arguments/length", "arguments.length")}} eine in jeder Funktion verfügbare lokale Variable, die die tatsächliche Anzahl der übergebenen Argumente angibt.</p> + +<h3 id="Dateneigenschaft_des_Function_Konstruktors">Dateneigenschaft des <code>Function</code> Konstruktors</h3> + +<p>Der {{jsxref("Global_Objects/Function", "Function")}} Konstruktor ist selbst ein {{jsxref("Global_Objects/Function", "Function")}} Objekt. Seine Eigenschaft <code>length</code> hat den Wert 1. Dessen Attribute lauten: Writable: <code>false</code>, Enumerable: <code>false</code>, Configurable: <code>true</code>.</p> + +<h3 id="Eigenschaft_des_Function_prototype_Objekt">Eigenschaft des <code>Function</code> prototype Objekt</h3> + +<p>Die length-Eigenschaft des {{jsxref("Global_Objects/Function", "Function")}} prototype Objekts hat den Wert 0.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<pre class="brush: js">console.log(Function.length); /* 1 */ + +console.log((function() {}).length); /* 0 */ +console.log((function(a) {}).length); /* 1 */ +console.log((function(a, b) {}).length); /* 2 etc. */ + +console.log((function(...args) {}).length); +// 0, rest parameter wird nicht gezählt + +console.log((function(a, b = 1, c) {}).length); +// 1, nur Parameter vor dem ersten Parameter mit +// einem Default-Wert werden gezählt +</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.3.5.1', 'Function.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Das <code>configurable</code> Attribut dieser Eigenschaft ist nun <code>true</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-instances-length', 'Function.length')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.length")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Global_Objects/Function", "Function")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/name/index.html b/files/de/web/javascript/reference/global_objects/function/name/index.html new file mode 100644 index 0000000000..29a3903d56 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/name/index.html @@ -0,0 +1,229 @@ +--- +title: Function.name +slug: Web/JavaScript/Reference/Global_Objects/Function/name +tags: + - ECMAScript 2015 + - Function + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/name +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">Die nur lesende Eigenschaft <code><strong>name</strong></code> eines {{jsxref("Function")}} Objektes welche den Namen, der beim erstellen angegeben wurde enthält oder <code>"anonymous"</code> für anonyme Funktionen.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/function-name.html")}}</div> + + + +<div>{{js_property_attributes(0,0,1)}}</div> + +<div> </div> + +<div class="note"> +<p>Zu beachten ist, dass in nicht standardisierten implementierungen vor ES2015 das <code>configurable</code> Attribute ebenfalls <code>false</code> ist.</p> +</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Name_bei_Funktionsanweisungen">Name bei Funktionsanweisungen</h3> + +<p>Die <code>name</code> Eigenschaft gibt den Namen einer Funktionsanweisung:</p> + +<pre class="brush: js">function doSomething() {} +doSomething.name; // logs "doSomething" +</pre> + +<h3 id="Name_bei_Function_Konstruktoren">Name bei <code>Function</code> Konstruktoren</h3> + +<p>Funktionen, die mit der Syntax <code>new Function(...)</code> oder nur <code>Function(...)</code> erstellt werden, erstellen {{jsxref("Function")}} mit dem Namen "anonymous".</p> + +<pre class="brush: js">(new Function).name; // "anonymous" +</pre> + +<h3 id="Gefolgerte_Funktionsnamen">Gefolgerte Funktionsnamen</h3> + +<p>Bei Variablen und Methoden kann der Name von anonymen Funktionen von ihrer syntaktischen Position gefolgert werden (neu in ECMAScript 2015).</p> + +<pre class="brush: js">var f = function() {}; +var object = { + someMethod: function() {} +}; + +console.log(f.name); // "f" +console.log(object.someMethod.name); // "someMethod" +</pre> + +<p>Funktionen mit einem Namen lassen sich mittels {{jsxref("Operators/Function", "Funktionanweisung", "", 1)}} definieren:</p> + +<pre class="brush: js">var object = { + someMethod: function object_someMethod() {} +}; +console.log(object.someMethod.name); // logs "object_someMethod" + +try { object_someMethod } catch(e) { console.log(e); } +// ReferenceError: object_someMethod is not defined +</pre> + +<p>Man kann den Namen einer Funktion nicht ändern, weil diese Eigenschaft schreibgeschützt ist:</p> + +<div class="hidden"> +<p>Example below contradicts with what is said at the beginning of this section and doesn't work as described.</p> +</div> + +<pre class="brush: js">var object = { + // anonyme Funktionsdefinition + someMethod: function() {} +}; + +object.someMethod.name = 'someMethod'; +console.log(object.someMethod.name); // leerer String, someMethod ist anonym +</pre> + +<p>Um sie zu ändern, kann {{jsxref("Object.defineProperty()")}} eingesetzt werden.</p> + +<h3 id="Kurzform_von_Methodennamen">Kurzform von Methodennamen</h3> + +<pre class="brush: js">var o = { + foo(){} +}; +o.foo.name; // "foo"; +</pre> + +<h3 id="Gebundene_Funktionsnamen">Gebundene Funktionsnamen</h3> + +<p>{{jsxref("Function.bind()")}} erzeugt eine Funktion mit dem Namen, der sich aus <code> "bound "</code> und dem Namen der Funktion zusammensetzt.</p> + +<pre class="brush: js">function foo() {}; +foo.bind({}).name; // "bound foo"</pre> + +<h3 class="brush: js" id="Funktionsnamen_für_Getter_und_Setter">Funktionsnamen für Getter und Setter</h3> + +<p>Beim Einsatz von <code><a href="/de/docs/Web/JavaScript/Reference/Functions/get">get</a></code> und <code><a href="/de/docs/Web/JavaScript/Reference/Functions/set">set</a></code> Zugriffseigenschaften wird "get" oder "set" im Funktionsnamen auftauchen.</p> + +<pre class="brush: js">var o = { + get foo(){}, + set foo(x){} +}; + +var descriptor = Object.getOwnPropertyDescriptor(o, "foo"); +descriptor.get.name; // "get foo" +descriptor.set.name; // "set foo" +</pre> + +<h3 id="Funktionsnamen_in_Klassen">Funktionsnamen in Klassen</h3> + +<p>Über <code>obj.constructor.name</code> lässt sich die "Klasse" eines Objekts überprüfen (jedoch sollten die unten stehende Warnung berücksichtigt werden):</p> + +<pre class="brush: js">function Foo() {} // ES2015 Syntax: class Foo {} + +var fooInstance = new Foo(); +console.log(fooInstance.constructor.name); // logs "Foo" +</pre> + +<div class="warning"> +<p><strong>Warnung:</strong> Der Skriptinterpreter wird die eingebaute <code>Function.name</code> Eigenschaft nur setzen, wenn eine Funktion keine eigene Eigenschaft mit dem Namen <em>name</em> hat (siehe Kapitel <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-setfunctionname">9.2.11 der ECMAScript2015 Sprachdefinition</a>). Jedoch spezifiziert ES2015 das <em>static</em> Schlüsselwort so, dass statische Methoden als eigene Eigenschaft des Klassenkonstruktorfunktion gesetzt wird (ECMAScript2015, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation">14.5.14.21.b</a> + <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer-runtime-semantics-propertydefinitionevaluation">12.2.6.9</a>).</p> +</div> + +<p>Aus diesem Grund kann der Klassenname für jede Klasse mit einer statischen Methodeneigenschaft <code>name()</code> nicht bestimmt werden:</p> + +<pre class="brush: js">class Foo { + constructor() {} + static name() {} +} +</pre> + +<p>Mit einer <code>static name()</code> Methode hält <code>Foo.name</code> nicht mehr den aktuellen Klassennamen bereit, sondern eine Referenz zu dem <code>name()</code> Funktionsobjekt. Die oben stehende Klassendefinition in ES2015 Syntax kann in ES5 Syntax für Chrome oder Firefox wie folgt übersetzt werden:</p> + +<pre class="brush: js">function Foo() {} +Object.defineProperty(Foo, 'name', { writable: true}); +Foo.name = function() {}; +</pre> + +<p>Beim Versuch die Klasse von <code>fooInstance</code> mithilfe von <code>fooInstance.constructor.name</code> herauszufinden, bekommt man nicht den Klassennamen, sondern eine Referenz auf die statische Methode. Beispiel:</p> + +<pre class="brush: js">var fooInstance = new Foo(); +console.log(fooInstance.constructor.name); // logs function name() +</pre> + +<p>Man sieht zudem in der Beispiel der ES5 Syntax für Chrome und Firefox, dass die Definition der statischen <code>Foo.name</code> Methode überschreibbar (<em>writable</em>) wird. Wird nicht angegeben, ist der Standard für solche Definition nur lesend (<em>read-only</em>).</p> + +<pre class="brush: js">Foo.name = 'Hello' +console.log(Foo.name); // logs "Hello" if class Foo has a static name() property but "Foo" if not. +</pre> + +<p>Aus diesem Grund darf man sich nicht darauf verlassen, dass <code>Function.name</code> immer den Klassennamen zurück gibt.</p> + +<h3 id="Symbols_als_Funktionsnamen">Symbols als Funktionsnamen</h3> + +<p>Wenn ein {{jsxref("Symbol")}} als Funktionsnamen genutzt wird und das Symbol eine Beschreibung (description) hat, ist der Methodennamen gleich der Beschreibung in eckigen Klammern.</p> + +<pre class="brush: js">var sym1 = Symbol("foo"); +var sym2 = Symbol(); +bar o = { + [sym1]: function(){}, + [sym2]: function(){} +}; + +o[sym1].name; // "[foo]" +o[sym2].name; // "" +</pre> + +<h2 id="JavaScript-Kompressoren_und_-Minimierer">JavaScript-Kompressoren und -Minimierer</h2> + +<div class="warning"> +<p><strong>Warnung:</strong> Beim der Benutzung von <code>Function.name</code> ist Vorsicht geboten, wenn Codetransformtionen, wie JavaScript Kompressoren (Minimierer) oder Obfuscators, zum Einsatz kommen. Diese Werkzeuge werden häufig im Zuge von Werkzeugketten zum Bauen von JavaScript-Programmen eingesetzt um die Größe eines Programms zu für den Produktivbetrieb zu minimieren. Solche Werkzeuge ändern die Funktionsnamen häufig beim Erstellen.</p> +</div> + +<p>Quelltext wie dieser:</p> + +<pre class="brush: js">function Foo() {}; +var foo = new Foo(); + +if (foo.constructor.name === 'Foo') { + console.log("'foo' is an instance of 'Foo'"); +} else { + console.log('Oops!'); +} +</pre> + +<p>wird manchmal zu folgendem Quelltext komprimiert:</p> + +<pre class="brush: js">function a() {}; +var b = new a(); +if (b.constructor.name === 'Foo') { + console.log("'foo' is an instance of 'Foo'"); +} else { + console.log('Oops!'); +} +</pre> + +<p>In der nicht komprimierten Version läuft das Programm in den true-Zweig und gibt <code><em>'foo' is an instance of 'Foo'</em></code> aus. Die komprimierte Version verhält sich anders und läuft in den else-Zweig. Wenn man sich <code>Function.name</code> zurückerinnert, wie in obigen Beispielen, muss beachtet werden, dass Kompressoren die Methodennamen nicht ändert oder nicht annimmt, dass eine Funktion nur in diesem Quelltext benutzt.</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('ES2015', '#sec-name', 'name')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-instances-name', 'name')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + +{{Compat("javascript.builtins.Function.name")}}</div> diff --git a/files/de/web/javascript/reference/global_objects/function/prototype/index.html b/files/de/web/javascript/reference/global_objects/function/prototype/index.html new file mode 100644 index 0000000000..afb602971c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/prototype/index.html @@ -0,0 +1,99 @@ +--- +title: Function.prototype +slug: Web/JavaScript/Reference/Global_Objects/Function/prototype +tags: + - Function + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Function.prototype</strong></code> Eigenschaft repräsentiert das {{jsxref("Function")}} Prototyp Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("Function")}} Objekte erben von <code>Function.prototype</code>. <code>Function.prototype</code> kann nicht modifiziert werden.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("Function.arguments")}} {{deprecated_inline}}</dt> + <dd>Ein Array, welches die der Funktion übergebenen Parameter enthält. Dieses ist veraltet als Eigenschaft von {{jsxref("Function")}}. Stattdessen sollte das {{jsxref("Functions/arguments", "arguments")}} Objekt in einer Funktion benutzt werden</dd> + <dt><s class="obsoleteElement">{{jsxref("Function.arity")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Wurde benutzt, um die Anzahl der erwarteten Argumente einer Funktion einzustellen, ist jedoch entfernt. Stattdessen kann die {{jsxref("Function.length", "length")}} Eigenschaft genutzt werden.</s></dd> + <dt>{{jsxref("Function.caller")}} {{non-standard_inline}}</dt> + <dd>Spezifizert die Funktion, die die aktuelle Funktion aufgerufen hat.</dd> + <dt>{{jsxref("Function.length")}}</dt> + <dd>Spezifizert die Anzahl der Parameter, die eine Funktion erwartet.</dd> + <dt>{{jsxref("Function.name")}}</dt> + <dd>Der Name einer Funktion.</dd> + <dt>{{jsxref("Function.displayName")}} {{non-standard_inline}}</dt> + <dd>Der angezeigte Name einer Funktion.</dd> + <dt><code>Function.prototype.constructor</code></dt> + <dd>Spezifiziert die Funktion, die ein Objekt Prototyp erstellt. Mehr Informationen bei {{jsxref("Object.prototype.constructor")}}.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Function.prototype.apply()")}}</dt> + <dd>Führt eine Funktion aus und setzt das <em>this</em> Objekt mit einem übergebenen wert. Parameter können in einem {{jsxref("Array")}} Objekt übergeben werden.</dd> + <dt>{{jsxref("Function.prototype.bind()")}}</dt> + <dd><span id="result_box" lang="de"><span>Erstellt eine neue Funktion, die beim Aufruf einen angegebenen Wert für <em>this</em> hat, wobei die Argumentfolge vor dem Aufruf der neuen Funktion fest steht.</span></span></dd> + <dt>{{jsxref("Function.prototype.call()")}}</dt> + <dd>Führt eine Funktion aus und setzt <em>this</em> auf einen übergebenen Wert. Parameter können übergeben werden.</dd> + <dt>{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}</dt> + <dd>Gibt <code>true</code> zurück, wenn die Funktion ein <a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators">Generator</a> ist, anderfalls <code>false</code>.</dd> + <dt>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Gibt eine Stringrepräsentation des Quelltextes einer Funktion zurück. Sie überschreibt die {{jsxref("Object.prototype.toSource")}} Methode.</dd> + <dt>{{jsxref("Function.prototype.toString()")}}</dt> + <dd>Gibt eine Stringrepräsentation des Quelltextes einer Funktion zurück. Sie überschreibt die {{jsxref("Object.prototype.toString")}} 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.3.5.2', 'Function.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.prototype")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Function")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/function/tosource/index.html b/files/de/web/javascript/reference/global_objects/function/tosource/index.html new file mode 100644 index 0000000000..75552bdc8c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/tosource/index.html @@ -0,0 +1,72 @@ +--- +title: Function.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Function/toSource +tags: + - Function + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <code><strong>toSource()</strong></code> Methode gibt eine Stringrepräsentation des Quelltextes des Objektes zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>function</var>.toSource(); +Function.toSource(); +</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Stringrepräsentation des Quelltextes des Objektes.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toSource</code> Methode gibt die folgenden Werte zurück:</p> + +<ul> + <li>Für das eingebaute {{jsxref("Function")}} Objekt gibt <code>toSource()</code> den folgenden String zurück, der angibt, dass der Quelltext nicht verfügbar ist: + + <pre class="brush: js">function Function() { + [native code] +} +</pre> + </li> + <li>Für Benutzerdefinierte Funktionen, gibt <code>toSource()</code> den JavaScript Quelltext zurück, welcher das Objekt als String definiert.</li> + <li> + <pre class="brush: js">// Zum Beispiel: +function hello() { + console.log("Hello, World!"); +} + +hello.toSource();</pre> + </li> + <li> + <pre class="brush: js">// Das Resultat +"function hello() { + console.log(\"Hello, World!\"); +}" +</pre> + </li> +</ul> + +<p>Die Methode wird normalerweise von JavaScript selbst aufgerufen und nicht explizit im Quelltext. Man kann <code>toSource</code> während des Debuggens aufrufen, um zu ermitteln, was ein Objekt enthält.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Ist in keinem Standard. Implementiert in JavaScript 1.3.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.toSource")}}</p> +</div> + +<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/function/tostring/index.html b/files/de/web/javascript/reference/global_objects/function/tostring/index.html new file mode 100644 index 0000000000..5b3978809e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/tostring/index.html @@ -0,0 +1,236 @@ +--- +title: Function.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Function/toString +tags: + - Function + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>toString()</strong></code> Methode gibt eine Stringrepräsentation des Quelltextes einer Funktion zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/function-tostring.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>function</var>.toString()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Stringrepräsentation des Quelltextes der Funktion.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das {{jsxref("Function")}} Objekt überschreibt die von {{jsxref("Object")}} geerbte Methode {{jsxref("Object.prototype.toString", "toString")}}; sie erbt nicht von {{jsxref("Object.prototype.toString")}}. Für benutzerdefinierte {{jsxref("Function")}} Objekte gibt die <code>toString</code> Methode einen String zurück, welcher den Quelltext, der die Funktion definiert, enthält.</p> + +<p>JavaScript ruft die <code>toString</code> Methode automatisch auf, wenn einen {{jsxref("Function")}} als Text repräsentiert werden muss, z. B. wenn eine Funktion mit einem String konkateniert wird.</p> + +<p>Die <code>toString()</code> Methode erzeugt eine {{jsxref("TypeError")}} Fehler("Function.prototype.toString called on incompatible object"), wenn das Objekt von <code>this</code> Objekt kein <code>Function</code> Objekt ist. Dieser wird auch bei einem {{jsxref("Proxy")}} Objekte erzeugt, zum Beispiel:</p> + +<pre class="brush: js example-bad">Function.prototype.toString.call('foo'); // TypeError + +var proxy = new Proxy(function() {}, {}); +Function.prototype.toString.call(proxy); // TypeError +</pre> + +<p>Wenn die <code>toString()</code> Methode auf eingebauten Objekten oder einer von <code>Function.prototype.bind</code> erstellten Methode aufgerufen wird, gibt <code>toString() </code><em>native function string</em> zurück, was wie folgt aussiet:</p> + +<pre class="brush: js">"function () {\n [native code]\n}" +</pre> + +<p>Wenn die <code>toString()</code> Methode auf einer Funktion aufgerufen wird, die mit dem <code>Function</code> Konstruktor erstellt wurde, gibt diese den Quelltext der syntetischen Funktionsdeklerations mit dem Namen "anonymous" zurück, welche die Parameter und den Funktionrumpf enthält.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Funktion</th> + <th scope="col">Ergebnis von Function.prototype.toString</th> + </tr> + </thead> + <tbody> + <tr> + <td> + <pre> +function f(){}</pre> + </td> + <td> + <pre> +"function f(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre> +class A { a(){} }</pre> + </td> + <td> + <pre> +"class A { a(){} }"</pre> + </td> + </tr> + <tr> + <td> + <pre> +function* g(){}</pre> + </td> + <td> + <pre> +"function* g(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre> +a => a</pre> + </td> + <td> + <pre> +"a => a"</pre> + </td> + </tr> + <tr> + <td> + <pre> +({ a(){} }.a)</pre> + </td> + <td> + <pre> +"a(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre> +({ *a(){} }.a)</pre> + </td> + <td> + <pre> +"*a(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre> +({ [0](){} }[0])</pre> + </td> + <td> + <pre> +"[0](){}"</pre> + </td> + </tr> + <tr> + <td> + <pre> +Object.getOwnPropertyDescriptor({ + get a(){} +}, "a").get</pre> + </td> + <td> + <pre> +"get a(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre> +Object.getOwnPropertyDescriptor({ + set a(x){} +}, "a").set</pre> + </td> + <td> + <pre> +"set a(x){}"</pre> + </td> + </tr> + <tr> + <td> + <pre> +Function.prototype.toString</pre> + </td> + <td> + <pre> +"function toString() { [native code] }"</pre> + </td> + </tr> + <tr> + <td> + <pre> +(function f(){}.bind(0))</pre> + </td> + <td> + <pre> +"function () { [native code] }"</pre> + </td> + </tr> + <tr> + <td> + <pre> +Function("a", "b")</pre> + </td> + <td> + <pre> +"function anonymous(a\n) {\nb\n}"</pre> + </td> + </tr> + </tbody> +</table> + +<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('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Spezifischere Anforderungen wurden an die Stringrepräsentation hinzugefügt.</td> + </tr> + <tr> + <td><a href="http://tc39.github.io/Function-prototype-toString-revision/">Function.prototype.toString revision</a></td> + <td>Draft</td> + <td>Standardisierung nativer Funktionsstrings am Zeilenende.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.toString")}}</p> +</div> + +<h2 id="Firefox_spezifische_Hinweise">Firefox spezifische Hinweise</h2> + +<ul> + <li>Seit Firefox 17, ist <code>Function.prototype.toString()</code> implementiert zum Speichern von Funktionsquelltexten. Der Decompiler wurde entfernt, so das der <code>indentation</code> Parameter nicht mehr gebraucht wird. Für mehr Details siehe {{bug("761723")}}.</li> + <li>Seit Firefox 38, erzeugt <code>Function.prototype.toString()</code> einen Fehler für {{jsxref("Proxy")}} Objekts ({{bug(1100936)}}).</li> +</ul> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/generator/index.html b/files/de/web/javascript/reference/global_objects/generator/index.html new file mode 100644 index 0000000000..af21ef18f8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/generator/index.html @@ -0,0 +1,137 @@ +--- +title: Generator +slug: Web/JavaScript/Reference/Global_Objects/Generator +tags: + - ECMAScript 2015 + - Generator + - JavaScript + - Legacy Generator + - Legacy Iterator + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Generator +--- +<div>{{JSRef}}</div> + +<p>Das <code><strong>Generator</strong></code> Objekt wird von der {{jsxref("Statements/function*", "Generator Function", "", 1)}} zurückgegeben und entspricht beidem, dem <a href="/de/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol">Iterable Protokoll</a> und dem <a href="/de/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol">Iterator Protokoll</a>.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); // "Generator { }"</pre> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Generator.prototype.next()")}}</dt> + <dd>Gibt einen Wert vom Generator zurück (ausgelöst durch {{jsxref("Operators/yield", "yield")}}).</dd> + <dt>{{jsxref("Generator.prototype.return()")}}</dt> + <dd>Gibt den gegebene Wert zurück und beendet den Generator.</dd> + <dt>{{jsxref("Generator.prototype.throw()")}}</dt> + <dd>Erzeugt einen Fehler im Generator (beendet auch den Generator, wenn der Fehler nicht im Generator abgefangen wird).</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ein_unendlicher_Iterator">Ein unendlicher Iterator</h3> + +<pre class="brush: js">function* idMaker() { + var index = 0; + while(true) + yield index++; +} + +var gen = idMaker(); // "Generator { }" + +console.log(gen.next().value); // 0 +console.log(gen.next().value); // 1 +console.log(gen.next().value); // 2 +// ...</pre> + +<h2 id="Veraltete_Generatorobjekte">Veraltete Generatorobjekte</h2> + +<p>Firefox (SpiderMonkey) hat eine frühe Version der Generatoren in <a href="/de/docs/Web/JavaScript/New_in_JavaScript/1.7">JavaScript 1.7</a> implementiert, bei der kein Stern (*) in der Funktionsdeklaration nötig war (man benutzte nur das <code>yield</code> Schlüsselwort im Funktionsrumpf). Seit Firefox 58 (Released am 23. Januar 2018) sind diese veralteten Generatoren entfernt ({{bug(1083482)}}).</p> + +<h3 id="Veraltete_Generator_Methoden">Veraltete Generator Methoden</h3> + +<dl> + <dt><code>Generator.prototype.next() </code>{{non-standard_inline}}</dt> + <dd>Gibt einen Wert vom {{jsxref("Operators/yield", "yield")}} Ausdruck zurück. Diese korrespondiert mit der <code>next()</code> Methode in ES2015 Generator Objekt.</dd> + <dt><code>Generator.prototype.close()</code> {{non-standard_inline}}</dt> + <dd>Beendet einen Generator, so dass der Aufruf von <code>next()</code> zu einem {{jsxref("StopIteration")}} Fehler führt. Diese korrespondiert mit der <code>return()</code> Methode in ES2015 Generator Objekt.</dd> + <dt><code>Generator.prototype.send()</code> {{non-standard_inline}}</dt> + <dd>Wird benutzt, um einen Wert zum Generator zu senden. Der wert wird vom {{jsxref("Operators/yield", "yield")}} Ausdruck zurückgegeben und gibt einen Wert vom nächsten {{jsxref("Operators/yield", "yield")}} Ausdruck zurück. Diese korrespondiert mit der <code>next(x)</code> Methode in ES2015 Generator Objekt.</dd> + <dt><strong><code>Generator.</code></strong><code>prototype.</code><strong><code>throw()</code> </strong> {{non-standard_inline}}</dt> + <dd>Erzeugt einen Fehler im Generator. Diese korrespondiert mit der <code>throw()</code> Methode in ES2015 Generator Objekt.</dd> +</dl> + +<h3 id="Veraltete_Generator_Beispiele">Veraltete Generator Beispiele</h3> + +<pre class="brush: js">function fibonacci() { + var a = yield 1; + yield a * 2; +} + +var it = fibonacci(); +console.log(it); // "Generator { }" +console.log(it.next()); // 1 +console.log(it.send(10)); // 20 +console.log(it.close()); // undefined +console.log(it.next()); // throws StopIteration (as the generator is now closed) +</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-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Generator")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<h3 id="Veraltete_Generatoren">Veraltete Generatoren</h3> + +<ul> + <li>{{jsxref("Statements/Legacy_generator_function", "Die veraltete Generator Function", "", 1)}}</li> + <li>{{jsxref("Operators/Legacy_generator_function", "Der veraltete Generator Functionsausdruck", "", 1)}}</li> + <li>{{jsxref("StopIteration")}}</li> + <li><a href="/de/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features/The_legacy_Iterator_protocol">The legacy Iterator protocol</a></li> +</ul> + +<h3 id="ES2015_Generatoren">ES2015 Generatoren</h3> + +<ul> + <li>{{jsxref("Functions", "Functions", "", 1)}}</li> + <li>{{jsxref("Statements/function", "function")}}</li> + <li>{{jsxref("Operators/function", "function Ausdruck")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function*", "function*")}}</li> + <li>{{jsxref("Operators/function*", "function* Ausdruck")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li><a href="/de/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/generator/next/index.html b/files/de/web/javascript/reference/global_objects/generator/next/index.html new file mode 100644 index 0000000000..44c45b77cf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/generator/next/index.html @@ -0,0 +1,116 @@ +--- +title: Generator.prototype.next() +slug: Web/JavaScript/Reference/Global_Objects/Generator/next +tags: + - ECMAScript 2015 + - Generator + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Generator/next +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>next</strong></code><strong><code>()</code></strong> Methode gibt ein Objekt mit den zwei Eigenschaften <code>done</code> und <code>value</code> zurück. Man kann der <code>next</code> Methode auch einen Wert für den Generator übergeben.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>gen</var>.next(value)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Der Wert der zum Generator übermittelt wird.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Ein <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Object">Objekt</a></code> mit zwei Eigenschaften:</p> + +<ul> + <li><code>done</code> (boolean) + + <ul> + <li>Hat den Wert <code>true</code>, wenn der Iterator am Ende der Sequenz angekommen ist. In diesem Fall ist <code>value</code>, der Rückgabewert des Iterators, optional spezifiziert.</li> + <li>Hat den Wert <code>false</code>, wenn der Iterator einen weiteren Wert aus der Sequenz produzieren kann. Das ist gleichbedeutend damit, dass die <code>done</code> Eigenschaft nicht spezifiziert ist.</li> + </ul> + </li> + <li><code>value</code> - Ein JavaScript Wert, der von einem Iterator zurückgegeben wird. Kann weggelassen werden, wenn <code>done</code> <code>true</code> ist.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_next">Einsatz von <code>next()</code></h3> + +<p>Das folgende Beispiel zeigt einen einfachen Generator und das Objekt, welches die <code>next</code> Methode zurück gibt:</p> + +<pre class="brush: js">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); // "Generator { }" +g.next(); // "Object { value: 1, done: false }" +g.next(); // "Object { value: 2, done: false }" +g.next(); // "Object { value: 3, done: false }" +g.next(); // "Object { value: undefined, done: true }" +</pre> + +<h3 id="Werte_zum_Generator_senden">Werte zum Generator senden</h3> + +<p>Im diesem Beispiel wird <code>next</code> mit einem Wert aufgerufen. Zu beachten ist, dass der Generator beim ersten aufruf nicht ausgibt, weil der Generator keinen initialen Wert generiert.</p> + +<pre class="brush: js">function* gen() { + while(true) { + var value = yield null; + console.log(value); + } +} + +var g = gen(); +g.next(1); +// "{ value: null, done: false }" +g.next(2); +// 2 +// "{ value: null, done: false }" +</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-generator.prototype.next', 'Generator.prototype.next')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator.prototype.next', 'Generator.prototype.next')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Generator.next")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/function*">function*</a></code></li> + <li><a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iteratoren and Generatoren</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/generator/return/index.html b/files/de/web/javascript/reference/global_objects/generator/return/index.html new file mode 100644 index 0000000000..897cd9b4f9 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/generator/return/index.html @@ -0,0 +1,102 @@ +--- +title: Generator.prototype.return() +slug: Web/JavaScript/Reference/Global_Objects/Generator/return +tags: + - ECMAScript 2015 + - Generator + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Generator/return +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>return()</strong></code> Gibt den gegebenen Wert und beendet den Generator</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>gen</var>.return(value)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Wert, der zurückgegeben werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der als Argument angegebene Wert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_return()">Einsatz von <code>return()</code></h3> + +<p>Das folgende Beispiel zeigt einen einfachen Generator und den Einsatz der <code>return</code> Methode.</p> + +<pre class="brush: js">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); + +g.next(); // { value: 1, done: false } +g.return('foo'); // { value: "foo", done: true } +g.next(); // { value: undefined, done: true } +</pre> + +<p>Wenn <code>return(value)</code> auf einem Generator aufgerufen wird, der schon den Status "completed" hat, bleibt diese auch in diesem Status. Wenn kein Argument übergeben wird, wird das selbe Objekt wir bei <code>.next()</code> zurückgegeben. Wenn ein Parameter übergeben wird, wird dieses als <code>value</code> Eigenschaft beim zurückgegebenen Objekt zurückgegeben.</p> + +<pre class="brush: js">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); +g.next(); // { value: 1, done: false } +g.next(); // { value: 2, done: false } +g.next(); // { value: 3, done: false } +g.next(); // { value: undefined, done: true } +g.return(); // { value: undefined, done: true } +g.return(1); // { value: 1, done: true } +</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-generator.prototype.return', 'Generator.prototype.return')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator.prototype.return', 'Generator.prototype.return')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Generator.return")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/function*">function*</a></code></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/generator/throw/index.html b/files/de/web/javascript/reference/global_objects/generator/throw/index.html new file mode 100644 index 0000000000..0879bd77d3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/generator/throw/index.html @@ -0,0 +1,101 @@ +--- +title: Generator.prototype.throw() +slug: Web/JavaScript/Reference/Global_Objects/Generator/throw +tags: + - ECMAScript 2015 + - Generator + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Generator/throw +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>throw()</strong></code> Methode übergibt dem Generator eine Exception, welche im Generator zu einem Fehler führt. Zudem wird ein Objekt mit den zwei Eigenschaften <code>done</code> und <code>value</code> zurückgegeben.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>gen</var>.throw(exception)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>exception</code></dt> + <dd>Die Exception, die geworfen werden soll. Für Debuggingzwecke ist es sinnvoll eine Instanz von {{jsxref("Error")}} zu verwenden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Object">Objekt</a></code> mit zwei Eigenschaften:</p> + +<ul> + <li><code>done</code> (boolean) + + <ul> + <li>Hat den Wert <code>true</code>, wenn der Iterator am Ende der Sequenz angekommen ist. In diesem Fall ist <code>value</code>, der Rückgabewert des Iterators, optional spezifiziert.</li> + <li>Hat den Wert <code>false</code>, wenn der Iterator einen weiteren Wert aus der Sequenz produzieren kann. Das ist gleichbedeutend damit, dass die <code>done</code> Eigenschaft nicht spezifiziert ist.</li> + </ul> + </li> + <li><code>value</code> - Ein JavaScript Wert, der von einem Iterator zurückgegeben wird. Kann weggelassen werden, wenn <code>done</code> <code>true</code> ist.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_throw()">Einsatz von <code>throw()</code></h3> + +<p>Das folgende Beispiel zeigt einen einfachen Generator und einen Fehler der mit der <code>throw</code> Methode erzeugt wird. Ein Fehler kann mit <code><a href="/de/docs/Web/JavaScript/Reference/Statements/try...catch">try...catch</a></code> abgefangen werden.</p> + +<pre class="brush: js">function* gen() { + while(true) { + try { + yield 42; + } catch(e) { + console.log('Error caught!'); + } + } +} + +var g = gen(); +g.next(); +// { value: 42, done: false } +g.throw(new Error('Something went wrong')); +// "Error caught!" +// { value: 42, done: false } +</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-generator.prototype.throw', 'Generator.prototype.throw')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator.prototype.throw', 'Generator.prototype.throw')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Generator.throw")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/function*">function*</a></code></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/generatorfunction/index.html b/files/de/web/javascript/reference/global_objects/generatorfunction/index.html new file mode 100644 index 0000000000..717774e10f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/generatorfunction/index.html @@ -0,0 +1,115 @@ +--- +title: GeneratorFunction +slug: Web/JavaScript/Reference/Global_Objects/GeneratorFunction +tags: + - Constructor + - ECMAScript 2015 + - GeneratorFunction + - Iterator + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/GeneratorFunction +--- +<div>{{JSRef}}</div> + +<p>Der <strong><code>GeneratorFunction</code> Konstruktor</strong> erstellt eine neues {{jsxref("Statements/function*", "Generator Funktion")}} Objekt. aktuell ist in JavaScript jede Generatorfunktion ein <code>GeneratorFunction</code> Objekt.</p> + +<p>Zu beachten ist, dass <code>GeneratorFunction</code> kein globales Objekt ist. Es kann mit folgendem Quelltext erhalten werden.</p> + +<pre class="brush: js">Object.getPrototypeOf(function*(){}).constructor +</pre> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new GeneratorFunction ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Namen für Formale Argumente der Funktion. Jeder muss ein String sein, der mit einem validen JavaScript-Bezeichner korrespondiert oder eine liste von solchen String, welche mit einem Komma getrennt sind; zum Beispiel "<code>x</code>", "<code>theValue</code>", oder "<code>a,b</code>"</dd> + <dt><code>functionBody</code></dt> + <dd>Ein String, welcher die Statements für die Funktionsdefinition enthält.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("Statements/function*", "Generator Funktion")}} Objekte, die mit dem <code>GeneratorFunction</code> Konstruktor erstellt werden übersetzt, wenn die Funktion erstellt wird. Das ist weniger effizient als die Erstellung mit einer {{jsxref("Statements/function*", "function* Ausdruck")}} und Aufrufe im Quelltext, weil solche Funktionen dem dem Rest des Quelltextes übersetzt werden.</p> + +<p>Alle Argumente, die der Funktion übergeben werden, werden als Namen der Bezeichner behandelt und werden als Parameter der Funktion übergen. Die Reihenfolge ist die angegebene Reihenfolge.</p> + +<div class="note"> +<p><strong>Hinweis:</strong> {{jsxref("Statements/function*", "Generator Function")}}, die mit dem <code>GeneratorFunction</code> Konstruktor erstellt werden erstellen keine Closures im Erstellungskontext. Sie werden immer im globalen Sichtbarkeitsbereich erstellt. Wenn diese ausgeführt werden, haben sie nur Zugriff auf eigene lokale Variablen und globale Variablen, jedoch nicht auf Variablen des Scopes, in der <code>GeneratorFunction</code> Konstruktor aufgerufen wird. Dieses unterscheidet diese Methode von {{jsxref("Global_Objects/eval", "eval")}} mit dem Quelltext einer Generatorfunktion.</p> +</div> + +<p>Das Aufrufen des <code>GeneratorFunction</code> Konstruktors als Funktion (ohne Einsatz des <code>new</code> Operator) hat den selben Effekt wie beim Aufruf als Konstruktor.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code><strong>GeneratorFunction.length</strong></code></dt> + <dd>Die Länge des <code>GeneratorFunction</code> Konstruktor Eigenschaft, welche 1 ist.</dd> + <dt>{{jsxref("GeneratorFunction.prototype")}}</dt> + <dd>Erlaubt das Hinzufügen von Eingenschaften für alle Generatorfunktionsobjekte.</dd> +</dl> + +<h2 id="GeneratorFunction_Prototyp_Objekt"><code>GeneratorFunction</code> Prototyp Objekt</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/GeneratorFunction/prototype', 'Eigenschaften')}}</div> + +<h2 id="GeneratorFunction_Instanzen"><code>GeneratorFunction</code> Instanzen</h2> + +<p><code>GeneratorFunction</code> Instanzen erben Methoden und Eigenschaften von {{jsxref("GeneratorFunction.prototype")}}. Wie bei allen Konstruktoren, kann man das Konstruktor Prototyp Objekt ändern, um diese für alle<code> GeneratorFunction</code> Instanzen zu übernehmen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Erstellen_einer_Generatorfunktion_mit_einem_GeneratorFunction_Konstruktor">Erstellen einer Generatorfunktion mit einem <code>GeneratorFunction</code> Konstruktor</h3> + +<pre class="brush: js">var GeneratorFunction = Object.getPrototypeOf(function*(){}).constructor +var g = new GeneratorFunction('a', 'yield a * 2'); +var iterator = g(10); +console.log(iterator.next().value); // 20 +</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-generatorfunction-objects', 'GeneratorFunction')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generatorfunction-objects', 'GeneratorFunction')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.GeneratorFunction")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Statements/function*", "function* function")}}</li> + <li>{{jsxref("Operators/function*", "function* Ausdruck")}}</li> + <li>{{jsxref("Global_Objects/Function", "Function")}}</li> + <li>{{jsxref("Statements/function", "function Statement")}}</li> + <li>{{jsxref("Operators/function", "function Ausdruck")}}</li> + <li>{{jsxref("Functions_and_function_scope", "Funktionen und Sichtbarkeiten", "", 1)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/generatorfunction/prototype/index.html b/files/de/web/javascript/reference/global_objects/generatorfunction/prototype/index.html new file mode 100644 index 0000000000..d4e895ed9c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/generatorfunction/prototype/index.html @@ -0,0 +1,66 @@ +--- +title: GeneratorFunction.prototype +slug: Web/JavaScript/Reference/Global_Objects/GeneratorFunction/prototype +tags: + - ECMAScript 2015 + - GeneratorFunction + - Iterator + - JavaScript + - Property + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/GeneratorFunction +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>GeneratorFunction.prototype</strong></code> Eigenschaft repräsentiert den Prototypen des {{jsxref("GeneratorFunction")}} Objektes.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("GeneratorFunction")}} Objekt erbt von <code>GeneratorFunction.prototype</code>. <code>GeneratorFunction.prototype</code> kann nicht verändert werden.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code><strong>GeneratorFunction.constructor</strong></code></dt> + <dd>Der initiale Wert von {{jsxref("GeneratorFunction")}}.</dd> + <dt><code><strong>GeneratorFunction.prototype.prototype</strong></code></dt> + <dd>Der Wert ist <code>%GeneratorPrototype%</code>.</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('ES2015', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.GeneratorFunction.prototype")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("GeneratorFunction")}}</li> + <li>{{jsxref("Function")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/globalthis/index.html b/files/de/web/javascript/reference/global_objects/globalthis/index.html new file mode 100644 index 0000000000..00e814c877 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/globalthis/index.html @@ -0,0 +1,96 @@ +--- +title: globalThis +slug: Web/JavaScript/Reference/Global_Objects/globalThis +tags: + - JavaScript + - Property + - Reference + - global + - globalThis + - this +translation_of: Web/JavaScript/Reference/Global_Objects/globalThis +--- +<div>{{jsSidebar("Objects")}}</div> + +<p><span class="tlid-translation translation" lang="de"><span title="">Die Eigenschaft </span></span><span class="seoSummary"><code><strong>globalThis</strong></code></span><span class="tlid-translation translation" lang="de"><span title=""> gibt das globale Objekt der obersten Ebene zurück.</span></span></p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-globalthis.html","shorter")}}</div> + + + +<p>{{JS_Property_Attributes(1, 0, 1)}}</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span class="tlid-translation translation" lang="de">In der Vergangenheit war für den Zugriff auf das globale Objekt in verschiedenen JavaScript-Umgebungen eine unterschiedliche Syntax erforderlich. Im Web kann man {{domxref("Window.window", "window")}}, {{domxref("Window.self", "self")}} oder {{domxref("Window.frames", "frames")}} verwenden - aber in </span><a href="/en-US/docs/Web/API/Worker">Web Workers</a><span class="tlid-translation translation" lang="de"> funktioniert nur <code>self</code>. In Node.js funktioniert keines der aufgezählten, und es muss stattdessen <code>global</code> verwendet werden.</span></p> + +<p><span class="tlid-translation translation" lang="de">Das Schlüsselwort <code>this</code> kann in Funktionen verwendet werden, die nicht im Strict-Mode ausgeführt werden, ist jedoch in Modulen und in Funktionen, die im Strict-Mode ausgeführt werden, <code>undefined</code>. Es kann <code>Function('return this')()</code> verwendet werden, aber Umgebungen, die {{jsxref("eval", "eval()")}} deaktiviert haben, wie etwa durch {{Glossary("CSP")}} in Browsern, verhindern die Verwendung von {{jsxref("Function")}} auf diese Weise.<br> + <br> + Die Eigenschaft <code>globalThis</code> bietet eine Standardmethode für den Zugriff auf den globalen Wert <code>this</code> (und damit auf das globale Objekt selbst) in verschiedenen Umgebungen. Im Gegensatz zu ähnlichen Eigenschaften wie <code>window</code> und <code>self</code> funktioniert es garantiert in Fenster- und Nicht-Fenster-Kontexten. Auf diese Weise können Sie auf konsistente Weise auf das globale Objekt zugreifen, ohne wissen zu müssen, in welcher Umgebung der Code ausgeführt wird. Um sich den Namen zu merken, denken Sie daran, dass <code>this</code> im globalen Bereich <code>globalThis</code> ist.</span></p> + +<h3 id="HTML_und_WindowProxy">HTML und WindowProxy</h3> + +<p><span class="tlid-translation translation" lang="de"><span title="">In vielen Engines ist <code>globalThis</code> ein Verweis auf das tatsächliche globale Objekt. In Webbrowsern wird jedoch aus Gründen der iframe- und fensterübergreifenden Sicherheit ein {{jsxref("Proxy")}} um das tatsächliche globale Objekt (das nicht direkt verwendet werden kann</span><span title="">).</span> <span title="">Diese Unterscheidung ist im allgemeinen Sprachgebrauch selten relevant, aber wichtig zu beachten.</span></span></p> + +<h3 id="Benennung">Benennung</h3> + +<p>Mehrere andere populäre Namen wie <code>self</code> und <code>global</code> wurden aus dem Vorschlag entfernt, da sie die Kompatibilität mit existierendem Code potenziell brechen könnten. Siehe das Dokument <a href="https://github.com/tc39/proposal-global/blob/master/NAMING.md">"Naming Constraints"</a> für weitere Details.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Umgebungsübergreifend_den_globalen_Kontext_finden">Umgebungsübergreifend den globalen Kontext finden</h3> + +<p><span class="tlid-translation translation" lang="de"><span title="">Vor <code>globalThis</code> war <code>Function('return this')()</code> die einzige zuverlässige, plattformübergreifende Methode, um das globale Objekt für eine Umgebung abzurufen.</span> <span title="">Dies führt jedoch in einigen Einstellungen zu </span></span> <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTTP/CSP">CSP </a><span class="tlid-translation translation" lang="de"><span title="">Verstößen. Daher verwendet </span></span> <a href="https://github.com/paulmillr/es6-shim">es6-shim</a><span class="tlid-translation translation" lang="de"><span title=""> eine Prüfung wie diese:</span></span></p> + +<pre class="brush: js notranslate">var getGlobal = function () { + if (typeof self !== 'undefined') { return self; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + throw new Error('unable to locate global object'); +}; + +var globals = getGlobal(); + +if (typeof globals.setTimeout !== 'function') { + // no setTimeout in this environment! +} +</pre> + +<p>Mit der Verfügbarkeit von <code>globalThis</code>, ist die zusätzliche umgebungsübergreifende Suche nach dem Global Kontext nicht mehr notwendig:</p> + +<pre class="brush: js notranslate">if (typeof globalThis.setTimeout !== 'function') { + // no setTimeout in this environment! +}</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName("ESDraft", "#sec-globalthis", "globalThis")}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.globalThis")}}</p> + +<h3 id="Implementierungsfortschritt"><span class="tlid-translation translation" lang="de"><span title="">Implementierungsfortschritt</span></span></h3> + +<p><span class="tlid-translation translation" lang="de"><span title="">Die folgende Tabelle enthält einen täglichen Implementierungsstatus für dieses Feature, da sie noch keine browserübergreifende Standardisierung erreicht hat.</span> <span title="">Die Daten werden generiert, indem die relevanten Funktionstests in </span></span><a href="https://github.com/tc39/test262">Test262</a><span class="tlid-translation translation" lang="de"><span title="">, der Standard-Testsuite von JavaScript, im nächtlichen Build oder in der neuesten Version der JavaScript-Engine jedes Browsers ausgeführt werden.</span></span></p> + +<div>{{EmbedTest262ReportResultsTable("globalThis")}}</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("this")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/index.html b/files/de/web/javascript/reference/global_objects/index.html new file mode 100644 index 0000000000..e7f9d05f3a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/index.html @@ -0,0 +1,191 @@ +--- +title: Globale Objekte +slug: Web/JavaScript/Reference/Global_Objects +tags: + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Dieses Kapitel dokumentiert alle Objekte, die standardmäßig in einer JavaScript-Umgebung zur Verfügung stehen.</p> + +<p>Der Ausdruck "Globales Objekt" (oder Standardobjekt) ist nicht zu verwechseln mit dem <strong>global object</strong>. Hier sind globale Objekte Objekte, die zu <strong>Objekten im globalen Zugriffsbereich (scope) referenzieren</strong>. Das <strong>global object</strong> selbst wird mit Hilfe des {{jsxref("Operators/this", "this")}}-Operators im globalen Bereich angesprochen (sofern der Strict-Modus von ECMAScript 5 nicht verwendet wird, andernfalls sind sie <code>undefined</code>). Tatsächlich <em>besteht </em>der globale Bereich aus den Eigenschaften (properties) des <em>global object</em> (einschließlich geerbter Eigenschaften, falls vorhanden).</p> + +<p>Andere Objekte im globalen Bereich wurden entweder <a href="/de/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">vom Benutzerscript erstellt</a> oder von der ausführenden Anwendung (meist der Browser) bereitgestellt. Die Anwendungsobjekte, welche im Browserumfeld (DOM) verfügbar sind, werden in der <a href="/de/docs/Web/API/Reference">API-Referenz </a>dokumentiert. Eine detailiertere Unterscheidung zwischen <a href="/de/docs/DOM/DOM_Reference">DOM-</a> und <a href="/de/docs/Web/JavaScript">Kern-JavaScript</a> befindet sich im Kapitel <a href="/de/docs/Web/JavaScript/JavaScript_technologies_overview">Überblick JavaScript-Technologien</a>.</p> + +<h2 id="Standardobjekte_(kategorisiert)">Standardobjekte (kategorisiert)</h2> + +<h3 id="Eigenschaften">Eigenschaften</h3> + +<p>Diese globalen Eigenschaften stellen einen einfachen Wert dar; sie haben keine weiteren Eigenschaften oder Methoden.</p> + +<ul> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("NaN")}}</li> + <li>{{jsxref("undefined")}}</li> + <li>{{jsxref("null")}} literal</li> +</ul> + +<h3 id="Funktionen">Funktionen</h3> + +<p>Diese globalen Funktionen werden als solche aufgerufen, nicht als Teil eines Objektes.</p> + +<ul> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> + <li>{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline()}}</li> + <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> + <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li> + <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> + <li>{{jsxref("Global_Objects/decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent()")}}</li> + <li>{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}</li> + <li>{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline()}}</li> + <li>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline()}}</li> +</ul> + +<h3 id="Fundamentale_Objekte">Fundamentale Objekte</h3> + +<p>Auf nachfolgenden Objekte basieren alle anderen, in JavaScript verfügbaren Objekte. Sie repräsentieren sowohl Objekte, als auch Funktionen und Fehler.</p> + +<ul> + <li>{{jsxref("Object")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Boolean")}}</li> + <li>{{jsxref("Symbol")}}</li> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("EvalError")}}</li> + <li>{{jsxref("InternalError")}}</li> + <li>{{jsxref("RangeError")}}</li> + <li>{{jsxref("ReferenceError")}}</li> + <li>{{jsxref("SyntaxError")}}</li> + <li>{{jsxref("TypeError")}}</li> + <li>{{jsxref("URIError")}}</li> +</ul> + +<h3 id="Zahlen_und_Zeiten">Zahlen und Zeiten</h3> + +<p>Objekte, die sich mit Zahlen und Zeit-Daten, sowie mathematischen Berechnungen befassen.</p> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("Math")}}</li> + <li>{{jsxref("Date")}}</li> +</ul> + +<h3 id="Textverarbeitung">Textverarbeitung</h3> + +<p>Objekte zum Verarbeiten von Text.</p> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("RegExp")}}</li> +</ul> + +<h3 id="Indexgebundene_Kollektionen">Indexgebundene Kollektionen</h3> + +<p>Diese Objekte umfassen Sammlungen von anderen Objekten, auf die über einen fortlaufenden, nummerischen Index zugegriffen werden kann. Zu ihnen gehören Arrays (Felder) und Array-ähnliche Objekte.</p> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Int8Array")}}</li> + <li>{{jsxref("Uint8Array")}}</li> + <li>{{jsxref("Uint8ClampedArray")}}</li> + <li>{{jsxref("Int16Array")}}</li> + <li>{{jsxref("Uint16Array")}}</li> + <li>{{jsxref("Int32Array")}}</li> + <li>{{jsxref("Uint32Array")}}</li> + <li>{{jsxref("Float32Array")}}</li> + <li>{{jsxref("Float64Array")}}</li> +</ul> + +<h3 id="Schlüsselgebundene_Kollektionen">Schlüsselgebundene Kollektionen</h3> + +<p>Diese Objekte umfassen Sammlungen von anderen Objekten, auf die über einen wahlfreien Schlüssel zugegriffen werden kann; sie lassen sich zudem nach Einfügereihenfolge durchlaufen.</p> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> + +<h3 id="Vector_Kollektionen">Vector Kollektionen</h3> + +<p>{{Glossary("SIMD")}} Vector Datentypen sind Objekte in denen die Daten in Bahnen angeordnet sind.</p> + +<ul> + <li>{{jsxref("SIMD")}} {{experimental_inline}}</li> + <li>{{jsxref("Float32x4", "SIMD.Float32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Float64x2", "SIMD.Float64x2")}} {{experimental_inline}}</li> + <li>{{jsxref("Int8x16", "SIMD.Int8x16")}} {{experimental_inline}}</li> + <li>{{jsxref("Int16x8", "SIMD.Int16x8")}} {{experimental_inline}}</li> + <li>{{jsxref("Int32x4", "SIMD.Int32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Uint8x16", "SIMD.Uint8x16")}} {{experimental_inline}}</li> + <li>{{jsxref("Uint16x8", "SIMD.Uint16x8")}} {{experimental_inline}}</li> + <li>{{jsxref("Uint32x4", "SIMD.Uint32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool8x16", "SIMD.Bool8x16")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool16x8", "SIMD.Bool16x8")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool32x4", "SIMD.Bool32x4")}} {{experimental_inline}}</li> + <li>{{jsxref("Bool64x2", "SIMD.Bool64x2")}} {{experimental_inline}}</li> +</ul> + +<h3 id="Strukturierte_Daten">Strukturierte Daten</h3> + +<p>Datenpuffer und <strong>J</strong>ava<strong>S</strong>cript-<strong>O</strong>bjekt-<strong>N</strong>otation.</p> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}} {{experimental_inline}}</li> + <li>{{jsxref("Atomics")}} {{experimental_inline}}</li> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("JSON")}}</li> +</ul> + +<h3 id="Kontrollabstraktions_Objekte">Kontrollabstraktions Objekte</h3> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Generator")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li>{{experimental_inline}} {{jsxref("AsyncFunction")}}</li> +</ul> + +<h3 id="Reflection">Reflection</h3> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Proxy")}}</li> +</ul> + +<h3 id="Internationalisierung">Internationalisierung</h3> + +<p>Ergänzungen zum ECMAScript-Kern für Aufgaben, die verschiedene Sprachen unterstützen sollen.</p> + +<ul> + <li>{{jsxref("Intl")}}</li> + <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</li> +</ul> + +<h3 id="WebAssembly">WebAssembly</h3> + +<ul> + <li>{{jsxref("WebAssembly")}}</li> + <li>{{jsxref("WebAssembly.Module")}}</li> + <li>{{jsxref("WebAssembly.Instance")}}</li> + <li>{{jsxref("WebAssembly.Memory")}}</li> + <li>{{jsxref("WebAssembly.Table")}}</li> + <li>{{jsxref("WebAssembly.CompileError")}}</li> + <li>{{jsxref("WebAssembly.LinkError")}}</li> + <li>{{jsxref("WebAssembly.RuntimeError")}}</li> +</ul> + +<h3 id="Sonstiges">Sonstiges</h3> + +<ul> + <li>{{jsxref("Functions/arguments", "arguments")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/infinity/index.html b/files/de/web/javascript/reference/global_objects/infinity/index.html new file mode 100644 index 0000000000..f862732ec2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/infinity/index.html @@ -0,0 +1,83 @@ +--- +title: Infinity +slug: Web/JavaScript/Reference/Global_Objects/Infinity +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Infinity +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die globale <span class="dpf_sent" id="dpfsent_1">Eigenschaft </span><strong><code>Infinity</code></strong> ist ein <span class="dpf_sent" id="dpfsent_1">numerischer </span>Wert, der die Unendlichkeit repräsentiert.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-infinity.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Infinity </code></pre> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>Infinity</code> ist eine Eigenschaft des <em>globalen Objekts</em>, was bedeutet, dass es eine Variable im globalen Gültigkeitsbereich ist.</p> + +<p>Der initiale Wert von <code>Infinity</code> entspricht {{jsxref("Number.POSITIVE_INFINITY")}}. Der Wert von <code>Infinity</code> (positiv unendlich) ist größer als alle anderen Nummern. Mathematisch entspricht der Wert der Unendlichkeit. Zum Beispiel ist das Produkt einer positiven Zahl mit <code>Infinity</code> immer <code>Infinity</code>. Jede Division einer Zahl durch <code>Infinity</code> ergibt 0.</p> + +<p>In der ECMAScript 5 Spezifikation wurde <code>Infinity</code> als read only Eigenschaft (nur lesender Zugriff) eingestuft. (Dieses wurde in JavaScript 1.8.5 / Firefox 4 implementiert.)</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">console.log(Infinity); /* Infinity */ +console.log(Infinity + 1); /* Infinity */ +console.log(Math.pow(10, 1000)); /* Infinity */ +console.log(Math.log(0)); /* -Infinity */ +console.log(1 / Infinity); /* 0 */ +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.3</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.1.2', 'Infinity')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Infinity")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/int16array/index.html b/files/de/web/javascript/reference/global_objects/int16array/index.html new file mode 100644 index 0000000000..4d2ff2cdab --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/int16array/index.html @@ -0,0 +1,204 @@ +--- +title: Int16Array +slug: Web/JavaScript/Reference/Global_Objects/Int16Array +tags: + - Constructor + - JavaScript + - TypedArray + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/Int16Array +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Int16Array</code></strong> getypte Array repräsentiert ein Array von zweierkomplement 16 Bit vorzeichenbehafteten, ganze Zahlen in der Plattform-Byte-Reihenfolge. Wenn Kontrolle über die Byte-Reihenfolge erforderlich ist, muss {{jsxref("DataView")}} stattdessen benutz werden. Die Inhalte werden mit <code>0</code> initialisiert. Wie erwartet, kann man Element in einem Array mit Objektmethoden referenzieren oder man benutzt die normale Arrayindex-Syntax (das ist die Klammernotation).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new Int16Array(); // new in ES2017 +new Int16Array(length); +new Int16Array(typedArray); +new Int16Array(object); +new Int16Array(buffer [, byteOffset [, length]]);</pre> + +<p>Für mehr Informationen über die Konstruktorensyntax und die Parameter, siehe auf der Seite <em><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int16Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Gibt die Größe der Elemente zurück. <code>2</code> im Falle eines <code>Int16Array</code>.</dd> + <dt>Int16Array.length</dt> + <dd>Statische Längeneigenschaft welche den Wert 0 hat. Für die aktuelle Länge (Anzahl der Elemente) siehe {{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}}.</dd> + <dt>{{jsxref("TypedArray.name", "Int16Array.name")}}</dt> + <dd>Gibt den Stringwert des Konstruktornamens zurück. In Fall eines <code>Int16Array</code> Typs: <code>"Int16Array"</code>.</dd> + <dt>{{jsxref("TypedArray.prototype", "Int16Array.prototype")}}</dt> + <dd>Prototyp für das <em>TypedArray</em> Objekt.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Int16Array.from()")}}</dt> + <dd>Erstelle ein neues <code>Int16Array</code> von einem Array-Ähnlichen oder Iterable Objekt. Siehe auch {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Int16Array.of()")}}</dt> + <dd>Erstellt ein neues <code>Int16Array</code> mit einer variablen Anzahl an Argumenten. Sie auch {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Int16Array_Prototyp"><code>Int16Array</code> Prototyp</h2> + +<p>Alle <code>Int16Array</code> Objekte erben von {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<dl> + <dt><code>Int16Array.prototype.constructor</code></dt> + <dd>Gibt die Funktion, die einen Instanzprototyp erstellt zurück. Diese ist auf den <code>Int16Array</code> Konstruktor voreingestellt.</dd> + <dt>{{jsxref("TypedArray.prototype.buffer", "Int16Array.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Gibt die {{jsxref("ArrayBuffer")}} Referenz zurück, welche nach der Erstellung eines <code>Int16Array</code> fest ist und nicht mehr geändert werden kann.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Int16Array.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Gibt die Länge (in Bytes) des <code>Int16Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Int16Array.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Gibt das Offset (in Bytes) des <code>Int16Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}} {{readonlyInline}}</dt> + <dd>Gibt Anzahl der Elemente des <code>Int16Array</code> zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> +</dl> + +<h3 id="Methoden_2">Methoden</h3> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}</dt> + <dd>Kopiert eine Sequenz von Arrayelementen in das Array. Siehe auch {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Int16Array.prototype.entries()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Schlüssel/Wertepaare für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Int16Array.prototype.every()")}}</dt> + <dd>Teste, ob alle Elemente einem, als Funktion übergebenen, Test erfüllen. Siehe auch Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Int16Array.prototype.fill()")}}</dt> + <dd>Füllt alle Elemente eines Arrays vom Startindex bis zum Endindex mit einem statischen Wert. Siehe auch {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Int16Array.prototype.filter()")}}</dt> + <dd>Erstellt ein neues Array mit allen Elementen des alten Arrays, für die eine übergebene Filterfunktion <code>true</code> zurückgibt. Siehe auch {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Int16Array.prototype.find()")}}</dt> + <dd>Gibt ein gefundenes Element des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>undefined</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Int16Array.prototype.findIndex()")}}</dt> + <dd>Gibt den Index eines gefundenen Elements des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Int16Array.prototype.forEach()")}}</dt> + <dd>Ruft für jedes Element in einem Array eine Funktion auf. Siehe auch {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Int16Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Überprüft, ob ein getyptes Array ein bestimmtes Element enthält und gibt gegebenfalls <code>true</code> oder<code>false</code> zurück. Siehe auch {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Int16Array.prototype.indexOf()")}}</dt> + <dd>Gibt den ersten Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Int16Array.prototype.join()")}}</dt> + <dd>Führt alle Elemente eines Arrays zu einem String zusammen. Siehe auch {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Int16Array.prototype.keys()")}}</dt> + <dd>Gibt ein neuen <code>Array Iterator</code> zurück, der alle Schlüssel für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Int16Array.prototype.lastIndexOf()")}}</dt> + <dd>Gibt den letzen Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Int16Array.prototype.map()")}}</dt> + <dd>Erstellt ein neues Array mit den Resultaten spezifizierten Funktion, die für jedes Element aufgerufen wird. Siehe auch {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.move", "Int16Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt> + <dd>Ehemalige nicht Standardisierte Version von {{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Int16Array.prototype.reduce()")}}</dt> + <dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von links nach rechts), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Int16Array.prototype.reduceRight()")}}</dt> + <dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von rechts nach links), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Int16Array.prototype.reverse()")}}</dt> + <dd>Kehrt die Reihenfolge von jedem Element eines Arrays um — das Erste wird das Letzte und das Letzte wird das Erste. Siehe auch {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Int16Array.prototype.set()")}}</dt> + <dd>Speichert mehrere Werte in einem getypten Array und ließt Eingabewerte aus einem spezifiziertem Array.</dd> + <dt>{{jsxref("TypedArray.slice", "Int16Array.prototype.slice()")}}</dt> + <dd>Extrahiert einen Bereich aus einem Array und gibt diesen in einem neuen Array zurück. Siehe auch {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Int16Array.prototype.some()")}}</dt> + <dd>Gibt <code>true</code> zurück, wenn nur ein Element in einem Array den als Funktion übergebenen Test erfüllt. Siehe auch {{jsxref("Array.prototype.some()")}}</dd> + <dt>{{jsxref("TypedArray.sort", "Int16Array.prototype.sort()")}}</dt> + <dd>Sortiert die Elemente eines Arrays in-Place und gibt das Array zurück. Siehe auch {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Int16Array.prototype.subarray()")}}</dt> + <dd>Gibt ein neues <code>Int16Array</code> vom gegebenen Start- und Endindex zurück.</dd> + <dt>{{jsxref("TypedArray.values", "Int16Array.prototype.values()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Werte von jedem Index im Array enthält. Siehe auch {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Int16Array.prototype.toLocaleString()")}}</dt> + <dd>Gibt einen Ortsabhängige Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Int16Array.prototype.toString()")}}</dt> + <dd>Gibt einen Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Int16Array.prototype[@@iterator]()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die zugehörigen Werte für jeden Index im Array enthalten.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Verschiedene Wege, um ein <code>Int16Array</code> zu erstellen:</p> + +<pre class="brush: js">// From a length +var int16 = new Int16Array(2); +int16[0] = 42; +console.log(int16[0]); // 42 +console.log(int16.length); // 2 +console.log(int16.BYTES_PER_ELEMENT); // 2 + +// From an array +var arr = new Int16Array([21,31]); +console.log(arr[1]); // 31 + +// From another TypedArray +var x = new Int16Array([21, 31]); +var y = new Int16Array(x); +console.log(y[0]); // 21 + +// From an ArrayBuffer +var buffer = new ArrayBuffer(8); +var z = new Int16Array(buffer, 0, 4); + +// From an iterable +var iterable = function*(){ yield* [1,2,3]; }(); +var int16 = new Int16Array(iterable); +// Int16Array[1, 2, 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt in ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA Standard. Spezifiziert, dass ein <code>new</code> benötigt wird.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>ECMAScript 2017 ändert den <code>Int16Array</code> Konstruktor, um die <code>ToIndex</code> Operation zu benutzen und erlaubt einen Konstruktor ohne Parameter.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Int16Array")}}</p> + +<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2> + +<p>Mit Beginn von ECMAScript 2015, müssen <code>Int16Array</code> Konstruktoren mit einem {{jsxref("Operators/new", "new")}} benutzt werden. Der Aufruf eines <code>Int16Array</code> Konstruktors als eine Funktion ohne <code>new</code>, Führt jetzt zu einem {{jsxref("TypeError")}}.</p> + +<pre class="brush: js example-bad">var dv = Int16Array([1, 2, 3]); +// TypeError: calling a builtin Int16Array constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new Int16Array([1, 2, 3]);</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript getypte Arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/int32array/index.html b/files/de/web/javascript/reference/global_objects/int32array/index.html new file mode 100644 index 0000000000..ed2da2bcdc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/int32array/index.html @@ -0,0 +1,204 @@ +--- +title: Int32Array +slug: Web/JavaScript/Reference/Global_Objects/Int32Array +tags: + - Constructor + - JavaScript + - TypedArray + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/Int32Array +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Int32Array</code></strong> getypte Array repräsentiert ein Array von zweierkomplement 32 Bit vorzeichenbehafteten, ganze Zahlen in der Plattform-Byte-Reihenfolge. Wenn Kontrolle über die Byte-Reihenfolge erforderlich ist, muss {{jsxref("DataView")}} stattdessen benutz werden. Die Inhalte werden mit <code>0</code> initialisiert. Wie erwartet, kann man Element in einem Array mit Objektmethoden referenzieren oder man benutzt die normale Arrayindex-Syntax (das ist die Klammernotation).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new Int32Array(); // new in ES2017 +new Int32Array(length); +new Int32Array(typedArray); +new Int32Array(object); +new Int32Array(buffer [, byteOffset [, length]]);</pre> + +<p>Für mehr Informationen über die Konstruktorensyntax und die Parameter, siehe auf der Seite <em><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int32Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Gibt die Größe der Elemente zurück. <code>4</code> im Falle eines <code>Int32Array</code>.</dd> + <dt>Int32Array.length</dt> + <dd>Statische Längeneigenschaft welche den Wert 0 hat. Für die aktuelle Länge (Anzahl der Elemente) siehe {{jsxref("TypedArray.prototype.length", "Int32Array.prototype.length")}}.</dd> + <dt>{{jsxref("TypedArray.name", "Int32Array.name")}}</dt> + <dd>Gibt den Stringwert des Konstruktornamens zurück. In Fall eines <code>Int32Array</code> Typs: <code>"Int32Array"</code>.</dd> + <dt>{{jsxref("TypedArray.prototype", "Int32Array.prototype")}}</dt> + <dd>Prototyp für das <em>TypedArray</em> Objekt.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Int32Array.from()")}}</dt> + <dd>Erstelle ein neues <code>Int32Array</code> von einem Array-Ähnlichen oder Iterable Objekt. Siehe auch {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Int32Array.of()")}}</dt> + <dd>Erstellt ein neues <code>Int32Array</code> mit einer variablen Anzahl an Argumenten. Sie auch {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Int32Array_Prototyp"><code>Int32Array</code> Prototyp</h2> + +<p>Alle <code>Int32Array</code> Objekte erben von {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<dl> + <dt><code>Int32Array.prototype.constructor</code></dt> + <dd>Gibt die Funktion, die einen Instanzprototyp erstellt zurück. Diese ist auf den <code>Int32Array</code> Konstruktor voreingestellt.</dd> + <dt>{{jsxref("TypedArray.prototype.buffer", "Int32Array.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Gibt die {{jsxref("ArrayBuffer")}} Referenz zurück, welche nach der Erstellung eines <code>Int32Array</code> fest ist und nicht mehr geändert werden kann.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Int32Array.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Gibt die Länge (in Bytes) des <code>Int32Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Int32Array.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Gibt das Offset (in Bytes) des <code>Int32Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.length", "Int32Array.prototype.length")}} {{readonlyInline}}</dt> + <dd>Gibt Anzahl der Elemente des <code>Int32Array</code> zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> +</dl> + +<h3 id="Methoden_2">Methoden</h3> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Int32Array.prototype.copyWithin()")}}</dt> + <dd>Kopiert eine Sequenz von Arrayelementen in das Array. Siehe auch {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Int32Array.prototype.entries()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Schlüssel/Wertepaare für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Int32Array.prototype.every()")}}</dt> + <dd>Teste, ob alle Elemente einem, als Funktion übergebenen, Test erfüllen. Siehe auch Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Int32Array.prototype.fill()")}}</dt> + <dd>Füllt alle Elemente eines Arrays vom Startindex bis zum Endindex mit einem statischen Wert. Siehe auch {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Int32Array.prototype.filter()")}}</dt> + <dd>Erstellt ein neues Array mit allen Elementen des alten Arrays, für die eine übergebene Filterfunktion <code>true</code> zurückgibt. Siehe auch {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Int32Array.prototype.find()")}}</dt> + <dd>Gibt ein gefundenes Element des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>undefined</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Int32Array.prototype.findIndex()")}}</dt> + <dd>Gibt den Index eines gefundenen Elements des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Int32Array.prototype.forEach()")}}</dt> + <dd>Ruft für jedes Element in einem Array eine Funktion auf. Siehe auch {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Int32Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Überprüft, ob ein getyptes Array ein bestimmtes Element enthält und gibt gegebenfalls <code>true</code> oder<code>false</code> zurück. Siehe auch {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Int32Array.prototype.indexOf()")}}</dt> + <dd>Gibt den ersten Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Int32Array.prototype.join()")}}</dt> + <dd>Führt alle Elemente eines Arrays zu einem String zusammen. Siehe auch {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Int32Array.prototype.keys()")}}</dt> + <dd>Gibt ein neuen <code>Array Iterator</code> zurück, der alle Schlüssel für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Int32Array.prototype.lastIndexOf()")}}</dt> + <dd>Gibt den letzen Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Int32Array.prototype.map()")}}</dt> + <dd>Erstellt ein neues Array mit den Resultaten spezifizierten Funktion, die für jedes Element aufgerufen wird. Siehe auch {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.move", "Int32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt> + <dd>Ehemalige nicht Standardisierte Version von {{jsxref("TypedArray.copyWithin", "Int32Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Int32Array.prototype.reduce()")}}</dt> + <dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von links nach rechts), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Int32Array.prototype.reduceRight()")}}</dt> + <dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von rechts nach links), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Int32Array.prototype.reverse()")}}</dt> + <dd>Kehrt die Reihenfolge von jedem Element eines Arrays um — das Erste wird das Letzte und das Letzte wird das Erste. Siehe auch {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Int32Array.prototype.set()")}}</dt> + <dd>Speichert mehrere Werte in einem getypten Array und ließt Eingabewerte aus einem spezifiziertem Array.</dd> + <dt>{{jsxref("TypedArray.slice", "Int32Array.prototype.slice()")}}</dt> + <dd>Extrahiert einen Bereich aus einem Array und gibt diesen in einem neuen Array zurück. Siehe auch {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Int32Array.prototype.some()")}}</dt> + <dd>Gibt <code>true</code> zurück, wenn nur ein Element in einem Array den als Funktion übergebenen Test erfüllt. Siehe auch {{jsxref("Array.prototype.some()")}}</dd> + <dt>{{jsxref("TypedArray.sort", "Int32Array.prototype.sort()")}}</dt> + <dd>Sortiert die Elemente eines Arrays in-Place und gibt das Array zurück. Siehe auch {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Int32Array.prototype.subarray()")}}</dt> + <dd>Gibt ein neues <code>Int32Array</code> vom gegebenen Start- und Endindex zurück.</dd> + <dt>{{jsxref("TypedArray.values", "Int32Array.prototype.values()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Werte von jedem Index im Array enthält. Siehe auch {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Int32Array.prototype.toLocaleString()")}}</dt> + <dd>Gibt einen Ortsabhängige Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Int32Array.prototype.toString()")}}</dt> + <dd>Gibt einen Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Int32Array.prototype[@@iterator]()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die zugehörigen Werte für jeden Index im Array enthalten.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Verschiedene Wege, um ein <code>Int32Array</code> zu erstellen:</p> + +<pre class="brush: js">// From a length +var int32 = new Int32Array(2); +int32[0] = 42; +console.log(int32[0]); // 42 +console.log(int32.length); // 2 +console.log(int32.BYTES_PER_ELEMENT); // 4 + +// From an array +var arr = new Int32Array([21,31]); +console.log(arr[1]); // 31 + +// From another TypedArray +var x = new Int32Array([21, 31]); +var y = new Int32Array(x); +console.log(y[0]); // 21 + +// From an ArrayBuffer +var buffer = new ArrayBuffer(16); +var z = new Int32Array(buffer, 0, 4); + +// From an iterable +var iterable = function*(){ yield* [1,2,3]; }(); +var int32 = new Int32Array(iterable); +// Int32Array[1, 2, 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt in ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA Standard. Spezifiziert, dass ein <code>new</code> benötigt wird.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>ECMAScript 2017 ändert den <code>Int32Array</code> Konstruktor, um die <code>ToIndex</code> Operation zu benutzen und erlaubt einen Konstruktor ohne Parameter.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Int32Array")}}</p> + +<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2> + +<p>Mit Beginn von ECMAScript 2015, müssen <code>Int32Array</code> Konstruktoren mit einem {{jsxref("Operators/new", "new")}} benutzt werden. Der Aufruf eines <code>Int32Array</code> Konstruktors als eine Funktion ohne <code>new</code>, Führt jetzt zu einem {{jsxref("TypeError")}}.</p> + +<pre class="brush: js example-bad">var dv = Int32Array([1, 2, 3]); +// TypeError: calling a builtin Int32Array constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new Int32Array([1, 2, 3]);</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript getypte Arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/int8array/index.html b/files/de/web/javascript/reference/global_objects/int8array/index.html new file mode 100644 index 0000000000..2358f38883 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/int8array/index.html @@ -0,0 +1,209 @@ +--- +title: Int8Array +slug: Web/JavaScript/Reference/Global_Objects/Int8Array +tags: + - Constructor + - Int8Array + - JavaScript + - TypedArray + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/Int8Array +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Int8Array</code></strong> getypte Array repräsentiert ein Array von zweierkomplement 8 Bit vorzeichenbehafteten, ganze Zahlen in der Plattform-Byte-Reihenfolge. Die Inhalte werden mit <code>0</code> initialisiert. Wie erwartet, kann man Element in einem Array mit Objektmethoden referenzieren oder man benutzt die normale Arrayindex-Syntax (das ist die Klammernotation).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new Int8Array(); // new in ES2017 +new Int8Array(length); +new Int8Array(typedArray); +new Int8Array(object); +new Int8Array(buffer [, byteOffset [, length]]);</pre> + +<p>Für mehr Informationen über die Konstruktorensyntax und die Parameter, siehe auf der Seite <em><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int8Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Gibt die Größe der Elemente zurück. <code>1</code> im Falle eines <code>Int8rray</code>.</dd> + <dt>Int8Array.length</dt> + <dd>Statische Längeneigenschaft welche den Wert 0 hat. Für die aktuelle Länge (Anzahl der Elemente) siehe {{jsxref("TypedArray.prototype.length", "Int8Array.prototype.length")}}.</dd> + <dt>{{jsxref("TypedArray.name", "Int8Array.name")}}</dt> + <dd>Gibt den Stringwert des Konstruktornamens zurück. In Fall eines <code>Int8Array</code> Typs: <code>"Int8Array"</code>.</dd> + <dt>{{jsxref("TypedArray.prototype", "Int8Array.prototype")}}</dt> + <dd>Prototyp für das <em>TypedArray</em> Objekt.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Int8Array.from()")}}</dt> + <dd>Erstelle ein neues <code>Int8Array</code> von einem Array-Ähnlichen oder Iterable Objekt. Siehe auch {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Int8Array.of()")}}</dt> + <dd>Erstellt ein neues <code>Int8Array</code> mit einer variablen Anzahl an Argumenten. Sie auch {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Int8Array_Prototyp"><code>Int8Array</code> Prototyp</h2> + +<p> </p> + +<p>Alle <code>Int8Array</code> Objekte erben von {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<dl> + <dt><code>Int8Array.prototype.constructor</code></dt> + <dd>Gibt die Funktion, die einen Instanzprototyp erstellt zurück. Diese ist auf den <code>Int8Array</code> Konstruktor voreingestellt.</dd> + <dt>{{jsxref("TypedArray.prototype.buffer", "Int8Array.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Gibt die {{jsxref("ArrayBuffer")}} Referenz zurück, welche nach der Erstellung eines <code>Int8Array</code> fest ist und nicht mehr geändert werden kann.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Int8Array.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Gibt die Länge (in Bytes) des <code>Int8Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Int8Array.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Gibt das Offset (in Bytes) des <code>Int8Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> + <dt>{{jsxref("TypedArray.prototype.length", "Int8Array.prototype.length")}} {{readonlyInline}}</dt> + <dd>Gibt Anzahl der Elemente des <code>Int8Array</code> zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd> +</dl> + +<h3 id="Methoden_2">Methoden</h3> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Int8Array.prototype.copyWithin()")}}</dt> + <dd>Kopiert eine Sequenz von Arrayelementen in das Array. Siehe auch {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Int8Array.prototype.entries()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Schlüssel/Wertepaare für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Int8Array.prototype.every()")}}</dt> + <dd>Teste, ob alle Elemente einem, als Funktion übergebenen, Test erfüllen. Siehe auch Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Int8Array.prototype.fill()")}}</dt> + <dd>Füllt alle Elemente eines Arrays vom Startindex bis zum Endindex mit einem statischen Wert. Siehe auch {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Int8Array.prototype.filter()")}}</dt> + <dd>Erstellt ein neues Array mit allen Elementen des alten Arrays, für die eine übergebene Filterfunktion <code>true</code> zurückgibt. Siehe auch {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Int8Array.prototype.find()")}}</dt> + <dd>Gibt ein gefundenes Element des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>undefined</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Int8Array.prototype.findIndex()")}}</dt> + <dd>Gibt den Index eines gefundenen Elements des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Int8Array.prototype.forEach()")}}</dt> + <dd>Ruft für jedes Element in einem Array eine Funktion auf. Siehe auch {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Int8Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Überprüft, ob ein getyptes Array ein bestimmtes Element enthält und gibt gegebenfalls <code>true</code> oder<code>false</code> zurück. Siehe auch {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Int8Array.prototype.indexOf()")}}</dt> + <dd>Gibt den ersten Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Int8Array.prototype.join()")}}</dt> + <dd>Führt alle Elemente eines Arrays zu einem String zusammen. Siehe auch {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Int8Array.prototype.keys()")}}</dt> + <dd>Gibt ein neuen <code>Array Iterator</code> zurück, der alle Schlüssel für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Int8Array.prototype.lastIndexOf()")}}</dt> + <dd>Gibt den letzen Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Int8Array.prototype.map()")}}</dt> + <dd>Erstellt ein neues Array mit den Resultaten spezifizierten Funktion, die für jedes Element aufgerufen wird. Siehe auch {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.move", "Int8Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt> + <dd>Ehemalige nicht Standardisierte Version von {{jsxref("TypedArray.copyWithin", "Int8Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Int8Array.prototype.reduce()")}}</dt> + <dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von links nach rechts), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Int8Array.prototype.reduceRight()")}}</dt> + <dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von rechts nach links), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Int8Array.prototype.reverse()")}}</dt> + <dd>Kehrt die Reihenfolge von jedem Element eines Arrays um — das Erste wird das Letzte und das Letzte wird das Erste. Siehe auch {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Int8Array.prototype.set()")}}</dt> + <dd>Speichert mehrere Werte in einem getypten Array und ließt Eingabewerte aus einem spezifiziertem Array.</dd> + <dt>{{jsxref("TypedArray.slice", "Int8Array.prototype.slice()")}}</dt> + <dd>Extrahiert einen Bereich aus einem Array und gibt diesen in einem neuen Array zurück. Siehe auch {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Int8Array.prototype.some()")}}</dt> + <dd>Gibt <code>true</code> zurück, wenn nur ein Element in einem Array den als Funktion übergebenen Test erfüllt. Siehe auch {{jsxref("Array.prototype.some()")}}</dd> + <dt>{{jsxref("TypedArray.sort", "Int8Array.prototype.sort()")}}</dt> + <dd>Sortiert die Elemente eines Arrays in-Place und gibt das Array zurück. Siehe auch {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Int8Array.prototype.subarray()")}}</dt> + <dd>Gibt ein neues <code>Int8Array</code> vom gegebenen Start- und Endindex zurück.</dd> + <dt>{{jsxref("TypedArray.values", "Int8Array.prototype.values()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Werte von jedem Index im Array enthält. Siehe auch {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Int8Array.prototype.toLocaleString()")}}</dt> + <dd>Gibt einen Ortsabhängige Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Int8Array.prototype.toString()")}}</dt> + <dd>Gibt einen Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Int8Array.prototype[@@iterator]()")}}</dt> + <dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die zugehörigen Werte für jeden Index im Array enthalten.</dd> +</dl> + +<p> </p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Verschiedene Wege, um ein <code>Int8Array</code> zu erstellen:</p> + +<pre class="brush: js">// From a length +var int8 = new Int8Array(2); +int8[0] = 42; +console.log(int8[0]); // 42 +console.log(int8.length); // 2 +console.log(int8.BYTES_PER_ELEMENT); // 1 + +// From an array +var arr = new Int8Array([21,31]); +console.log(arr[1]); // 31 + +// From another TypedArray +var x = new Int8Array([21, 31]); +var y = new Int8Array(x); +console.log(y[0]); // 21 + +// From an ArrayBuffer +var buffer = new ArrayBuffer(8); +var z = new Int8Array(buffer, 1, 4); + +// From an iterable +var iterable = function*(){ yield* [1,2,3]; }(); +var int8 = new Int8Array(iterable); +// Int8Array[1, 2, 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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Ersetzt in ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMA Standard. Spezifiziert, dass ein <code>new</code> benötigt wird.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>ECMAScript 2017 ändert den <code>Int8Array</code> Konstruktor, um die <code>ToIndex</code> Operation zu benutzen und erlaubt einen Konstruktor ohne Parameter.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Int8Array")}}</p> + +<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2> + +<p>Mit Beginn von ECMAScript 2015, müssen <code>Int8Array</code> Konstruktoren mit einem {{jsxref("Operators/new", "new")}} benutzt werden. Der Aufruf eines <code>Int8Array</code> Konstruktors als eine Funktion ohne <code>new</code>, Führt jetzt zu einem {{jsxref("TypeError")}}.</p> + +<pre class="brush: js example-bad">var dv = Int8Array([1, 2, 3]); +// TypeError: calling a builtin Int8Array constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new Int8Array([1, 2, 3]);</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript getypte Arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/internalerror/index.html b/files/de/web/javascript/reference/global_objects/internalerror/index.html new file mode 100644 index 0000000000..3775c4edd9 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/internalerror/index.html @@ -0,0 +1,82 @@ +--- +title: InternalError +slug: Web/JavaScript/Reference/Global_Objects/InternalError +tags: + - Error + - InternalError + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/InternalError +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Das <strong><code>InternalError</code> Objekt</strong> zeigt einen Fehler an, der in der JavaScript-Umgebung auftritt. Zum Beispiel: <strong>"InternalError</strong>: too much recursion".</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new InternalError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Optional. Für Menschen lesbare Fehlerbeschreibung.</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Optional. Der Name der Datei, in der der Fehler auftritt.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Optional. Die Zeilennummer in der Datei, in der der Fehler auftritt.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Ein <code>InternalError</code> wird immer erzeugt, wenn ein Fehler in der JavaScript-Umgebung auftritt.</p> + +<p>Beispielfälle die oft eintreten, wenn manchmal etwas zu ang ist:</p> + +<ul> + <li>"too many switch cases",</li> + <li>"too many parentheses in regular expression",</li> + <li>"array initializer too large",</li> + <li>"too much recursion".</li> +</ul> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("InternalError.prototype")}}</dt> + <dd>Erlaubt das Hinzufügen von Eigenschaften zu einem <code>InternalError</code> Objekt.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p>Die globale <code>InternalError</code> Klasse enthält keine eigenen Methoden, jedoch erbt sie einige Methoden durch die Prototypenkette.</p> + +<h2 id="InternalError_Instanzen"><code>InternalError</code> Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/InternalError/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methods">Methods</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/InternalError/prototype', 'Methoden')}}</div> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>In keiner Spezifikation enthalten.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.InternalError")}}</p> +</div> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("InternalError.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/internalerror/prototype/index.html b/files/de/web/javascript/reference/global_objects/internalerror/prototype/index.html new file mode 100644 index 0000000000..f76ee54ea8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/internalerror/prototype/index.html @@ -0,0 +1,61 @@ +--- +title: InternalError.prototype +slug: Web/JavaScript/Reference/Global_Objects/InternalError/prototype +tags: + - Error + - InternalError + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/InternalError +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <code><strong>InternalError.prototype</strong></code> Eigenschaft repräsentiert den Prototypen des {{jsxref("InternalError")}} Konstruktors.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Alle {{jsxref("InternalError")}} Instanzen erben von <code>InternalError.prototype</code>. Man kann den Prototypen benutzt, um Eigenschaften oder Methoden für alle Instanzen hinzuzufügen.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>InternalError.prototype.constructor</code></dt> + <dd>Spezifiziert die Funktion, die einen Instanzen Prototyp erstellt.</dd> + <dt>{{jsxref("Error.prototype.message", "InternalError.prototype.message")}}</dt> + <dd>Fehlermeldung. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "InternalError.prototype.name")}}</dt> + <dd>Fehlername. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "InternalError.prototype.fileName")}}</dt> + <dd>Pfad zur Datei, in der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "InternalError.prototype.lineNumber")}}</dt> + <dd>Zeilennummer, in der Datei, in der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "InternalError.prototype.columnNumber")}}</dt> + <dd>Spaltennummer, in der Zeile, in der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "InternalError.prototype.stack")}}</dt> + <dd>Stacktrace. Geerbt von {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p>Obwohl das {{jsxref("InternalError")}} Prototypobjekt keine eigenen Methoden besitzt, erben {{jsxref("InternalError")}} Instanzen einige Methoden durch die Prototypenkette.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>In keiner Spezifikation enthalten.</p> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.InternalError")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/collator/compare/index.html b/files/de/web/javascript/reference/global_objects/intl/collator/compare/index.html new file mode 100644 index 0000000000..c54c1a2869 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/collator/compare/index.html @@ -0,0 +1,101 @@ +--- +title: Intl.Collator.prototype.compare +slug: Web/JavaScript/Reference/Global_Objects/Intl/Collator/compare +tags: + - Collator + - Internationalization + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/compare +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.Collator.prototype.compare</code></strong> Eigenschaft gibt eine Funktion zurück, die zwei Strings, abhängig von der Sortierreihenfolge des {{jsxref("Collator")}} Objektes, vergleicht.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-collator-prototype-compare.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>collator</var>.compare(<var>string1</var>, <var>string2</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>string1</code></dt> + <dt><code>string2</code></dt> + <dd>Die Strings, die miteinander verglichen werden sollen.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die Funktion, die von dem Getter <code>compare</code> zurückgegeben wird, gibt eine Zahl zurück, die angibt, wie <code>string1</code> und <code>string2</code> in der Sortierreihenfolge des {{jsxref("Collator")}} Objektes zueinander stehen: Ein negativer Wert gibt an, <code>string1</code> vor <code>string2</code> kommt; Ein positiver Wert gibt an, dass <code>string1</code> nach <code>string2</code> kommt; 0 gibt an, dass beide gleich sind.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_compare_zum_Sortieren_von_Arrays">Einsatz von <code>compare</code> zum Sortieren von Arrays</h3> + +<p>Man kann die vom Getter <code>compare</code> zurückgegebenen Funktion zum Sortieren von Arrays einsetzen. Zu beachten ist, dass diese Funktion an das collator-Objekte gebunden ist, auf dem es aufgerufen wurde, so dass es direkt an {{jsxref("Array.prototype.sort()")}} übergeben werden kann.</p> + +<pre class="brush: js">var a = ['Offenbach', 'Österreich', 'Odenwald']; +var collator = new Intl.Collator('de-u-co-phonebk'); +a.sort(collator.compare); +console.log(a.join(', ')); +// → "Odenwald, Österreich, Offenbach" +</pre> + +<h3 id="Einsatz_von_compare_zum_Suchen_in_Arrays">Einsatz von <code>compare</code> zum Suchen in Arrays</h3> + +<p>Man kann die vom Getter <code>compare</code> zurückgegebenen Funktion zum suchen von passenden Elementen in einem Array benutzen:</p> + +<pre class="brush: js">var a = ['Congrès', 'congres', 'Assemblée', 'poisson']; +var collator = new Intl.Collator('fr', { usage: 'search', sensitivity: 'base' }); +var s = 'congres'; +var matches = a.filter(v => collator.compare(v, s) === 0); +console.log(matches.join(', ')); +// → "Congrès, congres" +</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('ES Int 1.0', '#sec-10.3.2', 'Intl.Collator.prototype.compare')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-10.3.2', 'Intl.Collator.prototype.compare')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype.compare', 'Intl.Collator.prototype.compare')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.Collator.compare")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Collator", "Intl.Collator")}}</li> + <li>{{jsxref("String.prototype.localeCompare()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/collator/index.html b/files/de/web/javascript/reference/global_objects/intl/collator/index.html new file mode 100644 index 0000000000..1ed4bb3f34 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/collator/index.html @@ -0,0 +1,179 @@ +--- +title: Intl.Collator +slug: Web/JavaScript/Reference/Global_Objects/Intl/Collator +tags: + - Collator + - Internationalization + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Intl.Collator</code></strong> Objekt ist ein Konstruktor für Überprüfer, Objekte die Sprachsensitive Stringvergleiche unterstützen.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-collator.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new Intl.Collator([<var>locales</var>[, <var>options</var>]]) +Intl.Collator.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>locales</code></dt> + <dd> + <p>Optional. Ein String mit einem BCP 47 Sprachtag, oder einem Array von solchen Strings. Für die generelle Interpretation für das <code>locales</code> Argument, siehe auf der {{jsxref("Global_Objects/Intl", "Intl Seite", "#Gebietsidentifikation_und_-verhandlung", 1)}} nach. Die folgenden Unicode-Erweiterunsschlüssel sind erlaubt:</p> + + <dl> + <dt><code>co</code></dt> + <dd>Abweichender Vergleich für einige Gebiete. Folgende Werte sind möglich: <code>"big5han"</code>, <code>"dict"</code>, <code>"direct"</code>, <code>"ducet"</code>, <code>"gb2312"</code>, <code>"phonebk"</code>, <code>"phonetic"</code>, <code>"pinyin"</code>, <code>"reformed"</code>, <code>"searchjl"</code>, <code>"stroke"</code>, <code>"trad"</code>, <code>"unihan"</code>. Die Werte <code>"standard"</code> und <code>"search"</code> werden ignoriert. Sie werden durch die EIgenschaft <code>usage</code> des <code>options</code> Objekt ersetzt (siehe unten).</dd> + <dt><code>kn</code></dt> + <dd>Wenn numerische Vergleiche benutzt werden soll, so wie "1" < "2" < "10". Mögliche Werte sind <code>"true"</code> und <code>"false"</code>. Diese Option kann über eine <code>options</code> Eigenschaft oder über einen Unicode-Erweiterungsschlüssel gesetzt werden. Wenn beide gesetzt sind, hat die <code>options</code> Eigenschaft Vorrang.</dd> + <dt><code>kf</code></dt> + <dd>Wenn Kleinschreibung oder Großschreibung zuerst in der Reihenfolge kommt. Mögliche Wert sind <code>"upper"</code>, <code>"lower"</code>, or <code>"false"</code> (benutzt den Gebietsstandard). Diese Option kann über eine <code>options</code> Eigenschaft oder über einen Unicode-Erweiterungsschlüssel gesetzt werden. Wenn beide gesetzt sind, hat die <code>options</code> Eigenschaft Vorrang.</dd> + </dl> + </dd> + <dt><code>options</code></dt> + <dd> + <p>Optional. Ein Objekt einigen oder allen der folgenden Eigenschafte:</p> + + <dl> + <dt><code>localeMatcher</code></dt> + <dd>Der Algorithmus zur Ermittlung des Gebiets. Mögliche Werte sind <code>"lookup"</code> and <code>"best fit"</code>; Der Standard ist <code>"best fit"</code>. Für Informationen über diese Option siehe auf der {{jsxref("Global_Objects/Intl", "Intl Seite", "#Gebietsauswahl", 1)}} nach.</dd> + <dt><code>usage</code></dt> + <dd>Ob der Vergleich für das Sortieren oder Suchen von Strings ist. Mögliche Werte sind <code>"sort"</code> and <code>"search"</code>; der Standard ist <code>"sort"</code>.</dd> + <dt><code>sensitivity</code></dt> + <dd> + <p>Welche Unterschiede in Strings sollen zu Resultaten ungleich 0 führen. Mögliche Werte:</p> + + <ul> + <li><code>"base"</code>: Nur Strings die im Basisbuchstaben ungleiche sind. Beispiele: <code>a ≠ b</code>, <code>a = á</code>, <code>a = A</code>.</li> + <li><code>"accent"</code>: Nur Strings die im Basisbuchstaben oder Akzent und anderen diakritisch Zeichen ungleich sind. Beispiele: <code>a ≠ b</code>, <code>a ≠ á</code>, <code>a = A</code>.</li> + <li><code>"case"</code>: Nur Strings die im Basisbuchstaben oder der Größe ungleich sind. Beispiele: <code>a ≠ b</code>, <code>a = á</code>, <code>a ≠ A</code>.</li> + <li><code>"variant"</code>: Strings, die im Basisbuchstaben, im Akzent und anderen diakritischen Zeichen oder in der Großschreibung ungleich sind. Andere Unterschiede können in den Vergleich eingehen. Beispiele: <code>a ≠ b</code>, <code>a ≠ á</code>, <code>a ≠ A</code>.</li> + </ul> + + <p>Der Standardwert ist <code>"variant"</code> wenn <code>usage</code> auf <code>"sort"</code> steht. Für <code>usage</code> gleich <code>"search"</code> ist es Gebietsabhängig.</p> + </dd> + <dt><code>ignorePunctuation</code></dt> + <dd>Wenn Interpunktion ignoriert werden soll. Mögliche Werte sind <code>true</code> and <code>false</code>; Der Standard ist <code>false</code>.</dd> + <dt><code>numeric</code></dt> + <dd>Wenn numerische Vergleiche benutzt werden soll, so wie "1" < "2" < "10". Mögliche Werte sind <code>"true"</code> und <code>"false"</code>. Der Standard ist <code>false</code>. Diese Option kann über eine <code>options</code> Eigenschaft oder über einen Unicode-Erweiterungsschlüssel gesetzt werden. Wenn beide gesetzt sind, hat die <code>options</code> Eigenschaft Vorrang. Implementierungen müssen diese Eigenschaft nicht unterstützen.</dd> + <dt><code>caseFirst</code></dt> + <dd>Wenn Kleinschreibung oder Großschreibung zuerst in der Reihenfolge kommt. Mögliche Wert sind <code>"upper"</code>, <code>"lower"</code>, or <code>"false"</code> (benutzt den Gebietsstandard). Der Standard ist <code>"false"</code>. Diese Option kann über eine <code>options</code> Eigenschaft oder über einen Unicode-Erweiterungsschlüssel gesetzt werden. Wenn beide gesetzt sind, hat die <code>options</code> Eigenschaft Vorrang. Implementierungen müssen diese Eigenschaft nicht unterstützen.</dd> + </dl> + </dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das <code>Intl.Collator</code> Objekt hat die folgenden Eigenschaften und Methoden:</p> + +<h3 id="Eigenschaften">Eigenschaften</h3> + +<dl> + <dt>{{jsxref("Collator.prototype", "Intl.Collator.prototype")}}</dt> + <dd>Erlaubt das hinzufügen von Eigenschaften zu allen Objekten.</dd> +</dl> + +<h3 id="Methoden">Methoden</h3> + +<dl> + <dt>{{jsxref("Collator.supportedLocalesOf", "Intl.Collator.supportedLocalesOf()")}}</dt> + <dd>Gibt ein Array von Gebieten zurück, die unterstützt werden, ohne dass die Backuplösung des Umgebungsstandards eingesetzt wird.</dd> +</dl> + +<h2 id="Collator_Instanzen"><code>Collator</code> Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<p><code>Collator</code> Instanzen erben die folgenden Eigenschaften von ihrem Prototyp:</p> + +<div>{{page('de/docs/Web/JavaScript/Reference/Global_Objects/Collator/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<p><code>Collator</code> Instanzen erben die folgenden Methoden von ihrem Prototyp:</p> + +<div>{{page('de/docs/Web/JavaScript/Reference/Global_Objects/Collator/prototype', 'Methoden')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Collator">Einsatz von <code>Collator</code></h3> + +<p>Das folgende Beispiel demonstriert die potentiell Unterschiedlichen Ergebnisse für ein String vor, nach, oder an der selben Stelle in ein andere String in der Sortierreihenfolge:</p> + +<pre class="brush: js">console.log(new Intl.Collator().compare('a', 'c')); // → ein negativer Wert +console.log(new Intl.Collator().compare('c', 'a')); // → ein positiver Wert +console.log(new Intl.Collator().compare('a', 'a')); // → 0 +</pre> + +<p>Zu beachten ist, dass sich das im Quelltext gezeigte Ergebnis zwischen Browsern und Browserversionen unterscheiden kann. Das ist, weil die Werte implementierungsabhängig sind. Die Spezifikation definiert nur, dass die Werte vor und nach gleich negativ und positiv sein müssen.</p> + +<h3 id="Einsatz_von_locales">Einsatz von <code>locales</code></h3> + +<p>Das Ergebnis von {{jsxref("Collator.prototype.compare()")}} variiert zwischen Sprachen. Um die Sortierreihenfolge eine Sprache im Benutzerinterface eine Applikation zu bekommen, sollte man die Sprache mit dem <code>locales</code> Argument spezifizieren (und einige Backupsprachen):</p> + +<pre class="brush: js">// in German, ä sorts with a +console.log(new Intl.Collator('de').compare('ä', 'z')); +// → a negative value + +// in Swedish, ä sorts after z +console.log(new Intl.Collator('sv').compare('ä', 'z')); +// → a positive value +</pre> + +<h3 id="Einsatz_von_options">Einsatz von <code>options</code></h3> + +<p>Das Ergebnis von {{jsxref("Collator.prototype.compare()")}} kann durch den Einsatz des <code>options</code> Argument verändert werden:</p> + +<pre class="brush: js">// in German, ä has a as the base letter +console.log(new Intl.Collator('de', { sensitivity: 'base' }).compare('ä', 'a')); +// → 0 + +// in Swedish, ä and a are separate base letters +console.log(new Intl.Collator('sv', { sensitivity: 'base' }).compare('ä', 'a')); +// → a positive 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('ES Int 1.0', '#sec-10.1', 'Intl.Collator')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-10.1', 'Intl.Collator')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#collator-objects', 'Intl.Collator')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.Collator")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Intl', 'Siehe_auch')}}</div> diff --git a/files/de/web/javascript/reference/global_objects/intl/collator/prototype/index.html b/files/de/web/javascript/reference/global_objects/intl/collator/prototype/index.html new file mode 100644 index 0000000000..2528ecc7ba --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/collator/prototype/index.html @@ -0,0 +1,79 @@ +--- +title: Intl.Collator.prototype +slug: Web/JavaScript/Reference/Global_Objects/Intl/Collator/prototype +tags: + - Collator + - Internationalization + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.Collator.prototype</code></strong> Eigenschaft repräsentiert das Prototypobjekt für den {{jsxref("Collator", "Intl.Collator")}} Konstruktor.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Siehe im Beitrag {{jsxref("Collator")}} für eine Beschreibung von <code>Intl.Collator</code> Instanzen.</p> + +<p>{{jsxref("Collator", "Intl.Collator")}} Instanzen erben von <code>Intl.Collator.prototype</code>. Änderungen am Prototypobjekt werden an alle {{jsxref("Collator", "Intl.Collator")}} Instanzen vererbt.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("Collator.compare", "Intl.Collator.prototype.compare")}}</dt> + <dd>Getter; gibt eine Funktion zurück, die zwei Strings abhängig vom der Sortierreihenfolge des {{jsxref("Global_Objects/Collator", "Intl.Collator")}} Objektes vergleicht.</dd> + <dt><code>Intl.Collator.prototype.constructor</code></dt> + <dd>Eine Referenz zu {{jsxref("Global_Objects/Collator", "Intl.Collator")}}.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Collator.resolvedOptions", "Intl.Collator.prototype.resolvedOptions()")}}</dt> + <dd>Gibt ein neues Objekt mit Eigenschaften zu Gebiets- und Collation-Optionen, die bei der Initialisierung des Objekte ermittelt wurden.</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('ES Int 1.0', '#sec-10.2.1', 'Intl.Collator.prototype')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-10.2.1', 'Intl.Collator.prototype')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype', 'Intl.Collator.prototype')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.Collator.prototype")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Collator", "Intl.Collator")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html b/files/de/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html new file mode 100644 index 0000000000..322621017f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html @@ -0,0 +1,100 @@ +--- +title: Intl.Collator.prototype.resolvedOptions() +slug: Web/JavaScript/Reference/Global_Objects/Intl/Collator/resolvedOptions +tags: + - Collator + - Internationalization + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/resolvedOptions +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.Collator.prototype.resolvedOptions()</code></strong> Methode gibt ein neues Objekt mit Eigenschaften zurück, welches die Gebiets- und Vergleichs-Optionen während der Initialisierung des {{jsxref("Collator")}} Objektes wiederspiegelt.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-collator-prototype-resolvedoptions.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>collator</var>.resolvedOptions()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues Objekt mit Eigenschaften, die die Eigenschaften der Gebiets- und Vergleichsoptionen enthält, die während der Initialisierung des gegebenen {{jsxref("Collator")}} Objekt ermittelt wurden.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das Ergebnisobjekt hat die folgenden Eigenschaften:</p> + +<dl> + <dt><code>locale</code></dt> + <dd>Der BCP 47 Sprachtag für das aktuell benutzte Gebiet. Wenn Unicode-Erweiterungswerte im BCP 47 Sprachtag in der Gebietsangabe angegeben sind, sind die, die auch unterstützt sind, in <code>locale</code> vorhanden.</dd> + <dt><code>usage</code></dt> + <dt><code>sensitivity</code></dt> + <dt><code>ignorePunctuation</code></dt> + <dd>Die Werte der Unterstützten Eigenschaften des <code>options</code> Argument oder eingesetzte Standardwerte.</dd> + <dt><code>collation</code></dt> + <dd>Der überbene Wert des Unicode-Werweiterungsschlüssels <code>"co"</code>, wenn dieser für <code>locale</code> unterstützt wird oder <code>"default"</code>.</dd> + <dt><code>numeric</code></dt> + <dt><code>caseFirst</code></dt> + <dd>Die Werte der Unterstützten Eigenschaften des <code>options</code> Argument oder der eingesetzten Unicode-Erweiterungsschlüssel <code>"kn"</code> and <code>"kf"</code> oder den Standardwerten. Wenn die Implimentierung diese Eigenschaften nicht unterstützt, werden diese weggelassen.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_resolvedOptions_Methode">Einsatz der <code>resolvedOptions</code> Methode</h3> + +<pre class="brush: js">var de = new Intl.Collator('de', { sensitivity: 'base' }) +var usedOptions = de.resolvedOptions(); + +usedOptions.locale; // "de" +usedOptions.usage; // "sort" +usedOptions.sensitivity; // "base" +usedOptions.ignorePunctuation; // false +usedOptions.collation; // "default" +usedOptions.numeric; // false +</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('ES Int 1.0', '#sec-10.3.3', 'Intl.Collator.prototype.resolvedOptions')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-10.3.3', 'Intl.Collator.prototype.resolvedOptions')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype.resolvedOptions', 'Intl.Collator.prototype.resolvedOptions')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.Collator.resolvedOptions")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Collator", "Intl.Collator")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html b/files/de/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html new file mode 100644 index 0000000000..8bc9bed6bb --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html @@ -0,0 +1,98 @@ +--- +title: Intl.Collator.supportedLocalesOf() +slug: Web/JavaScript/Reference/Global_Objects/Intl/Collator/supportedLocalesOf +tags: + - Collator + - Internationalization + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/supportedLocalesOf +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.Collator.supportedLocalesOf()</code></strong> Methode gibt ein Array zurück, welches die Gebiete enthält, die von <code>Collation</code> unterstützt werden, ohne das die Laufzeitumgebung auf den Systemstandard zurückgreifen muss.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-collator-prototype-supportedlocalesof.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Intl.Collator.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>locales</code></dt> + <dd>Ein String mit einem BCP 47 Sprachtag oder einem Array von solchen. Für die generelle Form des <code>locales</code> Argument siehe die {{jsxref("Global_Objects/Intl", "Intl Seite", "#Gebietsidentifikation_und_-verhandlung", 1)}}.</dd> + <dt><code>options</code></dt> + <dd> + <p>Optional. Ein Objekt welches die folgenden Eigenschaften haben kann:</p> + + <dl> + <dt><code>localeMatcher</code></dt> + <dd>Der Auswahlalgorithmus für das Gebiet. Mögliche Werte sind <code>"lookup"</code> and <code>"best fit"</code>; Der Standard ist <code>"best fit"</code>. Mehr Informationen über diese Algorithmen sind auch der {{jsxref("Global_Objects/Intl", "Intl Seite", "#Gebietsauswahl", 1)}} verfügbar.</dd> + </dl> + </dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein Array von String, welches eine Untermenge von Gebiete enthält, die von <code>Collation</code> unterstützt werden, ohne das die Laufzeitumgebung auf den Systemstandard zurückgreifen muss.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Gibt ein Array mit einer Untermenge von Sprachtags, die in <code>locales</code> angegeben sind zurück. Die Sprachtags, die zurückgegeben werden, werden von <code>collation</code> unterstützt und vom Auswahlalgorithmus ausgesucht, ohne auf eine Standard-Sprache zurückzugreifen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_supportedLocalesOf">Einsatz von <code>supportedLocalesOf</code></h3> + +<p>Angenommen wird, dass indonesisch und deutsch in <code>collation</code> unterstützt wird, aber balinesisch nicht. <code>supportedLocalesOf</code> gibt das indonesische und deutsche Sprachtag unverändert zurück, obwohl Pinyin nicht mit Indonesisch verwendet wird und Fachdeutsch wahrscheinlich nicht für Indonesisch verfügbar ist. Zu bemerken ist, dass der <code>"lookup"</code> Algorithmus verwendet wird — der<code>"best-fit"</code> Algorithmus könnte entscheiden, dass Indonesisch eine angemessene Ergänzung für Balinesen ist, da die meisten Balinesen Indonesisch verstehen und daher auch das balinesische Sprachtag zurückgeben.</p> + +<pre class="brush: js">var locales = ['ban', 'id-u-co-pinyin', 'de-ID']; +var options = { localeMatcher: 'lookup' }; +console.log(Intl.Collator.supportedLocalesOf(locales, options).join(', ')); +// → "id-u-co-pinyin, de-ID" +</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('ES Int 1.0', '#sec-10.2.2', 'Intl.Collator.supportedLocalesOf')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-10.2.2', 'Intl.Collator.supportedLocalesOf')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.Collator.supportedLocalesOf', 'Intl.Collator.supportedLocalesOf')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.Collator.supportedLocalesOf")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Collator", "Intl.Collator")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html new file mode 100644 index 0000000000..38ebaa091f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html @@ -0,0 +1,101 @@ +--- +title: Intl.DateTimeFormat.prototype.format +slug: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/format +tags: + - DateTimeFormat + - Internationalization + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/format +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.DateTimeFormat.prototype.format</code></strong> Eigenschaft gibt einen Getter-Funktion zurück, die einen Zeitstempel nach den Gebiets- und Formatierungsoptionen des {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Objekts formatiert.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-format.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateTimeFormat</var>.format(<var>date</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>date</code></dt> + <dd>Der Zeitstempel, der formatiert werden soll.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die Funktion, die vom <code>format</code> Getter zurückgegeben wird, formatiert einen Zeitpunkt (date) in einen String. Dabei werden die Gebiets- und Formatierungsoptionen des {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Objekts berücksichtigt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_format">Einsatz von <code>format</code></h3> + +<p>Die vom <code>format</code> Getter zurückgegebene Funktion wird zum Formatieren von Zeitstempeln genutzt, hier für Serbien:</p> + +<pre class="brush: js">var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }; +var dateTimeFormat = new Intl.DateTimeFormat('sr-RS', options); +console.log(dateTimeFormat.format(new Date())); +// → "недеља, 7. април 2013." +</pre> + +<h3 id="Einsatz_von_format_mit_map">Einsatz von <code>format</code> mit <code>map</code></h3> + +<p>Die vom <code>format</code> Getter zurückgegebene Funktion kann zum Formatieren von Zeitpunkten in einem Array genutzt werden. Zu berücksichtigen ist, dass die Funktion an das {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Objekt gebunden ist, von welche die Funktion stammt, so dass sie direkt an {{jsxref("Array.prototype.map()")}} übergeben werden kann.</p> + +<pre class="brush: js">var a = [new Date(2012, 08), new Date(2012, 11), new Date(2012, 03)]; +var options = { year: 'numeric', month: 'long' }; +var dateTimeFormat = new Intl.DateTimeFormat('pt-BR', options); +var formatted = a.map(dateTimeFormat.format); +console.log(formatted.join('; ')); +// → "setembro de 2012; dezembro de 2012; abril de 2012" +</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('ES Int 1.0', '#sec-12.3.2', 'Intl.DateTimeFormat.format')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-12.3.2', 'Intl.DateTimeFormat.format')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.format', 'Intl.DateTimeFormat.format')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.DateTimeFormat.format")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.html b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.html new file mode 100644 index 0000000000..07919d3fcf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.html @@ -0,0 +1,169 @@ +--- +title: Intl.DateTimeFormat.prototype.formatToParts() +slug: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts +tags: + - DateTimeFormat + - Internationalization + - Intl + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts +--- +<div>{{JSRef}} {{SeeCompatTable}}</div> + +<p>Die <strong><code>Intl.DateTimeFormat.prototype.formatToParts()</code></strong> Methode erlaubt gebietssichere Formatierung von Strings, die von <code>DateTimeFormat</code> Formatierungen erzeugt werden.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Intl.DateTimeFormat.prototype.formatToParts(date)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>date</code> {{optional_inline}}</dt> + <dd>Der Zeitstempel, der formatiert werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Array")}} von Objekten, die das Formatierte Datum in Teilen wiederspielgeln.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>formatToParts()</code> Methode ist nützlich für benutzerdefinierte Formatierung von Zeitpunktsstrings. <span id="result_box" lang="de"><span>Sie gibt ein {{jsxref ("Array")}} von Objekten zurück, die die länderspezifischen Token enthalten, aus denen benutzerdefinierte Zeichenfolgen erstellt werden können, während die länderspezifischen Teile beibehalten werden.</span> <span>Die Struktur, die die <code>formatToParts()</code> Methode zurückgibt, sieht so aus:</span></span></p> + +<pre class="brush: js">[ + { type: 'day', value: '17' }, + { type: 'weekday', value: 'Monday' } +]</pre> + +<p>Mögliche Typen sind die folgenden:</p> + +<dl> + <dt>day</dt> + <dd>Der String, der für den Tag benutzt wird. Zum Beispiel <code>"17"</code>.</dd> + <dt>dayPeriod</dt> + <dd>Der String, der für die Tagesperiode benutzt wird. Zum Beispiel <code>"AM"</code> oder <code>"PM"</code>.</dd> + <dt>era</dt> + <dd>Der String, der für die Ära benutzt wird. Zum Beispiel <code>"BC"</code> oder <code>"AD"</code>.</dd> + <dt>hour</dt> + <dd>Der String, der für die Stunde benutzt wird. Zum Beispiel <code>"3"</code> oder <code>"03"</code>.</dd> + <dt>literal</dt> + <dd>Der String, der als Trennung für das Datum und die Zeitbenutzt benutzt wird. Zum Beispiel <code>"/"</code>, <code>","</code>, <code>"o'clock"</code>, <code>"de"</code>, etc.</dd> + <dt>minute</dt> + <dd>Der String, der für die Minute benutzt wird. Zum Beispiel <code>"00"</code>.</dd> + <dt>month</dt> + <dd>Der String, der für den Monat benutzt wird. Zum Beispiel <code>"12"</code>.</dd> + <dt>second</dt> + <dd>Der String, der für die Sekunde benutzt wird. Zum Beispiel <code>"07"</code> oder <code>"42"</code>.</dd> + <dt>timeZoneName</dt> + <dd>Der String, der für den Zeitzonennamen benutzt wird. Zum Beispiel <code>"UTC"</code>.</dd> + <dt>weekday</dt> + <dd>Der String, der für den Wochentag benutzt wird. Zum Beispiel <code>"M"</code>, <code>"Monday"</code> oder <code>"Montag"</code>.</dd> + <dt>year</dt> + <dd>Der String, der für das Jahr benutzt wird. Zum Beispiel <code>"2012"</code> oder <code>"96"</code>.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<p><code>DateTimeFormat</code> gibt lokalisierte Strings aus, die nicht direkt verändert werden können:</p> + +<pre class="brush: js">var date = Date.UTC(2012, 11, 17, 3, 0, 42); + +var formatter = new Intl.DateTimeFormat('en-us', { + weekday: 'long', + year: 'numeric', + month: 'numeric', + day: 'numeric', + hour: 'numeric', + minute: 'numeric', + second: 'numeric', + hour12: true, + timeZone: 'UTC' +}); + +formatter.format(date); +// "Monday, 12/17/2012, 3:00:42 AM" +</pre> + +<p>Oftmals ist es in vielen Benutzeroberflächen erwünscht die Formatierung dieser Strings zu verändern. Die <code>formatToParts</code> Methode erlaubt lokalsicheres Formatieren von Strings, die von <code>DateTimeFormat</code> in Teilstrings unterstützt werden:</p> + +<pre class="brush: js">formatter.formatToParts(date); + +// return value: +[ + { type: 'weekday', value: 'Monday' }, + { type: 'literal', value: ', ' }, + { type: 'month', value: '12' }, + { type: 'literal', value: '/' }, + { type: 'day', value: '17' }, + { type: 'literal', value: '/' }, + { type: 'year', value: '2012' }, + { type: 'literal', value: ', ' }, + { type: 'hour', value: '3' }, + { type: 'literal', value: ':' }, + { type: 'minute', value: '00' }, + { type: 'literal', value: ':' }, + { type: 'second', value: '42' }, + { type: 'literal', value: ' ' }, + { type: 'dayPeriod', value: 'AM' } +] +</pre> + +<p>Jetzt sind die Informationen separiert vorhanden und man kann Formatierungen und Konkatinationen benutzerdefiniert vornehmen. Zum Beispiel unter Einsatz von {{jsxref("Array.prototype.map()")}}, <a href="/de/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Arrow Funktionen</a>, einem <a href="/de/docs/Web/JavaScript/Reference/Statements/switch">switch Statement</a>, <a href="/de/docs/Web/JavaScript/Reference/Template_literals">Templateliteralen</a> und {{jsxref("Array.prototype.reduce()")}}.</p> + +<pre class="brush: js">var dateString = formatter.formatToParts(date).map(({type, value}) => { + switch (type) { + case 'dayPeriod': return `<b>${value}</b>`; + default : return value; + } +}).reduce((string, part) => string + part); +</pre> + +<p>Diese Beispiel macht die Tagesperiode fett, wenn die <code>formatToParts()</code> Methode benutzt wird.</p> + +<pre class="brush: js">console.log(formatter.format(date)); +// "Monday, 12/17/2012, 3:00:42 AM" + +console.log(dateString); +// "Monday, 12/17/2012, 3:00:42 <b>AM</b>"</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Ein Polyfill für die Funktionalität ist im <a href="https://github.com/zbraniecki/proposal-intl-formatToParts">proposal repository</a> verfügbar.</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('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.formatToParts', 'Intl.DateTimeFormat.prototype.formatToParts')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>Initiale Definition</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.DateTimeFormat.formatToParts")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("DateTimeFormat.format", "Intl.DateTimeFormat.prototype.format")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/datetimeformat/index.html b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/index.html new file mode 100644 index 0000000000..94cfe2d3c7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/index.html @@ -0,0 +1,248 @@ +--- +title: Intl.DateTimeFormat +slug: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat +tags: + - DateTimeFormat + - Internationalization + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Intl.DateTimeFormat</code></strong> Objekt ist ein Konstruktor für Objekte, die sprachsensitive Formatierung von Datums- und Zeitangaben ermöglicht.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new Intl.DateTimeFormat([<var>locales</var>[, <var>options</var>]]) +Intl.DateTimeFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>locales</code></dt> + <dd>Optional. Ein String mit einem BCP 47 Sprachcode, oder einem Array von Sprachcodes. Für die generelle Form und Interpretation des <code>locales</code> Arguments siehe auf der {{jsxref("Global_Objects/Intl", "Intl Seite", "#Locale_identification_and_negotiation", 1)}}. Die folgenden Unicode Erweiterungen sind erlaubt:</dd> + <dd> + <dl> + <dt><code>nu</code></dt> + <dd>Zahlensysteme. Mögliche Werte sind: <code>"arab"</code>, <code>"arabext"</code>, <code>"bali"</code>, <code>"beng"</code>, <code>"deva"</code>, <code>"fullwide"</code>, <code>"gujr"</code>, <code>"guru"</code>, <code>"hanidec"</code>, <code>"khmr"</code>, <code>"knda"</code>, <code>"laoo"</code>, <code>"latn"</code>, <code>"limb"</code>, <code>"mlym"</code>, <code>"mong"</code>, <code>"mymr"</code>, <code>"orya"</code>, <code>"tamldec"</code>, <code>"telu"</code>, <code>"thai"</code>, <code>"tibt"</code>.</dd> + <dt><code>ca</code></dt> + <dd>Kalender. Mögliche Werte sind: <code>"buddhist"</code>, <code>"chinese"</code>, <code>"coptic"</code>, <code>"ethioaa"</code>, <code>"ethiopic"</code>, <code>"gregory"</code>, <code>"hebrew"</code>, <code>"indian"</code>, <code>"islamic"</code>, <code>"islamicc"</code>, <code>"iso8601"</code>, <code>"japanese"</code>, <code>"persian"</code>, <code>"roc"</code>.</dd> + <dt><code>hc</code></dt> + <dd>Stundenzyklus. Mögliche Werte sind: <code>"h11"</code>, <code>"h12"</code>, <code>"h23"</code>, <code>"h24"</code>.</dd> + </dl> + </dd> + <dt><code>options</code></dt> + <dd> + <p>Optional. Ein Objekt mit einigen oder allen folgenden Eigenschaften:</p> + + <dl> + <dt><code>localeMatcher</code></dt> + <dd>Der Sprachfindungsalgorithmus, der eingesetzt wird. Mögliche Werte sind <code>"lookup"</code> und <code>"best fit"</code>. Als Standard ist <code>"best fit"</code> vorgegeben. Für Informationen über diese Option siehe auf der {{jsxref("Global_Objects/Intl", "Intl Seite", "#Locale_negotiation", 1)}} nach.</dd> + <dt><code>timeZone</code></dt> + <dd>Die eingesetzte Zeitzone. Der einzige Wert, den alle Implementierungen verstehen ist <code>"UTC"</code>. Der Standardwert ist die Standard-Laufzeitzeitzone. Manche Implementierungen erkennen auch die Namen der <a href="https://www.iana.org/time-zones">IANA Zeitzonendatenbank</a>, wie zum Beispiel <code>"Asia/Shanghai"</code>, <code>"Asia/Kolkata"</code> und <code>"America/New_York"</code>.</dd> + <dt><code>hour12</code></dt> + <dd>Wird eingesetzt, wenn 12-Stunden Zeitangaben eingesetzt werden (im gegensatz zu 24-Stunden Zeitangaben). Mögliche Werte sind <code>true</code> und <code>false</code>. Diese Option überschreibt den <code>hc</code> Sprachen-Tag und/oder <code>hourCycle</code> wenn beide vorhanden sind.</dd> + <dt><code>hourCycle</code></dt> + <dd>Der eingesetzte Stundenzyklus. Mögliche Werte sind <code>"h11"</code>, <code>"h12"</code>, <code>"h23"</code> oder <code>"h24"</code>. Diese Option überschreibt den <code>hc</code> Sprachen-Tag, wenn beide präsent sind und die <code>hour12</code> Option hat Vorrang, wenn beide Optionen spezifiziert sind.</dd> + <dt><code>formatMatcher</code></dt> + <dd>Der eingesetzte Formaterkennungsalgorithmus. Mögliche Werte sind <code>"basic"</code> und <code>"best fit"</code>. Der Standard ist <code>"best fit"</code>. Siehe folgenden Absatz, um den Einsatz dieses Parameters zu verstehen.</dd> + </dl> + + <p>Die folgenden Eigenschaften beschreiben die Datums-Zeit-Komponenten, die für die formatierten Ausgabe eingesetzt werden und deren Repräsentation. Implementierungen müssen folgende Kombinationen der Eigenschaften unterstützen:</p> + + <ul> + <li><code>Wochentag, Jahr, Monat, Tag, Stunde, Minute, Sekunde</code></li> + <li><code>Wochentag, Jahr, Monat, Tag </code></li> + <li><code>Jahr, Monat, Tag </code></li> + <li><code>Jahr, Monat</code></li> + <li><code>Monat, Tag </code></li> + <li><code>Stunde, Minute, Sekunde </code></li> + <li><code>Stunde, Minute</code></li> + </ul> + + <p>Manche Implementierungen unterstützen weitere Kombinationen der Parameter. Es wird immer auf alle möglichen Kombinationen geprüft, um den besten Treffer zu landen. Zwei Algorithmen sind für die Auswahl der Kombination vorhanden: Ein <a href="http://www.ecma-international.org/ecma-402/1.0/#BasicFormatMatcher">voll spezifizierter <code>"basic"</code> Algorithmus</a> und ein implementierungsabhängiger <code>"best fit"</code> Algorithmus.</p> + + <dl> + <dt><code>weekday</code></dt> + <dd>Die Repräsentation der Wochentage. Mögliche Werte sind <code>"narrow"</code>, <code>"short"</code> und <code>"long"</code>.</dd> + <dt><code>era</code></dt> + <dd>Die Repräsentation der Epoche. Mögliche Werte sind <code>"narrow"</code>, <code>"short"</code> und <code>"long"</code>.</dd> + <dt><code>year</code></dt> + <dd>Die Repräsentation des Jahres. Mögliche Werte sind <code>"numeric"</code> und <code>"2-digit"</code>.</dd> + <dt><code>month</code></dt> + <dd>Die Repräsentation des Monats. Mögliche Werte sind <code>"numeric"</code>, <code>"2-digit"</code>, <code>"narrow"</code>, <code>"short"</code> und <code>"long"</code>.</dd> + <dt><code>day</code></dt> + <dd>Die Repräsentation des Tages. Mögliche Werte sind <code>"numeric"</code> und <code>"2-digit"</code>.</dd> + <dt><code>hour</code></dt> + <dd>Die Repräsentation der Stunden. Mögliche Werte sind <code>"numeric"</code> und <code>"2-digit"</code>.</dd> + <dt><code>minute</code></dt> + <dd>Die Repräsentation der Minuten. Mögliche Werte sind <code>"numeric"</code> und <code>"2-digit"</code>.</dd> + <dt><code>second</code></dt> + <dd>Die Repräsentation der Sekunden. Mögliche Werte sind <code>"numeric"</code> und <code>"2-digit"</code>.</dd> + <dt><code>timeZoneName</code></dt> + <dd>Die Repräsentation des Zeitzonennamens. Mögliche Werte sind <code>"short"</code> und <code>"long"</code>.</dd> + </dl> + + <p class="noinclude">Die Standardwerte für jede Datums-Zeit-Komponente ist {{jsxref("undefined")}}, wenn jedoch alle Komponenten {{jsxref("undefined")}} sind, wird <code>year</code>, <code>month</code>, and <code>day</code> als <code>"numeric"</code> angenommen.</p> + </dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<h3 id="Eigenschaften">Eigenschaften</h3> + +<dl> + <dt>{{jsxref("DateTimeFormat.prototype", "Intl.DateTimeFormat.prototype")}}</dt> + <dd>Ermögliche es Eigenschaften und Methoden für alle Objekte zu definieren.</dd> +</dl> + +<h3 id="Methoden">Methoden</h3> + +<dl> + <dt>{{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}</dt> + <dd>Gibt ein Array an Sprachen zurück, die unterstützt werden, ohne dass auf den Laufzeitumgebungsstandard zurückgegriffen wird.</dd> +</dl> + +<h2 id="DateTimeFormat_Instanzen"><code>DateTimeFormat</code> Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<p><code>DateTimeFormat</code> Instanzen erben die folgenden Eigenschaften von ihrem Prototypen:</p> + +<div>{{page("/de/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/prototype", "Eigenschaften")}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<p><code>DateTimeFormat</code> Instanzen erben die folgenden Methoden von ihrem Prototypen:</p> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/prototype', 'Methoden')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_DateTimeFormat">Einsatz von <code>DateTimeFormat</code></h3> + +<p>Der Basiseinsatz ohne extra Sprach- und Formatierungsoptionen, sondern den Standardeinstellungen.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// toLocaleString ohne Argumente ist von der implementierunge, +// der Standardsprache und der Standardzeitzone abhängig. +console.log(new Intl.DateTimeFormat().format(date)); +// → "12/19/2012" wenn das Gebiet en-US mit der Zeitzone America/Los_Angeles (UTC-0800) der Standard ist. +</pre> + +<h3 id="Einsatz_von_locales">Einsatz von <code>locales</code></h3> + +<p>Das folgende Beispiel zeigt verschiedene Formatierungsoptionen von Datums- und Zeitformaten. Um sicherzustellen, dass das Format der Sprache eingesetzt wird, die in der Benutzerschnittstelle benutzt wird, muss diese (und mögliche Rückfallsprachen) mit dem <code>locales</code> Argument eingestellt werden.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// Die folgenden Formate setzen die Zeitzone America/Los_Angeles +// für die Sprache US voraus. + +// US englisch: Monat-Tag-Jahr +console.log(new Intl.DateTimeFormat('en-US').format(date)); +// → "12/19/2012" + +// Britisch englisch: Tag-Monat-Jahr +console.log(new Intl.DateTimeFormat('en-GB').format(date)); +// → "20/12/2012" + +// Koreanisch: Jahr-Monat-Tag +console.log(new Intl.DateTimeFormat('ko-KR').format(date)); +// → "2012. 12. 20." + +// Arabisch: In den meisten arabischen Ländern werden arabische Ziffern genutzt +console.log(new Intl.DateTimeFormat('ar-EG').format(date)); +// → "<span dir="rtl">٢٠/١٢/٢٠١٢</span>" + +// Japanisch: In Japan wird der japanische Kalender eingesetzt: +// 2012 ist in diesem das Jahr 24 der Heisei Ära. +console.log(new Intl.DateTimeFormat('ja-JP-u-ca-japanese').format(date)); +// → "24/12/20" + +// Einsatz von Sprachen, die vielleicht nicht unterstützt werden: +// Balinesisch, und Indonesisch als Rückfallsprache. +console.log(new Intl.DateTimeFormat(['ban', 'id']).format(date)); +// → "20/12/2012" +</pre> + +<h3 id="Einsatz_von_options">Einsatz von <code>options</code></h3> + +<p>Das Datums- und Zeitformat kann mit dem Einsatz des <code>options</code> Arguments vom Benutzer definiert werden.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// Langer Wochentag mit langem Datum +var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }; +console.log(new Intl.DateTimeFormat('de-DE', options).format(date)); +// → "Donnerstag, 20. Dezember 2012" + +// sichtbares UTC +options.timeZone = 'UTC'; +options.timeZoneName = 'short'; +console.log(new Intl.DateTimeFormat('en-US', options).format(date)); +// → "Thursday, December 20, 2012, GMT" + +// Präzisere Angaben der Zeit +options = { + hour: 'numeric', minute: 'numeric', second: 'numeric', + timeZone: 'Australia/Sydney', + timeZoneName: 'short' +}; +console.log(new Intl.DateTimeFormat('en-AU', options).format(date)); +// → "2:00:00 pm AEDT" + +// 24-Stunden Angabe in US Zeiten +options = { + year: 'numeric', month: 'numeric', day: 'numeric', + hour: 'numeric', minute: 'numeric', second: 'numeric', + hour12: false, + timeZone: 'America/Los_Angeles' +}; +console.log(new Intl.DateTimeFormat('en-US', options).format(date)); +// → "12/19/2012, 19:00:00" +</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('ES Int 1.0', '#sec-12.1', 'Intl.DateTimeFormat')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-12.1', 'Intl.DateTimeFormat')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#datetimeformat-objects', 'Intl.DateTimeFormat')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.DateTimeFormat")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Intl', 'See_also')}}</div> diff --git a/files/de/web/javascript/reference/global_objects/intl/datetimeformat/prototype/index.html b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/prototype/index.html new file mode 100644 index 0000000000..98f5e8f57b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/prototype/index.html @@ -0,0 +1,83 @@ +--- +title: Intl.DateTimeFormat.prototype +slug: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/prototype +tags: + - DateTimeFormat + - Internationalization + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat +--- +<div>{{JSRef}}</div> + +<div>Die <strong><code>Intl.DateTimeFormat.prototype</code></strong> Eigenschaft ist ein Prototyp Objekt für den {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Konstruktor.</div> + +<div> </div> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Für eine Beschreibung von <code>Intl.DateTimeFormat</code> Instanzen siehe im Artikel {{jsxref("DateTimeFormat")}} nach.</p> + +<p>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Instanzen erben von <code>Intl.DateTimeFormat.prototype</code>. Änderungen in der Eigenschaft <code>prototype</code> wirken sich auf alle Instanzen von {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} aus.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Intl.DateTimeFormat.prototype.constructor</code></dt> + <dd>Eine Referenz zu {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.</dd> + <dt>{{jsxref("DateTimeFormat.format", "Intl.DateTimeFormat.prototype.format")}}</dt> + <dd>Getter, der eine Funktion, die für das Formatieren von Datums- und Zeitangaben nach den Optionen des {{jsxref("DateTimeFormat", "DateTimeFormat")}} ermöglicht, wird zurückgegeben.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("DateTimeFormat.formatToParts", "Intl.DateTimeFormat.prototype.formatToParts()")}}</dt> + <dd>Gibt ein {{jsxref("Array")}} von Objekten zurück, die den formatierten String in Teilen repräsentiert. Das kann eingesetzt werden, um ein benutzerdefiniertes Format zu erstellen.</dd> + <dt>{{jsxref("DateTimeFormat.resolvedOptions", "Intl.DateTimeFormat.prototype.resolvedOptions()")}}</dt> + <dd>Gibt ein neues Objekt mit den Eigenschaften der Sprache und des Formates zum Erstellungszeitpunkt des Objektes zurück.</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('ES Int 1.0', '#sec-12.2.1', 'Intl.DateTimeFormat.prototype')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-12.2.1', 'Intl.DateTimeFormat.prototype')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype', 'Intl.DateTimeFormat.prototype')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.DateTimeFormat.prototype")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html new file mode 100644 index 0000000000..a1403f9a7b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html @@ -0,0 +1,107 @@ +--- +title: Intl.DateTimeFormat.prototype.resolvedOptions() +slug: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/resolvedOptions +tags: + - DateTimeFormat + - Internationalization + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/resolvedOptions +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.DateTimeFormat.prototype.resolvedOptions()</code></strong> Methode gibt ein Objekt mit den Eigenschaften zum Gebiet und der Datums- und Zeitformatierung zurück, die beim der Initialisierung eines {{jsxref("DateTimeFormat", "DateTimeFormat")}} Objektes berechnet werden.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-resolvedoptions.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>dateTimeFormat</var>.resolvedOptions()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues Objekt mit den Eigenschaften zum Gebiet und der Datums- und Zeitformatierung, die beim der Initialisierung eines {{jsxref("DateTimeFormat", "DateTimeFormat")}} Objektes berechnet werden.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das resultierende Objekt hat die folgenden Eigenschaften:</p> + +<dl> + <dt><code>locale</code></dt> + <dd>Der BCP 47 Sprach-Tag für die genutzte Sprache. Wenn Unicode-Erweiterungen im BCP 47 Sprach-Tag enthalten waren, die für die Sprache unterstützt werden, sind die Unterstützen Schlüssel-Werte-Paare in <code>locale</code> enthalten.</dd> + <dt><code>calendar</code></dt> + <dt><code>numberingSystem</code></dt> + <dd>Dieser Wert wird durch die Unicode-Erweiterungsschlüssel <code>"ca"</code> und <code>"nu"</code> oder mit einem Standardwert gefüllt.</dd> + <dt><code>timeZone</code></dt> + <dd>Die Wert für die Unterstützen Eigenschaft im <code>options</code> Argument; {{jsxref("undefined")}} (entspricht der Standard-Zeitzone der Laufzeitumgebung), wenn keine verwendet wird. Warnung: Anwendungen sollten nicht auf den Rückgabewert {{jsxref("undefined")}} programmiert sein, weil es in zukünftigen Versionen sein kann, dass ein {{jsxref("String")}} zurückgegeben wird, der die Standard-Zeitzone der Laufzeitumgebung identifiziert.</dd> + <dt><code>hour12</code></dt> + <dd>Der Wert der verwendeten Eigenschaft im <code>options</code> Argument oder ein Standard-Wert.</dd> + <dt><code>weekday</code></dt> + <dt><code>era</code></dt> + <dt><code>year</code></dt> + <dt><code>month</code></dt> + <dt><code>day</code></dt> + <dt><code>hour</code></dt> + <dt><code>minute</code></dt> + <dt><code>second</code></dt> + <dt><code>timeZoneName</code></dt> + <dd>Die Werte resultieren von den Eigenschaften in dem <code>options</code> Argument und den möglichen Kombinationen und Repräsentationen der Datums- und Zeitformatierung aus der ausgewählte Sprache. Einige der Eigenschaften können auch fehlen, was bedeutet, dass die Komponenten nicht in der formatierten Ausgabe enthalten sind.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_resolvedOptions_Methode">Einsatz der <code>resolvedOptions</code> Methode</h3> + +<pre class="brush: js">var germanFakeRegion = new Intl.DateTimeFormat('de-XX', { timeZone: 'UTC' }); +var usedOptions = germanFakeRegion.resolvedOptions(); + +usedOptions.locale; // "de" +usedOptions.calendar; // "gregory" +usedOptions.numberingSystem; // "latn" +usedOptions.timeZone; // "UTC" +usedOptions.month; // "numeric" +</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('ES Int 1.0', '#sec-12.3.3', 'Intl.DateTimeFormat.prototype.resolvedOptions')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-Intl.DateTimeFormat.prototype.resolvedOptions', 'Intl.DateTimeFormat.prototype.resolvedOptions')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.resolvedOptions', 'Intl.DateTimeFormat.prototype.resolvedOptions')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.DateTimeFormat.resolvedOptions")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html new file mode 100644 index 0000000000..722b372745 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html @@ -0,0 +1,99 @@ +--- +title: Intl.DateTimeFormat.supportedLocalesOf() +slug: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/supportedLocalesOf +tags: + - DateTimeFormat + - Internationalization + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/supportedLocalesOf +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.DateTimeFormat.supportedLocalesOf()</code></strong> Methode gibt ein Array zurück, welches die Gebiete enthält, die die Datums- und Zeitformatierung unterstützen, ohne das auf das Laufzeitstandardgebeit zurückgegriffen werden muss.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-supportedlocalesof.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Intl.DateTimeFormat.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>locales</code></dt> + <dd>Ein String mit einem BCP 47 Sprachtag, oder ein Array von solchen Strings. Für die generelle Form des <code>locales</code> Arguments siehe die {{jsxref("Intl", "Intl Seite", "#Gebietsidentifikation_und_-verhandlung", 1)}}.</dd> + <dt><code>options</code></dt> + <dd> + <p>Optional. Ein Objekt, welches die folgende Eigenschaft haben kann:</p> + + <dl> + <dt><code>localeMatcher</code></dt> + <dd>Der Auswahlalgorithmus des Gebietes. Mögliche Werte sind <code>"lookup"</code> und <code>"best fit"</code>; der Standard ist <code>"best fit"</code>. Für mehr Information über diese Option siehe auf der {{jsxref("Intl", "Intl Seite", "#Gebietsauswahl", 1)}}.</dd> + </dl> + </dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Gibt ein Array zurück, welches eine Untermenge der gegebenen Gebiete enthält, für die die Datums- und Zeitformatierung unterstützen wird, ohne das auf das Laufzeitstandardgebeit zurückgegriffen werden muss.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Gibt ein Array zurück, welches eine Untermenge der gegebenen Gebiete (<code>locales</code>) enthält. Die Sprachtags, die zurückgegeben werden, unterstützen Datums- und Zeitformatierungen für das entsprechende Gebiet, ohne auf den Systemstandard zurückgreifen zu müssen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_supportedLocalesOf">Einsatz von <code>supportedLocalesOf</code></h3> + +<p>Angenommen wird, dass indonesische und deutsche Datums- und Zeitformatierung unterstützt wird, aber balinesisch nicht. <code>supportedLocalesOf</code> gibt das indonesische und deutsche Sprachtag unverändert zurück, obwohl Pinyin nicht mit Indonesisch verwendet wird und Fachdeutsch wahrscheinlich nicht für Indonesisch verfügbar ist. Zu bemerken ist, dass der <code>"lookup"</code> Algorithmus verwendet wird — der<code>"best-fit"</code> Algorithmus könnte entscheiden, dass Indonesisch eine angemessene Ergänzung für Balinesen ist, da die meisten Balinesen Indonesisch verstehen und daher auch das balinesische Sprachtag zurückgeben.</p> + +<pre class="brush: js">var locales = ['ban', 'id-u-co-pinyin', 'de-ID']; +var options = { localeMatcher: 'lookup' }; +console.log(Intl.DateTimeFormat.supportedLocalesOf(locales, options).join(', ')); +// → "id-u-co-pinyin, de-ID" +</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('ES Int 1.0', '#sec-12.2.2', 'Intl.DateTimeFormat.supportedLocalesOf')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-12.2.2', 'Intl.DateTimeFormat.supportedLocalesOf')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.supportedLocalesOf', 'Intl.DateTimeFormat.supportedLocalesOf')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.DateTimeFormat.supportedLocalesOf")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/getcanonicallocales/index.html b/files/de/web/javascript/reference/global_objects/intl/getcanonicallocales/index.html new file mode 100644 index 0000000000..0913ad7a6e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/getcanonicallocales/index.html @@ -0,0 +1,74 @@ +--- +title: Intl.getCanonicalLocales() +slug: Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales +tags: + - Internationalization + - Intl + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.getCanonicalLocales()</code></strong> Methode gibt ein Array mit den anerkannten Gebietsnamen zurück. Duplikate werden verhindert und Elemente werden auf valide Sprach-Tag-Struktur geprüft.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-getcanonicallocales.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Intl.getCanonicalLocales(locales)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>locales</code></dt> + <dd>Eine List von {{jsxref("String")}} Werten, von welchen die anerkannten Gebietsnamen gesucht werden.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein Array mit den anerkannten Gebietsnamen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Intl.getCanonicalLocales('EN-US'); // ["en-US"] +Intl.getCanonicalLocales(['EN-US', 'Fr']); // ["en-US", "fr"] + +Intl.getCanonicalLocales('EN_US'); +// RangeError:'EN_US' is not a structurally valid language tag +</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('ES Int Draft', '#sec-intl.getcanonicallocales', 'Intl.getCanonicalLocales')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>Initiale Definition</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.getCanonicalLocales")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}</li> + <li>{{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}</li> + <li>{{jsxref("Collator.supportedLocalesOf", "Intl.Collator.supportedLocalesOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/index.html b/files/de/web/javascript/reference/global_objects/intl/index.html new file mode 100644 index 0000000000..50567a9913 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/index.html @@ -0,0 +1,129 @@ +--- +title: Intl +slug: Web/JavaScript/Reference/Global_Objects/Intl +tags: + - Internationalization + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Intl +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Intl</code></strong> Objekt ist der Namensraum für die ECMAScript Internationalisierungs API, welche sprachenabhängige Stringvergleiche, Zahlenformate und Datums bzw. Zeitformate unterstützt. Der Konstruktoren für {{jsxref("Collator")}}, {{jsxref("NumberFormat")}} und {{jsxref("DateTimeFormat")}} Objekte sind Eigenschaften des <code>Intl</code> Objektes. <span id="result_box" lang="de"><span>Diese Seite dokumentiert diese Eigenschaften sowie die Funktionalität, die in Internationalisierungskonstruktoren und anderen sprachsensitiven Funktionen gemeinsam sind.</span></span></p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</dt> + <dd>Konstruktor für Collatoren, Objekte mit sprachsensitiven Stringvergleichen.</dd> + <dt>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</dt> + <dd>Konstruktor für Objekte, die Daten und Zeiten sprachsensitiv formatieren.</dd> + <dt>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</dt> + <dd>Konstruktor für Objekte, die Zahlen sprachsensitiv formatieren.</dd> + <dt>{{jsxref("Global_Objects/PluralRules", "Intl.PluralRules")}}</dt> + <dd>Konstruktor für Objekte, die mit Pluralsprachregeln pluralsensitiv formatieren kann.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Intl.getCanonicalLocales()")}}</dt> + <dd>Eine Methode, die den kanonischen Gebietsnamen zurückgibt.</dd> +</dl> + +<h2 id="Gebietsidentifikation_und_-verhandlung">Gebietsidentifikation und -verhandlung</h2> + +<p>Die Internationalisierungskonstruktoren genauso wie viele sprachsensitive Methoden von anderen Konstruktoren (aufgelistet unter {{anch("Siehe auch", "Siehe auch")}}) benutzten übliche Muster für die Identifizierung von Gebieten und der Feststellung des aktuellen Gebietes: Alle diese akzeptieren <code>locales</code> und <code>options</code> Parameter und verhandeln ein Gebiet aus den gesendeten Gebieten und den Lokal unterstützen Gebieten mithilfe eines Speziellen Algorithmus in der Eigenschaft <code>options.localeMatcher</code> aus.</p> + +<h3 id="locales_Argument"><code>locales</code> Argument</h3> + +<p>Das <code>locales</code> Argument muss entweder ein String sein, der einen <a href="http://tools.ietf.org/html/rfc5646">BCP 47 Sprachcode</a> enthält, oder ein Array mit solche Sprachcodes. Wenn dieses Argument nicht unterstützt ist oder <code>undefined</code> ist, wird das lokale Standardgebiet benutzt.</p> + +<p><span id="result_box" lang="de"><span>Ein BCP 47-Sprachcode definiert eine Sprache und enthält minimal einen primären Sprachcode</span></span>. <span id="result_box" lang="de"><span>In seiner gebräuchlichsten Form kann er folgender Reihenfolge enthalten: einen Sprachcode, einen Skriptcode und einen Länder- oder Regionscode, alle getrennt durch Bindestriche.</span></span> Weil diese Codes unabhängig von Groß- und Kleinschreibung ist, ist es empfohlen bei Skriptcodes den ersten Buchstaben groß zuschreiben, bei Länder- und Regionscodes soll alles groß geschrieben werden und der Rest soll klein geschreiben werden.</p> + +<p>Beispiele:</p> + +<ul> + <li><code>"hi"</code>: Hindi (primäre Sprache).</li> + <li><code>"de-AT"</code>: Deutsch wie es in Österreich genutzt wird (primäre Sprache mit Ländercode).</li> + <li><code>"zh-Hans-CN"</code>: Chinesisch geschrieben mit speziellen Zeichen, wie es in China genutzt wird (Primäre Sprache mit Skript- und Ländercode).</li> +</ul> + +<p>Die Subcodes zum identifizieren von Sprachen, Skripten, Ländern (Regionen) und (selten genutzen) Varianten in BCP 47 Sprachcodes können im <a href="http://www.iana.org/assignments/language-subtag-registry">IANA Sprach Subtag Register</a> gefunden werden.</p> + +<p>BCP 47 erlaubt sogar Erweiterungen. JavaScript Internationalisierungsfunktionen benutzen die <code>"u"</code> (Unicode) Erweiterung, welche es ermöglicht benutzerdefinierte Änderungen in {{jsxref("Collator")}}, {{jsxref("NumberFormat")}} oder {{jsxref("DateTimeFormat")}} einzubringen. Beispiele:</p> + +<ul> + <li><code>"de-DE-u-co-phonebk"</code>: Benutzt die Telefonbuch-Variante der deutschen Sortierreihenfolge, welche Umlaute zu Paaren übersetzt: ä → ae, ö → oe, ü → ue.</li> + <li><code>"th-TH-u-nu-thai"</code>: Benutzt Thei-Zeichen(๐, ๑, ๒, ๓, ๔, ๕, ๖, ๗, ๘, ๙) im Nummernformat.</li> + <li><code>"ja-JP-u-ca-japanese"</code>: Benutzt den Japanischen Kalender für Datums- und Zeitformate, so dass 2013 als Jahr 25 der Heisei Periode ist oder 平成25.</li> + <li><code>"en-GB-u-ca-islamic"</code>: Benutzt Britisches Englisch mit dem Islamic (Hijri) Kalender, indem das gregorianische Datum 14. Oktober 2017 das Hijri Datum 24 Muharram, 1439 ist.</li> +</ul> + +<h3 id="Gebietsauswahl">Gebietsauswahl</h3> + +<p>Das <code>locales</code> Argument wird als priorisierte Angabe für die Applikation interpretiert, nach dem alle Unicode-Erweiterungen durchführt wurden. Zur Laufzeut wird gegeben verfügbare Gebiete verglichen und das am besten passende genommen. Es existieren zwei Algorithmen für die Auswahl: die <code>"lookup"</code> Auswahl, die dem im <a href="http://tools.ietf.org/html/rfc4647#section-3.4">BCP 47</a> spezifizierten Algorithmus folgt; die <code>"best fit"</code> Auswahl, bei dem die Laufzeigumgebung mindestens einen gleichgutes Ergebnis wie der Lookup Algorithmus erzielt, wenn nicht sogar einen besseren. Wenn die Applikation kein <code>locales</code> Argument unterstützt oder die Laufzeit kein Gebiet hat, welches passt, dann wird das Standardgebiet der Laufzeitumgebung werdendet. Das Algorithmus zur Auswahl kann über das <code>options</code> Argument ausgewählt werden (siehe unten).</p> + +<p>Wenn der ausgewählte Sprache-Tag eine Unicode Erweiterung hat, wird diese genutzt, um das erstellte Objekte oder das Verhalten der Funktion anzupassen. Jeder Konstruktor oder jede Funktion unterstützt nur eine Untermenge der als Unicode Erweiterungen definierten Schlüssel und die unterstützen Werte sind meistens von Sprach-Tag abhängig. Zum Beispiel ist der <code>"co"</code> Schlüssel (collation) nur in {{jsxref("Collator")}} unterstützt und der <code>"phonebk"</code> Wert ist nur im Deutschen unterstützt.</p> + +<h3 id="options_Argument"><code>options</code> Argument</h3> + +<p>Das <code>options</code> Argument muss ein Objekt mit Eigenschaften sein, welche vom Konstruktor und der Funktion abhängen. Wenn das <code>options</code> Argument nicht unterstützt wird oder <code>undefined</code> ist, werden Standardwerte für alle Eigenschaften benutzt.</p> + +<p>Eine Eigenschaft ist in allen sprachensensitiven Konstruktoren und Funktionen forhanden: Die <code>localeMatcher</code> Eigenschaft, die vom Datentyp String ist und den Wert <code>"lookup"</code> oder <code>"best fit"</code> hat, welche den Algorithmus für die Auswahl des Gebietes beschreiben (siehe oben).</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('ES Int 1.0', '#sec-8', 'Intl')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-8', 'Intl')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#intl-object', 'Intl')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>Intl.getCanonicalLocales in the 4. Auflage hinzugefügt.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>Einführung: <a href="http://norbertlindenberg.com/2012/12/ecmascript-internationalization-api/index.html">The ECMAScript Internationalization API</a></li> + <li>Konstruktoren + <ul> + <li>{{jsxref("Collator", "Intl.Collator")}}</li> + <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li> + </ul> + </li> + <li>Methoden + <ul> + <li>{{jsxref("String.prototype.localeCompare()")}}</li> + <li>{{jsxref("Number.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + </ul> + </li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/numberformat/format/index.html b/files/de/web/javascript/reference/global_objects/intl/numberformat/format/index.html new file mode 100644 index 0000000000..4d42272e9c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/numberformat/format/index.html @@ -0,0 +1,98 @@ +--- +title: Intl.NumberFormat.prototype.format +slug: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/format +tags: + - Internationalization + - JavaScript + - NumberFormat + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/format +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.NumberFormat.prototype.format</code></strong> Eigenschaft gibt eine Getterfunktion zurück, die eine Zahl nach den Sprach- und Formatierungsoptionen dieses {{jsxref("NumberFormat")}} Objektes formatiert.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-format.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>numberFormat</var>.format(<var>number</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>number</code></dt> + <dd>Zahl, die formatiert werden soll.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die Funktion, die von <code>format</code> Getter zurückgegeben wird, formatiert eine Zahl in einen String nach den angegebenen Sprach- und Formatierungsoptionen des {{jsxref("NumberFormat")}} Objektes.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_format">Einsatz von <code>format</code></h3> + +<p>Einsatz der vom <code>format</code> Getter zurückgegebenen Funktion zum Formatieren eines Währungswertes, hier für Russland:</p> + +<pre class="brush: js">var options = { style: 'currency', currency: 'RUB' }; +var numberFormat = new Intl.NumberFormat('ru-RU', options); +console.log(numberFormat.format(654321.987)); +// → "654 321,99 руб." +</pre> + +<h3 id="Einsatz_format_mit_map">Einsatz <code>format</code> mit <code>map</code></h3> + +<p>Einsatz der vom <code>format</code> Getter zurückgegebenen Funktion zum Formatieren von allen Zahlen in einem Array. Zu bemerken ist, dass die Funktion an das {{jsxref("NumberFormat")}} Objekt gebunden ist, von dem sie stammt, so dass es direkt in {{jsxref("Array.prototype.map")}} verwendet werden kann.</p> + +<pre class="brush: js">var a = [123456.789, 987654.321, 456789.123]; +var numberFormat = new Intl.NumberFormat('es-ES'); +var formatted = a.map(numberFormat.format); +console.log(formatted.join('; ')); +// → "123.456,789; 987.654,321; 456.789,123" +</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('ES Int 1.0', '#sec-11.3.2', 'Intl.NumberFormat.prototype.format')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-11.3.2', 'Intl.NumberFormat.prototype.format')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype.format', 'Intl.NumberFormat.prototype.format')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.NumberFormat.format")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li> + <li>{{jsxref("Number.prototype.toLocaleString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/numberformat/index.html b/files/de/web/javascript/reference/global_objects/intl/numberformat/index.html new file mode 100644 index 0000000000..b2881e081d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/numberformat/index.html @@ -0,0 +1,195 @@ +--- +title: Intl.NumberFormat +slug: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat +tags: + - Internationalization + - JavaScript + - NumberFormat +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Intl.NumberFormat</code></strong> Objekt ist ein Konstruktor für Objekte, die sprachabhängige Zahlenformatierungen nutzen.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-numberformat.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new Intl.NumberFormat([<var>locales</var>[, <var>options</var>]]) +Intl.NumberFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]]) +</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>locales</code></dt> + <dd>Optional. Ein String mit einem BCP 47 Sprachcode, oder ein Array mit solchen Strings. Für die generelle Form und Interpretation des <code>locales</code> Arguments siehe im {{jsxref("Intl", "Intl Artikel", "#Locale_identification_and_negotiation", 1)}}. Die folgenden Unicode Erweiterungsschlüssel sind erlaubt:</dd> + <dd> + <dl> + <dt><code>nu</code></dt> + <dd>Das einzusetzende Nummerierungssystem. Mögliche Wert sind:<code> "arab"</code>, <code>"arabext"</code>, <code>"bali"</code>, <code>"beng"</code>, <code>"deva"</code>, <code>"fullwide"</code>, <code>"gujr"</code>, <code>"guru"</code>, <code>"hanidec"</code>, <code>"khmr"</code>, <code>"knda"</code>, <code>"laoo"</code>, <code>"latn"</code>, <code>"limb"</code>, <code>"mlym"</code>, <code>"mong"</code>, <code>"mymr"</code>, <code>"orya"</code>, <code>"tamldec"</code>, <code>"telu"</code>, <code>"thai"</code>, <code>"tibt"</code>.</dd> + </dl> + </dd> + <dt><code>options</code></dt> + <dd> + <p>Optional. Ein Objekt mit einigen oder allen der folgenden Eigenschaften:</p> + + <dl> + <dt><code>localeMatcher</code></dt> + <dd>Der Spracherkennungsalgorithmus. Mögliche Werte sind <code>"lookup"</code> und <code>"best fit"</code>. Der Standardwert ist <code>"best fit"</code>. Für mehr Informationen siehe in den {{jsxref("Intl", "Intl Artikel", "#Locale_negotiation", 1)}}.</dd> + <dt><code>style</code></dt> + <dd>Der einzusetzende Formatierungsstil. Mögliche Werte sind <code>"decimal"</code> für einfache Zahlenformate, <code>"currency"</code> für Währungen, <code>"percent"</code> für Prozentzahlen. Der Standardwert ist <code>"decimal"</code>.</dd> + <dt><code>currency</code></dt> + <dd>Die bei der Währungsformatierung einzusetzende Währung. Mögliche Werte sind die ISO 4217 Währungscodes wie zum Beispiel <code>"USD"</code> für US Dollar, <code>"EUR"</code> für Euro und <code>"CNY"</code> für Chinesischen RMB (siehe <a href="http://www.currency-iso.org/en/home/tables/table-a1.html">Current currency & funds code list</a>). Es gibt keinen Standardwert. Wenn <code>style</code> auf <code>"currency"</code> gesetzt ist, muss die <code>currency</code> Eigenschaft gesetzt werden.</dd> + <dt><code>currencyDisplay</code></dt> + <dd>Währungsanzeige im String. Mögliche Werte sind <code>"symbol"</code> für lokalisierte Währungssymbole wie zum Beispiel €, <code>"code"</code> für ISO Währungscodes, <code>"name"</code> für den Namen der Währung wie zum Beispiel <code>"dollar"</code>. Der Standardwert ist <code>"symbol"</code>.</dd> + <dt><code>useGrouping</code></dt> + <dd>Gruppierung der Zahl. Wird für das Ein- und Ausschalten der Tausendertrenner oder thousand/lakh/crore-Trenner eingesetzt. Mögliche Werte sind <code>true</code> und <code>false</code>. Der Standardwert ist <code>true</code>.</dd> + </dl> + + <p>Die folgenden Eingeschaften fallen in zwei Gruppen: <code>minimumIntegerDigits</code>, <code>minimumFractionDigits</code>, und <code>maximumFractionDigits</code> in einer Gruppe, <code>minimumSignificantDigits</code> und <code>maximumSignificantDigits</code> in der anderen. Wenn nur eine Eigenschaft der zweiten Gruppe genutzt wird, wird die erste Gruppe ignoriert.</p> + + <dl> + <dt><code>minimumIntegerDigits</code></dt> + <dd>Die minimale Anzahl von Ganzzahl Ziffern. Mögliche Werte sind zwischen 1 und 21. Der Standardwert ist 1.</dd> + <dt><code>minimumFractionDigits</code></dt> + <dd>Die minimale Anzahl von Nachkommastellen. Mögliche Werte sind zwischen 0 und 20. Der Standardwert für Zahlen und Prozentzahlen ist 0. Der Standard für Währungen ist die Anzahl der Stellen für die Untereinheit der Währung, die eingesetzt wird (<a href="http://www.currency-iso.org/en/home/tables/table-a1.html">ISO 4217 currency code list</a>) oder 2, wenn die Währung nicht unterstützt wird.</dd> + <dt><code>maximumFractionDigits</code></dt> + <dd>Die Maximale Anzahl von Nachkommastellen. Mögliche Werte sind zwischen 0 und 20. Der Standardwert für einfache Zahlen ist die größere Zahl von <code>minimumFractionDigits</code> und <code>3</code>. Der Standardwert für Währungen ist der größere von <code>minimumFractionDigits</code> und der Anzahl der Stellen für die Untereinheit der Währung oder 2 wenn die Währung nicht unterstützt wird. Der Standardwert für Prozentzahlen ist die größere Zahl von <code>minimumFractionDigits</code> und <code>0</code>.</dd> + <dt><code>minimumSignificantDigits</code></dt> + <dd>Die minimale Anzahl von signifikanten Stellen. Mögliche Werte sind zwischen 1 und 21. Der Standardwert ist 1.</dd> + <dt><code>maximumSignificantDigits</code></dt> + <dd>Die maximale Anzahl von signifikanten Stellen. Mögliche Werte sind zwischen 1 und 21. Der Standardwert ist <code>minimumSignificantDigits</code>.</dd> + </dl> + </dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<h3 id="Eigenschaften">Eigenschaften</h3> + +<dl> + <dt>{{jsxref("NumberFormat.prototype", "Intl.NumberFormat.prototype")}}</dt> + <dd>Erlaubt das Hinzufügen von Eigenschaften zu allen Objekten.</dd> +</dl> + +<h3 id="Methoden">Methoden</h3> + +<dl> + <dt>{{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}</dt> + <dd>Gibt ein Array zurück, welches alle Sprachen enthält, die unterstützt werden, ohne auf den Laufzeitstandard zurückzufallen (ohne fallback).</dd> +</dl> + +<h2 id="NumberFormat_Instanzen"><code>NumberFormat</code> Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<p><code>NumberFormat</code> Instanzen erben die folgenden Eigenschaften von ihrem Prototyp:</p> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<p><code>NumberFormat</code> Instanzen erben die folgenden Methoden von ihrem Prototyp:</p> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype', 'Methoden')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Standardeinsatz">Standardeinsatz</h3> + +<p>Beim Einsatz ohne spezifizierte Sprache wird ein formatierter String in der Standardsprache und mit Standardoptionen zurückgegeben:</p> + +<pre class="brush: js">var number = 3500; + +console.log(new Intl.NumberFormat().format(number)); +// → '3.500' wenn in Deutscher Sprache +</pre> + +<h3 id="Einsatz_von_locales">Einsatz von <code>locales</code></h3> + +<p>Diese Beispiel zeigt einige der Variationen lokalisierter Zahlenformate. Um das Format der Sprache zu erhalten, 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(new Intl.NumberFormat('en-GB').format(number)); +// → 123.456,789 + +// Arabisch ist in den meisten arabisch sprachigen Ländern eingesetzt +console.log(new Intl.NumberFormat('ar-EG').format(number)); +// → ١٢٣٤٥٦٫٧٨٩ + +// Indien benutzt Tausendertrennzeichen bei Tausend und allen weiteren <strong>zwei Stellen</strong> +console.log(new Intl.NumberFormat('en-IN').format(number)); +// → 1,23,456.789 + +// Chinesisches Zahlensystem +console.log(new Intl.NumberFormat('zh-Hans-CN-u-nu-hanidec').format(number)); +// → 一二三,四五六.七八九 + +// Wenn eine Sprache übergeben werden soll, die vielleicht nicht +// unterstützt wird (Balinesisch), nutze eine fallback Sprache (Indonesisch) +console.log(new Intl.NumberFormat(['ban', 'id']).format(number)); +// → 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(new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(number)); +// → 123.456,79 € + +// Der Japanische Yen hat keine Unterwährung (z. B. Cent) +console.log(new Intl.NumberFormat('ja-JP', { style: 'currency', currency: 'JPY' }).format(number)); +// → ￥123,457 + +// Limitiert auf drei signifikante Stellen +console.log(new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).format(number)); +// → 1,23,000 +</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('ES Int 1.0', '#sec-11.1', 'Intl.NumberFormat')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-11.1', 'Intl.NumberFormat')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#numberformat-objects', 'Intl.NumberFormat')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.NumberFormat")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<p>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Intl', 'Siehe auch')}}</p> diff --git a/files/de/web/javascript/reference/global_objects/intl/numberformat/prototype/index.html b/files/de/web/javascript/reference/global_objects/intl/numberformat/prototype/index.html new file mode 100644 index 0000000000..aa10caf254 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/numberformat/prototype/index.html @@ -0,0 +1,81 @@ +--- +title: Intl.NumberFormat.prototype +slug: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/prototype +tags: + - Internationalization + - JavaScript + - NumberFormat + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.NumberFormat.prototype</code></strong> Eigenschaft repräsentiert das Prototypobjekt für einen {{jsxref("NumberFormat", "Intl.NumberFormat")}} Konstruktor.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Siehe {{jsxref("NumberFormat")}} für eine Beschreibung von <code>Intl.NumberFormat</code> Instanzen.</p> + +<p>{{jsxref("NumberFormat", "Intl.NumberFormat")}} Instanzen erben von <code>Intl.NumberFormat.prototype</code>. Veränderungen am Prototypobjekt werden an alle {{jsxref("NumberFormat", "Intl.NumberFormat")}} Instanzen vererbt.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Intl.NumberFormat.prototype.constructor</code></dt> + <dd>Eine Referenz zu <code>Intl.NumberFormat</code>.</dd> + <dt>{{jsxref("NumberFormat.format", "Intl.NumberFormat.prototype.format")}}</dt> + <dd>Getter; gibt eine Funktion zurück, die eine Zahl nach den Sprach- und Formatierungsoptionen dieses {{jsxref("NumberFormat")}} Objektes formatiert.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("NumberFormat.formatToParts", "Intl.NumberFormat.prototype.formatToParts()")}}</dt> + <dd>Gibt ein {{jsxref("Array")}} mit Objekten zurück, welche die Repräsentation des Zahlenstrings in Teilen enthalten, die für sprachsicheres Formatieren genutzt werden können.</dd> + <dt>{{jsxref("NumberFormat.resolvedOptions", "Intl.NumberFormat.prototype.resolvedOptions()")}}</dt> + <dd>Gibt ein neues Objekt mit eigenschaften zurück, die Sprach- und Formatierungsoptionen enthält, die bei der Initialisierung des Objektes errechnet wurden.</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">Komment</th> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype', 'Intl.NumberFormat.prototype')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.NumberFormat.prototype")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html b/files/de/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html new file mode 100644 index 0000000000..2521267a18 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html @@ -0,0 +1,98 @@ +--- +title: Intl.NumberFormat.supportedLocalesOf() +slug: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/supportedLocalesOf +tags: + - Internationalization + - JavaScript + - Method + - NumberFormat +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/supportedLocalesOf +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.NumberFormat.supportedLocalesOf()</code></strong> Methode gibt ein Array zurück, welches die Gebiete enthält, die die Zahlenformatierung unterstützen, ohne das auf das Laufzeitstandardgebiet zurückgegriffen werden muss.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-supportedlocalesof.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Intl.NumberFormat.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>locales</code></dt> + <dd>Ein String mit einem BCP 47 Sprachtag, oder ein Array von solchen Strings. Für die generelle Form des <code>locales</code> Arguments siehe die {{jsxref("Intl", "Intl Seite", "#Gebietsidentifikation_und_-verhandlung", 1)}}.</dd> + <dt><code>options</code></dt> + <dd> + <p>Optional. Ein Objekt, welches die folgende Eigenschaft haben kann:</p> + + <dl> + <dt><code>localeMatcher</code></dt> + <dd>Der Auswahlalgorithmus des Gebietes. Mögliche Werte sind <code>"lookup"</code> und <code>"best fit"</code>; der Standard ist <code>"best fit"</code>. Für mehr Information über diese Option siehe auf der {{jsxref("Intl", "Intl Seite", "#Gebietsauswahl", 1)}}.</dd> + </dl> + </dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Gibt ein Array zurück, welches eine Untermenge der gegebenen Gebiete enthält, für die die Zahlenformatierung unterstützen wird, ohne das auf das Laufzeitstandardgebeit zurückgegriffen werden muss.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Gibt ein Array zurück, welches eine Untermenge der gegebenen Gebiete (<code>locales</code>) enthält. Die Sprachtags, die zurückgegeben werden, unterstützen Zahlenformatierungen für das entsprechende Gebiet, ohne auf den Systemstandard zurückgreifen zu müssen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_supportedLocalesOf">Einsatz von <code>supportedLocalesOf</code></h3> + +<p>Angenommen wird, dass indonesische und deutsche Zahlenformatierung unterstützt wird, aber balinesisch nicht. <code>supportedLocalesOf</code> gibt das indonesische und deutsche Sprachtag unverändert zurück, obwohl Pinyin nicht mit Indonesisch verwendet wird und Fachdeutsch wahrscheinlich nicht für Indonesisch verfügbar ist. Zu bemerken ist, dass der <code>"lookup"</code> Algorithmus verwendet wird — der<code>"best-fit"</code> Algorithmus könnte entscheiden, dass Indonesisch eine angemessene Ergänzung für Balinesen ist, da die meisten Balinesen Indonesisch verstehen und daher auch das balinesische Sprachtag zurückgeben.</p> + +<pre class="brush: js">var locales = ['ban', 'id-u-co-pinyin', 'de-ID']; +var options = { localeMatcher: 'lookup' }; +console.log(Intl.NumberFormat.supportedLocalesOf(locales, options).join(', ')); +// → "id-u-co-pinyin, de-ID" +</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('ES Int 1.0', '#sec-11.2.2', 'Intl.NumberFormat.supportedLocalesOf')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-11.2.2', 'Intl.NumberFormat.supportedLocalesOf')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.supportedLocalesOf', 'Intl.NumberFormat.supportedLocalesOf')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.NumberFormat.supportedLocalesOf")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/intl/pluralrules/index.html b/files/de/web/javascript/reference/global_objects/intl/pluralrules/index.html new file mode 100644 index 0000000000..fe646e4772 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/pluralrules/index.html @@ -0,0 +1,161 @@ +--- +title: Intl.PluralRules +slug: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules +tags: + - Internationalization + - Intl + - JavaScript + - NeedsTranslation + - PluralRules + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules +--- +<div>{{JSRef}}</div> + +<p>The <strong><code>Intl.PluralRules</code></strong> object is a constructor for objects that enable plural sensitive formatting and plural language language rules.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new Intl.PluralRules([<var>locales</var>[, <var>options</var>]]) +Intl.PluralRules.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]]) +</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>locales</code></dt> + <dd> + <p>Optional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the <code>locales</code> argument, see the {{jsxref("Intl", "Intl page", "#Locale_identification_and_negotiation", 1)}}.</p> + </dd> + <dt><code>options</code></dt> + <dd> + <p>Optional. An object with some or all of the following properties:</p> + + <dl> + <dt><code>localeMatcher</code></dt> + <dd>The locale matching algorithm to use. Possible values are <code>"lookup"</code> and <code>"best fit"</code>; the default is <code>"best fit"</code>. For information about this option, see the {{jsxref("Global_Objects/Intl", "Intl page", "#Locale_negotiation", 1)}}.</dd> + <dt><code>type</code></dt> + <dd>The type to use. Possible values are: + <ul> + <li><code>"cardinal"</code> for cardinal numbers (refering to the quantity of things). This is the default value.</li> + <li><code>"ordinal"</code> for ordinal number (refering to the ordering or ranking of things, e.g. "1st", "2nd", "3rd" in English).</li> + </ul> + </dd> + </dl> + </dd> +</dl> + +<h2 id="Description">Description</h2> + +<h3 id="Properties">Properties</h3> + +<dl> + <dt>{{jsxref("PluralRules.prototype", "Intl.PluralRules.prototype")}}</dt> + <dd>Allows the addition of properties to all objects.</dd> +</dl> + +<h3 id="Methods">Methods</h3> + +<dl> + <dt>{{jsxref("PluralRules.supportedLocalesOf", "Intl.PluralRules.supportedLocalesOf()")}}</dt> + <dd>Returns an array containing those of the provided locales that are supported without having to fall back to the runtime's default locale.</dd> +</dl> + +<h2 id="PluralRules_instances"><code>PluralRules</code> instances</h2> + +<h3 id="Properties_2">Properties</h3> + +<p><code>PluralRules</code> instances inherit the following properties from their prototype:</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules/prototype', 'Properties')}}</div> + +<h3 id="Methods_2">Methods</h3> + +<p><code>PluralRules</code> instances inherit the following methods from their prototype:</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules/prototype', 'Methods')}}</div> + +<h2 id="Examples">Examples</h2> + +<h3 id="Basic_usage">Basic usage</h3> + +<p>In basic use without specifying a locale, a formatted string in the default locale and with default options is returned. This is useful to distinguish between singular and plural forms, e.g. "dog" and "dogs".</p> + +<pre class="brush: js">var pr = new Intl.PluralRules(); + +pr.select(0); +// → 'other' if in US English locale + +pr.select(1); +// → 'one' if in US English locale + +pr.select(2); +// → 'other' if in US English locale +</pre> + +<h3 id="Using_locales">Using <code>locales</code></h3> + +<p>This example shows some of the variations in localized plural rules. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the <code>locales</code> argument:</p> + +<pre class="brush: js">// Arabic has different plural rules + +new Intl.PluralRules('ar-EG').select(0); +// → 'zero' +new Intl.PluralRules('ar-EG').select(1); +// → 'one' +new Intl.PluralRules('ar-EG').select(2); +// → 'two' +new Intl.PluralRules('ar-EG').select(6); +// → 'few' +new Intl.PluralRules('ar-EG').select(18); +// → 'many' +</pre> + +<h3 id="Using_options">Using <code>options</code></h3> + +<p>The results can be customized using the <code>options</code> argument, which has one property called <code>type</code> which you can set to <code>ordinal</code>. This is useful to figure out the ordinal indicator, e.g. "1st", "2nd", "3rd", "4th", "42nd" and so forth.</p> + +<pre class="brush: js">var pr = new Intl.PluralRules('en-US', { type: 'ordinal' }); + +pr.select(0); +// → 'other' +pr.select(1); +// → 'one' +pr.select(2); +// → 'two' +pr.select(3); +// → 'few' +pr.select(4); +// → 'other' +pr.select(42); +// → 'two' +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td><a href="https://rawgit.com/caridy/intl-plural-rules-spec/master/index.html">Intl Plural Rules Draft</a></td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>Initial definition</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.PluralRules")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl', 'See_also')}}</div> diff --git a/files/de/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.html b/files/de/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.html new file mode 100644 index 0000000000..a33eac3e76 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.html @@ -0,0 +1,85 @@ +--- +title: Intl.PluralRules.supportedLocalesOf() +slug: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/supportedLocalesOf +tags: + - Internationalization + - Intl + - JavaScript + - Method + - PluralRules +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/supportedLocalesOf +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Intl.PluralRules.supportedLocalesOf()</code></strong> Methode gibt ein Array zurück, welches die Gebiete enthält, die die Pluralformatierung unterstützen, ohne das auf das Laufzeitstandardgebeit zurückgegriffen werden muss.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Intl.PluralRules.supportedLocalesOf(<var>locales</var>[, <var>options</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>locales</code></dt> + <dd>Ein String mit einem BCP 47 Sprachtag, oder ein Array von solchen Strings. Für die generelle Form des <code>locales</code> Arguments siehe die {{jsxref("Intl", "Intl Seite", "#Gebietsidentifikation_und_-verhandlung", 1)}}.</dd> + <dt><code>options</code></dt> + <dd> + <p>Optional. Ein Objekt, welches die folgende Eigenschaft haben kann:</p> + + <dl> + <dt><code>localeMatcher</code></dt> + <dd>Der Auswahlalgorithmus des Gebietes. Mögliche Werte sind <code>"lookup"</code> und <code>"best fit"</code>; der Standard ist <code>"best fit"</code>. Für mehr Information über diese Option siehe auf der {{jsxref("Intl", "Intl Seite", "#Gebietsauswahl", 1)}}.</dd> + </dl> + </dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Gibt ein Array zurück, welches eine Untermenge der gegebenen Gebiete enthält, für die die Pluralformatierung unterstützen wird, ohne das auf das Laufzeitstandardgebeit zurückgegriffen werden muss.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Gibt ein Array zurück, welches eine Untermenge der gegebenen Gebiete (<code>locales</code>) enthält. Die Sprachtags, die zurückgegeben werden, unterstützen Zahlenformatierungen für das entsprechende Gebiet, ohne auf den Systemstandard zurückgreifen zu müssen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_supportedLocalesOf">Einsatz von <code>supportedLocalesOf</code></h3> + +<p>Angenommen wird, dass indonesische und deutsche Pluralformatierung unterstützt wird, aber balinesisch nicht. <code>supportedLocalesOf</code> gibt das indonesische und deutsche Sprachtag unverändert zurück, obwohl Pinyin nicht mit Indonesisch verwendet wird und Fachdeutsch wahrscheinlich nicht für Indonesisch verfügbar ist. Zu bemerken ist, dass der <code>"lookup"</code> Algorithmus verwendet wird — der<code>"best-fit"</code> Algorithmus könnte entscheiden, dass Indonesisch eine angemessene Ergänzung für Balinesen ist, da die meisten Balinesen Indonesisch verstehen und daher auch das balinesische Sprachtag zurückgeben.</p> + +<pre class="brush: js">var locales = ['ban', 'id-u-co-pinyin', 'de-ID']; +var options = { localeMatcher: 'lookup' }; +console.log(Intl.PluralRules.supportedLocalesOf(locales, options).join(', ')); +// → "id-u-co-pinyin, de-ID" +</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><a href="https://rawgit.com/caridy/intl-plural-rules-spec/master/index.html">Intl Plural Rules Draft</a></td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>Initiale Definition</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.PluralRules.supportedLocalesOf")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("PluralRules", "Intl.PluralRules")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/isfinite/index.html b/files/de/web/javascript/reference/global_objects/isfinite/index.html new file mode 100644 index 0000000000..c947c8cbf8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/isfinite/index.html @@ -0,0 +1,99 @@ +--- +title: isFinite() +slug: Web/JavaScript/Reference/Global_Objects/isFinite +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/isFinite +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die globale Funktion <code><strong>isFinite()</strong></code> prüft, ob eine Zahl endlich ist oder nicht. Wenn der übergeben Wert keine Nummer ist, wird dieser zuerst konvertiert.</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-isfinite.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox">isFinite(<em>testWert</em>)</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>test</code>Wert</dt> + <dd>Wert, der auf <span class="dpf_sent" id="dpfsent_2">Endlichkeit </span>geprüft wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><strong><code>false</code></strong> wenn der Wert positiv {{jsxref("Infinity")}}, negativ {{jsxref("Infinity")}} or {{jsxref("NaN")}} ist, andernfalls <strong><code>true</code></strong>.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>isFinite</code> ist eine <span class="dpf_sent" id="dpfsent_1">Toplevel-</span>Funktion und ist nicht mit einem Objekt verbunden.</p> + +<p>Man kann die Funktion nutzen, um eine Nummer auf Endlichkeit zu prüfen. Die <code>isFinite</code> Funktion prüft die Zahl, die ihr als Parameter mit übergeben wird. Wenn der Wert der Zahl {{jsxref("Global_Objects/NaN", "NaN")}}, positiv {{jsxref("Global_Objects/Infinity", "infinity")}} oder negativ {{jsxref("Global_Objects/Infinity", "infinity")}} ist, so ist der Rückgabewert <code>false</code>; andernfalls <code>true</code>.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<pre class="brush: js">isFinite(Infinity); // false +isFinite(NaN); // false +isFinite(-Infinity); // false + +isFinite(0); // true +isFinite(2e64); // true +isFinite(null); // true + +isFinite(null) // true, würde false sein, wenn die robustere + // Methode Number.isFinite(null) eingesetzt wird. + +isFinite('0'); // true, würde false sein, wenn die robustere + // Methode Number.isFinite('0') eingesetzt wird. +</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.2.5', 'isFinite')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-isfinite-number', 'isFinite')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-isfinite-number', 'isFinite')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.isFinite")}}</p> + +<h2 id="See_Also" name="See_Also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Number.NaN")}}</li> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/isnan/index.html b/files/de/web/javascript/reference/global_objects/isnan/index.html new file mode 100644 index 0000000000..328ef94557 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/isnan/index.html @@ -0,0 +1,192 @@ +--- +title: isNaN() +slug: Web/JavaScript/Reference/Global_Objects/isNaN +tags: + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/isNaN +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die <code><strong>isNaN()</strong></code> Methode prüft, ob ein Wert {{jsxref("NaN")}} ist. Bemerkung: Aufgrund innerer Zwänge weist die <code>isNaN</code> Methode <a href="#Description">interessante</a> Regeln auf. Alternativ kann die in ECMAScript 2015 definierte Methode {{jsxref("Number.isNaN()")}} genutzt werden.</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-isnan.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>isNaN(<em>testWert</em>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>testWert</code></dt> + <dd>Der zu testende Wert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><strong><code>true</code></strong> wenn der gegebene Wert {{jsxref("NaN")}} ist, andernfalls <strong><code>false</code></strong>.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<h3 id="The_necessity_of_an_isNaN_function" name="The_necessity_of_an_isNaN_function">Die notwendigkeit einer <code>isNaN Methode</code></h3> + +<p>Anders als bei allen anderen Werten in JavaScript, ist es nicht möglich mit den Gleichheitsoperatoren ({{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} and {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}) zu prüfen, ob ein Wert {{jsxref("NaN")}} ist oder nicht. <code>NaN == NaN</code> und <code>NaN === NaN</code> werden zu <code>false </code>ausgewertet. Aus diesem Grund wird eine <code>isNaN</code> Methode benötigt. </p> + +<h3 id="Origin_of_NaN_values" name="Origin_of_NaN_values">Ursprünge des <code>NaNWertes</code></h3> + +<p><code>NaN</code> Werte werden generiert, wenn das Ergebnis einer arithmetischen Operation ein undefinierter Wert oder ein nicht repräsentierbarer Wert ist. Diese Werte entsprechen nicht unbedingt dem Überlauf von Wertebereichen. Ein <code>NaN</code> Ergebnis kann ebenfalls entstehen, wenn es für eine Operation keine primitive Zahl als Darstellung gibt.</p> + +<p>Beispielsweise ist das Ergebnis einer Division von null durch null <code>NaN</code>. Jedoch ist das Ergebnis nicht <code>NaN</code> wenn andere Zahlen durch null geteilt werden.</p> + +<h3 id="Verwirrende_Spezialfälle">Verwirrende Spezialfälle</h3> + +<p>Schon seit den frühesten Versionen der <code>isNaN</code> Methodendefinition ist das Verhalten für nicht numerische Typen nicht trivial. Wenn der zu überprüfende Wert nicht vom Typ <a href="http://es5.github.com/#x8.5" title="http://es5.github.com/#x8.5">Number</a> ist, so wird dieser Wert zuerst in den Typ <a href="http://es5.github.com/#x8.5" title="http://es5.github.com/#x8.5">Number</a> konvertiert. Erst dann wird geprüft, ob der Wert {{jsxref("NaN")}} ist. Weil einige nicht numerischen Werte trotzdem als Zahlen interpretiert werden können (leere Strings und Werte vom Typ boolean können als Nullen und Einsen dargestellt werden) ist das <code>false</code>-Resultat der Funktion manchmal unerwartet. Der leere String ist ein Beispiel dafür, weil dieser definitiv keine Nummer ist. Das verwirrende ist jedoch dass "not a number" eine spezielle Repräsentation in den IEEE-754 Gleitkommazahlen besitzt. Aus diesem Grund kann die Methode so interpretiert werden, dass sie die Antwort auf die Frage gibt, ob ein Wert, der als Nummer interpretiert wird, eine IEEE-754 'Not a number' ist.</p> + +<p>Die aktuelle Version von ECMAScript (ES2015) enthält die Methode {{jsxref("Number.isNaN()")}}. <code>Number.isNaN(x)</code> wird eine zuverlässige Möglichkeit sein um zu testen ob <code>x</code> den Wert <code>NaN</code> entspricht oder nicht. Mit <code>Number.isNaN</code> wird exakt abgefragt, ob es sich um eine Nummer handelt. Eine Alternative zu testen ob eine Variable <code>NaN</code> ist, ist die Abfrage <code>(x != x)</code>. Diese wird im Normalfall zu <code>false </code>ausgewertet, außer wenn der wert <code>NaN ist.</code></p> + +<p>Ein Polyfill für <code>isNaN</code> ist folgender (der<span id="result_box" lang="de"><span> Polyfill nutzt die einzigartigen Eigenschaften von <code>NaN</code>, dass dieses niemals gleichwertig mit <code>NaN</code> ist</span></span>):</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">var isNaN <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span>value<span class="punctuation token">)</span> <span class="punctuation token">{ + var n = Number(value);</span> + return n !== n<span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></pre> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<pre class="brush: js">isNaN(NaN); // true +isNaN(undefined); // true +isNaN({}); // true + +isNaN(true); // false +isNaN(null); // false +isNaN(37); // false + +// strings +isNaN("37"); // false: "37" wird in die Nummer 37 konvertiert welche nicht NaN ist +isNaN("37.37"); // false: "37.37" wird in die Nummer 37.37 konvertiert welche nicht NaN ist +isNaN("37,5"); // true +isNaN("123ABC"); // true: parseInt("123ABC") ist 123 aber Number("123ABC") ist NaN +isNaN(""); // false: der leere String wird zu 0 konvertiert welche nicht NaN ist +isNaN(" "); // false: ein String mit Leerzeichen wird zu 0 konvertiert welche nicht NaN ist + +// dates +isNaN(new Date()); // false +isNaN(new Date().toString()); // true + +// Dieses ist das Beispiel, warum isNaN nicht zuverlässig ist. +isNaN("blabla") // true: "blabla" wird zu einer Nummer konvertiert + // Das Konvertieren schlägt fehl und gibt NaN zurück +</pre> + +<h3 id="Nützliche_Spezialfälle">Nützliche Spezialfälle</h3> + +<p>Es gibt weitere nützliche Wege <code>isNaN()</code> einzusetzen: Wenn <code>isNaN(x)</code> <code>false</code> zurückgibt, kann <code>x</code> in einer arithmetischen Operation eingesetzt werden, ohne dass diese zu <code>NaN</code> ausgewertet wird. Wenn <code>true</code> zurückgegeben wird, wird jede arithmetische Operation zu <code>NaN</code> ausgewertet. Das bedeutet, dass in JavaScript <code>isNaN(x) == true</code> gleich zu "<code>x - 0</code> ergibt <code>NaN</code>" (in JavaScript wird <code>x - 0 == NaN</code> immer false zurückgeben, was bedeutet, man kann es nicht testen). Aktuell geben <code>isNaN(x)</code>, <code>isNaN(x - 0)</code>, <code>isNaN(Number(x))</code>, <code>Number.isNaN(x - 0)</code>, und <code>Number.isNaN(Number(x))</code> immer das selbe Ergebnis zurück und <code>isNaN(x)</code> ist der kürzest mögliche Ausdruck.</p> + +<p>Dieses kann zum Beispiel eingesetzt werden, um zu prüfen, ob ein Funktionsargument arithmetisch verarbeitet werden kann. Wenn diese Verarbeitung nicht möglich ist, kann ein Standardwert unterstützt werden oder irgendetwas anderes. Damit kann man sich die volle Vielseitigkeit, die JavaScript mit implizierten Typkonvertierungen abhängig vom Kontext unterstützt, zu nutze machen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">function increment(x) { + if (isNaN(x)) x = 0; + return x + 1; +}; + +// Gleicher Wirkung wie bei Number.isNaN(): +function increment(x) { + if (Number.isNaN(Number(x))) x = 0; + return x + 1; +}; + +// In den folgenden Fällen ist für das Funktionsargument x +// isNaN(x) immer false, weil es keine Nummer ist, +// jedoch kann es in arithmetischen Operationen eingesetzt +// werden. +increment(""); // 1: "" is converted to 0 +increment(new String()); // 1: String object representing an empty string is converted to 0 +increment([]); // 1: [] is converted to 0 +increment(new Array()); // 1: Array object representing an empty array is converted to 0 +increment("0"); // 1: "0" is converted to 0 +increment("1"); // 2: "1" is converted to 1 +increment("0.1"); // 1.1: "0.1" is converted to 0.1 +increment("Infinity"); // Infinity: "Infinity" is converted to Infinity +increment(null); // 1: null is converted to 0 +increment(false); // 1: false is converted to 0 +increment(true); // 2: true is converted to 1 +increment(new Date()); // returns current date/time in milliseconds plus 1 + +// In den folgenden Fällen ist für das Funktionsargument x +// isNaN(x) immer false und x ist eine Nummer +increment(-1); // 0 +increment(-0.1); // 0.9 +increment(0); // 1 +increment(1); // 2 +increment(2); // 3 +// ... und so weiter ... +increment(Infinity); // Infinity + +// In den folgenden Fällen ist für das Funktionsargument x +// isNaN(x) immer true und x ist keine Nummer, +// weshalb die Funktion es mit 0 ersetzt und 1 zurück gibt. +increment(String); // 1 +increment(Array); // 1 +increment("blabla"); // 1 +increment("-blabla"); // 1 +increment(0/0); // 1 +increment("0/0"); // 1 +increment(Infinity/Infinity); // 1 +increment(NaN); // 1 +increment(undefined); // 1 +increment(); // 1 + +// isNaN(x) ist immer identisch mit isNaN(Number(x)), +// aber die Präsenz wenn x ist immer zwingend erforderlich. +isNaN(x) == isNaN(Number(x)) // true für jeden Wert von x, auch x == undefined, + // weil isNaN(undefined) == true und Number(undefined) gibt NaN, + // aber ... +isNaN() == isNaN(Number()) // false, weil isNaN() == true und Number() == 0</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.2.4', 'isNaN')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-isnan-number', 'isNaN')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-isnan-number', 'isNaN')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.isNaN")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("NaN")}}</li> + <li>{{jsxref("Number.isNaN()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/json/index.html b/files/de/web/javascript/reference/global_objects/json/index.html new file mode 100644 index 0000000000..e52af893a1 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/json/index.html @@ -0,0 +1,155 @@ +--- +title: JSON +slug: Web/JavaScript/Reference/Global_Objects/JSON +tags: + - JSON + - JavaScript + - Object + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/JSON +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>JSON</code></strong> Objekt enthält Methoden für das Einlesen und Konvertieren der <a class="external" href="https://json.org/">JavaScript Objekt Notation</a> ({{glossary("JSON")}}) in JavaScript und umgekehrt. Es kann nicht aufgerufen oder erstellt werden. Außer seinen zwei Methoden hat das Objekt keine interessante Funktionalität.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<h3 id="JavaScript_Objekt_Notation">JavaScript Objekt Notation</h3> + +<p>JSON ist eine Syntax für das Serialisieren von Objekten, Arrays, Nummern, Strings, Wahrheitswerten und {{jsxref("null")}}. JSON basiert auf der JavaScript Syntax, jedoch ist sie leicht unterschiedlich: Manches JavaScript ist kein JSON und manches JSON ist kein JavaScript. Für mehr Informationen Siehe in dem Artikel <a href="http://timelessrepo.com/json-isnt-a-javascript-subset">JSON: The JavaScript subset that isn't</a>.</p> + +<table> + <caption>JavaScript und JSON Unterschiede</caption> + <thead> + <tr> + <th scope="col">JavaScript Typen</th> + <th scope="col">JSON Unterschiede</th> + </tr> + </thead> + <tbody> + <tr> + <td>Objekte und Arrays</td> + <td>Namen von Eigenschaften müssen als Strings in Doppelten Anführungszeichen (") geschrieben werden; Angefügte Kommas sind verboten.</td> + </tr> + <tr> + <td>Zahlen</td> + <td>Führende Nullen sind verboten (JSON.stringify ignoriert diese Nullen, jedoch wirft JSON.parse einen SyntaxError); Nach einem Dezimalpunkt muss mindestens eine Ziffer folgen.</td> + </tr> + <tr> + <td>Strings</td> + <td> + <p>Nur eine begrenzte Menge von Zeichen muss maskiert werden; Einige Kontrollzeichen sind verboten; Die Unicodezeichen Zeilenumbruch (<a href="http://unicode-table.com/en/2028/">U+2028</a>) und Paragraphenumbruch (<a href="http://unicode-table.com/en/2029/">U+2029</a>) sind erlaubt; Strings müssen in Doppelten Anführungszeichen (") geschrieben werden. Das folgenden Beispiel zeigt eine Situation in der {{jsxref("JSON.parse()")}} funktioniert, aber das Ausführen durch JavaScript zu einem {{jsxref("SyntaxError")}} führt:</p> + + <pre class="brush: js"> +var code = '"\u2028\u2029"'; +JSON.parse(code); // funktioniert +eval(code); // Error +</pre> + </td> + </tr> + </tbody> +</table> + +<p>Nachfolgend ist die komplette JSON Syntax zu sehen:</p> + +<pre class="brush: js">JSON = null + or true or false + or JSONNumber + or JSONString + or JSONObject + or JSONArray + +JSONNumber = - PositiveNumber + or PositiveNumber +PositiveNumber = DecimalNumber + or DecimalNumber . Digits + or DecimalNumber . Digits ExponentPart + or DecimalNumber ExponentPart +DecimalNumber = 0 + or OneToNine Digits +ExponentPart = e Exponent + or E Exponent +Exponent = Digits + or + Digits + or - Digits +Digits = Digit + or Digits Digit +Digit = 0 through 9 +OneToNine = 1 through 9 + +JSONString = "" + or " StringCharacters " +StringCharacters = StringCharacter + or StringCharacters StringCharacter +StringCharacter = any character + except " or \ or U+0000 through U+001F + or EscapeSequence +EscapeSequence = \" or \/ or \\ or \b or \f or \n or \r or \t + or \u HexDigit HexDigit HexDigit HexDigit +HexDigit = 0 through 9 + or A through F + or a through f + +JSONObject = { } + or { Members } +Members = JSONString : JSON + or Members , JSONString : JSON + +JSONArray = [ ] + or [ ArrayElements ] +ArrayElements = JSON + or ArrayElements , JSON</pre> + +<p>Unbedeutende Whitespaces können überall eingebaut werden außer in eine <code><var>JSONNumber</var></code> (Nummern dürfen keine Whitespaces enthalten) und einen <code><var>JSONString</var></code> (In dem wird es als das entsprechende Whitespace interpretiert oder führt zu einem Fehler). Das Tab-Zeichen (<a href="http://unicode-table.com/en/0009/">U+0009</a>), "carriage return"-Zeichen (<a href="http://unicode-table.com/en/000D/">U+000D</a>), "line feed"-Zeichen (<a href="http://unicode-table.com/en/000A/">U+000A</a>) und Leerzeichen (<a href="http://unicode-table.com/en/0020/">U+0020</a>) sind die einzigen erlaubten Whitespace-Zeichen.</p> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("JSON.parse()")}}</dt> + <dd>Liest einen String als JSON ein. Optional werden die Werte und die Eigenschaften Transformiert und zurückgegeben.</dd> + <dt>{{jsxref("JSON.stringify()")}}</dt> + <dd>Gibt ein JSON-String eines übergebenen Wertes zurück. Optional können nur bestimmte Eigenschaften zum JSON hinzugefügt werden oder Eigenschaften werden Ersetzt. Dieses wird durch eine Benutzerdefinierte Methode durchgeführt.</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('ES5.1', '#sec-15.12', 'JSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-json-object', 'JSON')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-json-object', 'JSON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.JSON")}}</p> +</div> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.toJSON()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/json/parse/index.html b/files/de/web/javascript/reference/global_objects/json/parse/index.html new file mode 100644 index 0000000000..b8442eb38d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/json/parse/index.html @@ -0,0 +1,128 @@ +--- +title: JSON.parse() +slug: Web/JavaScript/Reference/Global_Objects/JSON/parse +tags: + - ECMAScript5 + - JSON + - JavaScript + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/JSON/parse +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>JSON.parse()</code></strong> erzeugt aus einem JSON-formatierten Text ein entsprechendes Javascript-Objekt. Der optionale <strong>reviver</strong>-Parameter kann die Umwandlung im Detail beeinflussen.</p> + +<div>{{EmbedInteractiveExample("pages/js/json-parse.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox">JSON.parse(<var>text</var>[, <var>reviver</var>])</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>text</code></dt> + <dd>JSON-formatierter Text, der eingelesen werden soll. Siehe {{jsxref("JSON")}} für eine Beschreibung der JavaScript Objekt Notation.</dd> + <dt><code>reviver</code> {{optional_inline}}</dt> + <dd> + <p><span id="result_box" lang="de"><span>Wenn es sich um eine Funktion handelt, schreibt diese vor, wie der ursprünglich vom Parsen erzeugte Wert transformiert wird, bevor er zurückgegeben wird.</span></span></p> + </dd> +</dl> + +<h3 id="Returns" name="Returns">Rückgabewert</h3> + +<p>Die Funktion gibt das aus <code>text</code> erzeugte {{jsxref("Object")}} zurück.</p> + +<h3 id="Throws" name="Throws">Ausnahmen</h3> + +<p>{{jsxref("SyntaxError")}}, falls <code>text</code> kein gültiges JSON enthält.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_JSON.parse" name="Example:_Using_JSON.parse"><code>JSON.parse()</code> verwenden</h3> + +<pre>JSON.parse('{}'); // {} +JSON.parse('true'); // true +JSON.parse('"foo"'); // "foo" +JSON.parse('[1, 5, "false"]'); // [1, 5, "false"] +JSON.parse('null'); // null +</pre> + +<h3 id="Example:_Using_the_reviver_parameter" name="Example:_Using_the_reviver_parameter">Verwendung des <code>reviver</code>-Parameters</h3> + +<p>Wenn <code>reviver</code> spezifiziert ist, wird der vom Parser berechnete Wert vor der Rückgabe Transformiert. Insbesondere der berechnete Wert und alle seine EIgenschaften (beginnend mit dem am tiefsten geschachtelten Eigenschaft bis hin zum originalen Wert selbst) werden separat mit dem <code>reviver</code> Ausgeführt.<span id="result_box" lang="de"><span> Dann wird sie aufgerufen, wobei das Objekt, das die Eigenschaft enthält, als <code>this</code> und der Eigenschaftsname als Zeichenfolge und der Eigenschaftswert als Argumente verarbeitet werden.</span></span> Wenn <code>reviver</code> {{jsxref("undefined")}} zurück gibt (oder keinen Wert zurück gibt, wenn zum Beispiel die Ausführung der Funktion fehlschlägt), wird die Eigenschaft aus dem Ergebnis entfernt. Anderenfalls wird dessen Wert in den Rückgabewert neu definiert.</p> + +<p>Falls <code>reviver</code> nur einige Werte ändert, muss sichergestellt sein, dass die unveränderten Werte auch zurückgegeben werden, ansonsten werden diese Werte aus dem Ergebnis gelöscht.</p> + +<pre class="brush: js">JSON.parse('{"p": 5}', (key, value) => + typeof value === 'number' + ? value * 2 // Gibt value * 2 für Zahlen zurück. + : value // Alle anderen Werte werden unverändert zurückgegeben. +); + +// { p: 10 } + +JSON.parse('{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}', (key, value) => { + console.log(key); // Loggt die Namen der Eigenschaften, der letzte ist "". + return value; // Gib den unveränderten Eigenschaftenwert zurück. +}); + +// 1 +// 2 +// 4 +// 6 +// 5 +// 3 +// "" +</pre> + +<h3 id="JSON.parse()_erlaubt_keine_abschließenden_Kommas"><code>JSON.parse()</code> erlaubt keine abschließenden Kommas</h3> + +<pre class="example-bad brush: js">// Beides erzeugt einen Syntaxfehler +JSON.parse("[1, 2, 3, 4, ]"); +JSON.parse("{ \"foo\" : 1, }"); +</pre> + +<h2 id="Specifications" name="Specifications">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('ES5.1', '#sec-15.12.2', 'JSON.parse')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.7.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-json.parse', 'JSON.parse')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-json.parse', 'JSON.parse')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.JSON.parse")}}</p> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("JSON.stringify()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/json/stringify/index.html b/files/de/web/javascript/reference/global_objects/json/stringify/index.html new file mode 100644 index 0000000000..1acea5bbd3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/json/stringify/index.html @@ -0,0 +1,310 @@ +--- +title: JSON.stringify() +slug: Web/JavaScript/Reference/Global_Objects/JSON/stringify +tags: + - JSON + - JavaScript + - Method + - Reference + - stringify +translation_of: Web/JavaScript/Reference/Global_Objects/JSON/stringify +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>JSON.stringify()</code></strong> Methode konvertiert einen JavaScript-Wert in einen JSON-String. Optional werden Werte ersetzt, wenn eine Ersetzungsfunktion angegeben ist. Optional werden nur die angegebenen Eigenschaften einbezogen, wenn ein Ersetzungsarray angegeben ist.</p> + +<div>{{EmbedInteractiveExample("pages/js/json-stringify.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>JSON.stringify(<var>value</var>[, <var>replacer</var>[, <var>space</var>]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Der Wert, der zu einem JSON-String konvertiert werden soll.</dd> + <dt><code>replacer</code> {{optional_inline}}</dt> + <dd>Eine Funktion, die das Verhalten des String- Erstellungsprozesses verändert, oder ein Array von {{jsxref("String")}} und {{jsxref("Number")}} Objekten, die als Whiteliste für die Selektion von Eigenschaften des <code>value</code> Objektes fungiert, um nur bestimmte Eigenschaften im JSON-String aufzunehmen. Wenn dieser Parameter null ist oder nicht unterstützt wird, werden alle Eigenschaften des Objektes im JSON-String aufgenommen.</dd> + <dt><code>space</code> {{optional_inline}}</dt> + <dd>Ein {{jsxref("String")}} oder {{jsxref("Number")}} Objekt, welches eingesetzt wird, um Whitespaces in den JSON-String für die Lesbarkeit hinzuzufügen. Wenn eine <code>Number</code> angegeben ist, bedeutet dies, dass die angegebene Anzahl an Leerzeichen hinzugefügt werden; Die Anzahl der Leerzeichen ist hierbei auf 10 begrenzt und wird bei einer größeren Anzahl auf 10 gesetzt. Werte kleiner als 1 bedeuten, dass keine Leerzeichen verwendet werden sollen. Wenn ein <code>String</code> angegeben wird, wird der String (oder die ersten 10 Zeichen des Strings, wenn er länger ist) als Leerzeichen benutzt. Wenn dieser Parameter null ist oder nicht unterstützt wird, werden keine Whitespaces verwendet.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein JSON-String, der den angegebenen Wert repräsentiert.</p> + +<h3 id="Fehler">Fehler</h3> + +<p>Erzeugt einen {{jsxref("TypeError")}} ("cyclic object value") Fehler, wenn eine zyklische Referenz gefunden wird.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>JSON.stringify()</code> konvertiert einen Wert in einen in JSON-Notation gleichwertigen Wert:</p> + +<ul> + <li>Wenn der Wert eine <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify$edit#toJSON()_behavior">toJSON()</a> Methode hat, definiert diese, welche Daten serialisiert werden.</li> + <li>{{jsxref("Boolean")}}, {{jsxref("Number")}} und {{jsxref("String")}} Objekte werden zu den entsprechenden primitiven Werten, gemäß der traditionellen Konvertierungssemantik, konvertiert.</li> + <li>Wenn {{jsxref("undefined")}}, eine {{jsxref("Function", "Funktion")}} oder ein {{jsxref("Symbol")}} während der Konvertierung auftritt, wird es einfach weggelassen (wenn es in einem Objekt gefunden wird) oder zu {{jsxref("null")}} geändert (wenn es in einem Array gefunden wurde). <code>JSON.stringify</code> kann <code>undefined</code> zurückgeben, wenn nur ein Wert wie <code>JSON.stringify(function(){})</code> or <code>JSON.stringify(undefined)</code> übergeben wird.</li> + <li>Alle {{jsxref("Symbol")}}-Schlüssel-Eigenschaften werden komplett ignoriert, auch wenn die <code>replacer</code> Funktion genutzt wird.</li> + <li>Instanzen von {{jsxref("Date")}} implementieren die <code>toJSON()</code> Funktion so, dass ein String (der gleich wie bei <code>date.toISOString()</code> ist) zurückgibt. Daher werden sie als String behandelt.</li> + <li>Die Zahlen {{jsxref("Infinity")}} und {{jsxref("NaN")}} genauso wie {{jsxref("null")}} Objekte werden zu <code>null</code> umgewandelt.</li> + <li>Für alle anderen {{jsxref("Object")}} Instanzen (eingeschlossen {{jsxref("Map")}}, {{jsxref("Set")}}, {{jsxref("WeakMap")}} und {{jsxref("WeakSet")}}) werden nur die aufzählbaren (enumerable) Eigenschaften serialisiert.</li> +</ul> + +<pre class="brush: js">JSON.stringify({}); // '{}' +JSON.stringify(true); // 'true' +JSON.stringify('foo'); // '"foo"' +JSON.stringify([1, 'false', false]); // '[1,"false",false]' +JSON.stringify([NaN, null, Infinity]); // '[null,null,null]' +JSON.stringify({ x: 5 }); // '{"x":5}' + +JSON.stringify(new Date(2006, 0, 2, 15, 4, 5)) +// '"2006-01-02T15:04:05.000Z"' + +JSON.stringify({ x: 5, y: 6 }); +// '{"x":5,"y":6}' or '{"y":6,"x":5}' +JSON.stringify([new Number(1), new String('false'), new Boolean(false)]); +// '[1,"false",false]' + +JSON.stringify({ x: [10, undefined, function(){}, Symbol('')] }); +// '{"x":[10,null,null,null]}' + +// Standard-Datenstrukturen +JSON.stringify([new Set([1]), new Map([[1, 2]]), new WeakSet([{a: 1}]), new WeakMap([[{a: 1}, 2]])]); +// '[{},{},{},{}]' + +// TypedArray +JSON.stringify([new Int8Array([1]), new Int16Array([1]), new Int32Array([1])]); +// '[{"0":1},{"0":1},{"0":1}]' +JSON.stringify([new Uint8Array([1]), new Uint8ClampedArray([1]), new Uint16Array([1]), new Uint32Array([1])]); +// '[{"0":1},{"0":1},{"0":1},{"0":1}]' +JSON.stringify([new Float32Array([1]), new Float64Array([1])]); +// '[{"0":1},{"0":1}]' + +// toJSON() +JSON.stringify({ x: 5, y: 6, toJSON(){ return this.x + this.y} }); +// '11' + +// Symbols: +JSON.stringify({ x: undefined, y: Object, z: Symbol('') }); +// '{}' +JSON.stringify({ [Symbol('foo')]: 'foo' }); +// '{}' +JSON.stringify({ [Symbol.for('foo')]: 'foo' }, [Symbol.for('foo')]); +// '{}' +JSON.stringify({ [Symbol.for('foo')]: 'foo' }, function(k, v) { + if (typeof k === 'symbol') { + return 'a symbol'; + } +}); +// '{}' + +// Nicht-enumerable Eigenschaften: +JSON.stringify( Object.create(null, { x: { value: 'x', enumerable: false }, y: { value: 'y', enumerable: true } }) ); +// '{"y":"y"}' +</pre> + +<h3 id="Der_replacer_Parameter"><a id="The replacer parameter" name="The replacer parameter"></a>Der <code>replacer</code> Parameter</h3> + +<p>Der <code>replacer</code> Parameter kann entweder eine Funktion oder ein Array sein. Als Funktion erhält diese zwei Parameter, den Schlüssel und den Wert, die in JSON konvertiert werden. Das Objekt, in dem der Schlüssel gefunden wurde, kann in der <code>replacer</code> Funktion mit <code>this</code> abgefragt werden. Initial wird die <code>replacer</code> Funktion mit einem leeren String als Schlüssel aufgerufen, was bedeutet, dass das Objekt konvertiert wird und dieses dann für alle Eigenschaften des Objektes oder Arrays die <code>replacer</code> Funktion aufruft. Die Funktion kann den Rückgabewert wie folgt zurückgeben, damit das Objekt zum JSON-String hinzugefügt wird:</p> + +<ul> + <li>Wenn eine {{jsxref("Number")}} zurückgegeben wird, wird der entsprechende String der Zahl als Wert für die Eigenschaft zum JSON hinzugefügt.</li> + <li>Wenn ein {{jsxref("String")}} zurückgegeben wird, wird der String als Wert für die Eigenschaft zum JSON hinzugefügt.</li> + <li>Wenn ein {{jsxref("Boolean")}} zurückgegeben wird, werden "true" oder "false" als Wert für die Eigenschaft im JSON hinzugefügt.</li> + <li>Wenn <code>null</code> zurückgegeben wird, wird <code>null</code> zum JSON String kinzugefügt.</li> + <li>Wenn ein anderes Objekt zurückgegeben wird, wird dieses Objekt wiederum rekursiv in ein JSON-String konvertiert, was bedeutet, dass für jede Eigenschaft auch die <code>replacer</code> Funktion wieder aufgerufen wird. Eine Ausnahme ist, wenn das zurückgegebene Objekt eine Funktion ist, dann wird nichts zum JSON hinzugefügt.</li> + <li>Wenn <code>undefined</code> zurückgegeben wird, wird die Eigenschaft nicht in das JSON hinzugefügt.</li> +</ul> + +<div class="note"><strong>Hinweis:</strong> Man kann eine <code>replacer</code> Funktion nicht nutzen, um Werte von Arrays zu entfernen. Wenn man <code>undefined</code> oder eine function zurückgibt, wird <code>null</code> zum JSON hinzugefügt.</div> + +<div class="note"><strong>Hinweis:</strong> Wenn man möchten, dass der Replacer ein initiales Objekt von einem Schlüssel mit einer leeren String-Eigenschaft unterscheidet (da beide den leeren String als Schlüssel und möglicherweise ein Objekt als Wert angeben würden), muss man den Anzahl der Iterationen verfolgen (wenn er jenseits der ersten Iteration ist, ist es ein echter leerer String-Schlüssel).</div> + +<h4 id="Beispiel_mit_einer_Funktion">Beispiel mit einer Funktion</h4> + +<pre class="brush: js">function replacer(key, value) { + if (typeof value === "string") { + return undefined; + } + return value; +} + +var foo = {foundation: "Mozilla", model: "box", week: 45, transport: "car", month: 7}; +var jsonString = JSON.stringify(foo, replacer); +// <code>{"week":45,"month":7}</code> </pre> + +<h4 id="Beispiel_mit_einem_Array">Beispiel mit einem Array</h4> + +<p>Wenn <code>replacer</code> ein Array ist, geben die Werte des Arrays die Namen der Eigenschaften an, die im JSON-String mit aufgenommen werden sollen.</p> + +<pre class="brush: js">JSON.stringify(foo, ['week', 'month']); +// '{"week":45,"month":7}', only keep "week" and "month" properties +</pre> + +<h3 id="Der_space_Parameter"><a id="The space argument" name="The space argument"></a>Der <code>space</code> Parameter</h3> + +<p>Der <code>space</code> Parameter wird eingesetzt, um die Abstände in dem JSON-String zu beeinflussen. Wenn es eine Zahl ist, werden sukzessiv alle Stufen um die angegebene Anzahl von Leerzeichen (bis zu 10) eingerückt. Wenn <code>space</code> ein String ist, werden sukzessiv alle Stufen mit dem angegebenen String eingerückt (oder mit den ersten zehn Zeichen).</p> + +<pre class="brush: js">JSON.stringify({ a: 2 }, null, ' '); +// '{ +// "a": 2 +// }' +</pre> + +<p>Einsatz eines Tab-Zeichens als Standard für leserliches Aussehen:</p> + +<pre class="brush: js">JSON.stringify({ uno: 1, dos: 2 }, null, '\t'); +// returns the string: +// '{ +// "uno": 1, +// "dos": 2 +// }' +</pre> + +<h3 id="toJSON_Verhalten"><code>toJSON()</code> Verhalten</h3> + +<p>Wenn ein Objekt in ein JSON-String umgewandelt werden soll und eine Eigenschaft mit dem Namen <code>toJSON</code>, dessen Wert eine Funktion ist, wird die <code>toJSON()</code> Funktion eingesetzt um ein JSON-String zu erstellen: Anstatt, dass das Objekt normal serialisiert wird, wird die <code>toJSON()</code> Funktion aufgerufen und der Rückgabewert serialisiert. JSON.stringify ruft <code>toJSON</code> mit einem Parameter auf:</p> + +<ul> + <li>wenn das Objekt ein Eigenschaftswert ist, dann der Name der Eigenschaft</li> + <li>wenn es ein Array ist, dann den Index im Array als String</li> + <li>ein leerer String, wenn JSON.stringify direkt auf dem Objekt aufgerufen wurde</li> +</ul> + +<p>Zum Beispiel:</p> + +<pre class="brush: js">var obj = { + data: 'data', + + toJSON(key){ + if(key) + return `Now I am a nested Object under key '${key}'`; + + else + return this; + } +}; + +JSON.stringify(obj); +// Returns '{"data":"data"}' + +JSON.stringify({ obj }); +// Returns '{"obj":"Now I am a nested object under key 'obj'"}' + +JSON.stringify([ obj ]) +// Returns '["Now I am a nested object under key '0'"]'</pre> + +<h3 id="Probleme_mit_JSON.stringify_bei_zyklischen_Referenzen">Probleme mit <code>JSON.stringify</code> bei zyklischen Referenzen</h3> + +<p>Zu beachten ist, dass das <a href="https://www.json.org/">JSON Format</a> keine Objektreferenzen unterstützt (es existiert nur ein <a href="http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03">IETF Entwurf</a>), so dass ein {{jsxref("TypeError")}} erzeugt wird, wenn ein Objekt mit zyklischen Referenzen übersetzt werden soll.</p> + +<pre class="brush: js example-bad">const circularReference = {}; +circularReference.myself = circularReference; + +// Serializing circular references throws "TypeError: cyclic object value" +JSON.stringify(circularReference); +</pre> + +<p>Um zyklische Referenzen zu Serialisieren, wird ein Bibliothek mit solchen Funktionen benötigt (z. B. <a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a> von Douglas Crockford) oder es muss eine eigene Lösung implementiert werden, welche zyklische Referenzen bei serialisierbaren Werten findet und ersetzt (oder entfernt).</p> + +<h3 id="Probleme_mit_reinem_Einsatz_von_JSON.stringify_für_JavaScript">Probleme mit reinem Einsatz von <code>JSON.stringify</code> für JavaScript</h3> + +<p>Man muss anmerken, dass JSON <a href="http://timelessrepo.com/json-isnt-a-javascript-subset">keine komplette strikte Untermenge von JavaScript ist (englisch)</a>. Es gibt nämlich zwei Zeilentrenner (Zeilentrenner und Paragraphentrenner), die in JSON nicht escaped werden müssen, in JavasScript jedoch schon. Wenn ein JSON nun ausgewertet oder direkt in <a href="https://de.wikipedia.org/wiki/JavaScript_Object_Notation#JSONP">JSONP</a> eingesetzt werden soll, kann der folgende Quelltext verwendet werden:</p> + +<pre class="brush: js">function jsFriendlyJSONStringify (s) { + return JSON.stringify(s). + replace(/\u2028/g, '\\u2028'). + replace(/\u2029/g, '\\u2029'); +} + +var s = { + a: String.fromCharCode(0x2028), + b: String.fromCharCode(0x2029) +}; +try { + eval('(' + JSON.stringify(s) + ')'); +} catch (e) { + console.log(e); // "SyntaxError: unterminated string literal" +} + +// kein catch benötigt +eval('(' + jsFriendlyJSONStringify(s) + ')'); + +// console.log in Firefox unescapes den Unicode wenn +// in die Konsole geloggt wird, weshalb hier alert eingesetzt wird. +alert(jsFriendlyJSONStringify(s)); // {"a":"\u2028","b":"\u2029"}</pre> + +<h3 id="Beispiel_für_Einsatz_von_JSON.stringify_mit_localStorage">Beispiel für Einsatz von <code>JSON.stringify()</code> mit <code>localStorage</code></h3> + +<p>In einem Fall, indem man ein Objekt speichern möchte, dass von einem Benutzer erstellt wurde, und dem Benutzer dieses auch nach dem Schließen des Browsers wieder zur Verfügung stellten möchte, ist ein Beispiel für die Anwendung von <code>JSON.stringify()</code>:</p> + +<pre class="brush: js">// Creating an example of JSON +var session = { + 'screens': [], + 'state': true +}; +session.screens.push({ 'name': 'screenA', 'width': 450, 'height': 250 }); +session.screens.push({ 'name': 'screenB', 'width': 650, 'height': 350 }); +session.screens.push({ 'name': 'screenC', 'width': 750, 'height': 120 }); +session.screens.push({ 'name': 'screenD', 'width': 250, 'height': 60 }); +session.screens.push({ 'name': 'screenE', 'width': 390, 'height': 120 }); +session.screens.push({ 'name': 'screenF', 'width': 1240, 'height': 650 }); + +// Konvertiert zu einem JSON-String mit JSON.stringify(). +// Dann wird der String des session-Objektes im localStorage gespeichert. +localStorage.setItem('session', JSON.stringify(session)); + +// Beispiel wie man den mit JSON.stringify() generierten und +// im localStorage gespeicherten JSON-String in ein Objekt umwandelt. +var restoredSession = JSON.parse(localStorage.getItem('session')); + +// Jetzt enthält die Variable restoredSession das im localStorage +// abgespeicherte Objekt +console.log(restoredSession); +</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('ES5.1', '#sec-15.12.3', 'JSON.stringify')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.7.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-json.stringify', 'JSON.stringify')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-json.stringify', 'JSON.stringify')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.JSON.stringify")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("JSON.parse()")}}</li> + <li><a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a> – Führt zwei Funktionen ein, <code>JSON.decycle</code> und <code>JSON.retrocycle</code>, welche es ermöglichen zyklische Strukturen zu kodieren und dekodieren und eine erweiterbare und JSON Format kompatible Struktur bietet.</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/@@iterator/index.html b/files/de/web/javascript/reference/global_objects/map/@@iterator/index.html new file mode 100644 index 0000000000..8f480772d1 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/@@iterator/index.html @@ -0,0 +1,102 @@ +--- +title: 'Map.prototype[@@iterator]()' +slug: Web/JavaScript/Reference/Global_Objects/Map/@@iterator +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Map + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Map/@@iterator +--- +<div>{{JSRef}}</div> + +<p class="seoSummary">Der initialewert der <code><strong>@@iterator</strong></code> Eigenschaft enthält das selbe Funktionsobjekt wie der Wert in der {{jsxref("Map.prototype.entries()", "entries")}} Methode.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-@@iterator.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>myMap</em>[Symbol.iterator]</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die <strong>iterator</strong> Funktion von <code>map</code> ist im Standardfall die {{jsxref("Map.prototype.entries()", "entries()")}} Funktion.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_iterator()">Einsatz von <code>[@@iterator]()</code></h3> + +<pre class="brush:js">const myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +const mapIter = myMap[Symbol.iterator](); + +console.log(mapIter.next().value); // ["0", "foo"] +console.log(mapIter.next().value); // [1, "bar"] +console.log(mapIter.next().value); // [Object, "baz"] +</pre> + +<h3 id="Einsatz_von_iterator()_mit_for..of">Einsatz von <code>[@@iterator]()</code> mit <code>for..of</code></h3> + +<pre class="brush: js">const myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +for (const entry of myMap) { + console.log(entry); +} +// ["0", "foo"] +// [1, "bar"] +// [{}, "baz"] + +for (const [key, value] of myMap) { + console.log(`${key}: ${value}`); +} +// 0: foo +// 1: bar +// [Object]: baz +</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-map.prototype-@@iterator', 'Map.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype-@@iterator', 'Map.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.@@iterator")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.keys()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/@@species/index.html b/files/de/web/javascript/reference/global_objects/map/@@species/index.html new file mode 100644 index 0000000000..8dc72de6bc --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/@@species/index.html @@ -0,0 +1,72 @@ +--- +title: 'get Map[@@species]' +slug: Web/JavaScript/Reference/Global_Objects/Map/@@species +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Map/@@species +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Map[@@species]</strong></code> Zugriffseigenschaft gibt den <code>Map</code> Konstruktor zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Map[Symbol.species] +</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>species</code> Zugriffseigenschaft gibt den Standard-Konstruktor für <code>Map</code> Objekte zurück. Konstruktoren von Unterklassen überschreiben diese Eigenschaft manchmal, um die Konstruktorzuweisung zu ändern.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Die <code>species</code> Eigenschaft gibt die Standard-Konstruktorfunktion, welches der <code>Map</code> Konstruktor von <code>Map</code> Objekten ist:</p> + +<pre class="brush: js">Map[Symbol.species]; // function Map()</pre> + +<p>In einem abgeleiteten Collection Objekt (z. B. eine Benutzerdifinierte Map <code>MyMap</code>) ist der <code>species</code> von <code>MyMap</code> der <code>MyMap</code> Konstruktor. Manchmal, wenn dieser Überschrieben wird das Eltern <code>Map</code> Objekt in der abgeleiteten Klassenmethode verwenden:</p> + +<pre class="brush: js">class MyMap extends Map { + // Overwrite MyMap species to the parent Map constructor + static get [Symbol.species]() { return Map; } +}</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-get-map-@@species', 'get Map [ @@species ]')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-map-@@species', 'get Map [ @@species ]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Map.@@species")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Symbol.species")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/@@tostringtag/index.html b/files/de/web/javascript/reference/global_objects/map/@@tostringtag/index.html new file mode 100644 index 0000000000..50d1515963 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/@@tostringtag/index.html @@ -0,0 +1,58 @@ +--- +title: 'Map.prototype[@@toStringTag]' +slug: Web/JavaScript/Reference/Global_Objects/Map/@@toStringTag +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Property + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Map/@@toStringTag +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Map[@@toStringTag]</code></strong> Eigenschaft hat den initialen Wert <code>"Map"</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-@@tostringtag.html")}}</div> + + + +<div>{{js_property_attributes(0,0,1)}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Map[Symbol.toStringTag]</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush:js">Object.prototype.toString.call(new Map()) // "[object Map]" +</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-map.prototype-@@tostringtag', 'Map.prototype[@@toStringTag]')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype-@@tostringtag', 'Map.prototype[@@toStringTag]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.@@toStringTag")}}</p> diff --git a/files/de/web/javascript/reference/global_objects/map/clear/index.html b/files/de/web/javascript/reference/global_objects/map/clear/index.html new file mode 100644 index 0000000000..6ae31b4dee --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/clear/index.html @@ -0,0 +1,77 @@ +--- +title: Map.prototype.clear() +slug: Web/JavaScript/Reference/Global_Objects/Map/clear +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map/clear +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>clear()</strong></code> Methode entfernt alle Elemente von einem <code>Map</code> Objekt.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-clear.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.clear();</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_clear_Methode">Einsatz der <code>clear</code> Methode</h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'baz'); +myMap.set(1, 'foo'); + +myMap.size; // 2 +myMap.has('bar'); // true + +myMap.clear(); + +myMap.size; // 0 +myMap.has('bar') // false +</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-map.prototype.clear', 'Map.prototype.clear')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.clear")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/delete/index.html b/files/de/web/javascript/reference/global_objects/map/delete/index.html new file mode 100644 index 0000000000..40f38a6931 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/delete/index.html @@ -0,0 +1,73 @@ +--- +title: Map.prototype.delete() +slug: Web/JavaScript/Reference/Global_Objects/Map/delete +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Map/delete +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>delete()</code></strong> Methode entfernt das Element mit eine bestimmten Schlüssel von einem <code>Map</code> Objekt.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-delete.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="brush: js"><var>myMap</var>.delete(<var>key</var>);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>key</dt> + <dd>Der Schlüssel des Element, welches aus dem <code>Map</code> Objekt entfernt wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Gibt <code>true</code> zurück, wenn ein Element in der <code>Map</code> existiert und gelöscht wird, oder <code>false</code> wenn kein Element existiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_delete_Methode">Einsatz der <code>delete</code> Methode</h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'foo'); + +myMap.delete('bar'); // Returns true. Successfully removed. +myMap.has('bar'); // Returns false. The "bar" element is no longer present. +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.delete")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/entries/index.html b/files/de/web/javascript/reference/global_objects/map/entries/index.html new file mode 100644 index 0000000000..018cd8088a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/entries/index.html @@ -0,0 +1,78 @@ +--- +title: Map.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Map/entries +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Map + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map/entries +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>entries()</strong></code> Methode gibt ein neues <strong><a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong> Objekt mit allen <code>[Schlüssel, Wert]</code> Paaren von jedem Element in dem <code>Map</code> Objekt in Einfügereihenfolge zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-entries.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.entries()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues {{jsxref("Map")}} Iterator Objekt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_entries()">Einsatz von <code>entries()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +var mapIter = myMap.entries(); + +console.log(mapIter.next().value); // ["0", "foo"] +console.log(mapIter.next().value); // [1, "bar"] +console.log(mapIter.next().value); // [Object, "baz"] +</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-map.prototype.entries', 'Map.prototype.entries')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.entries")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map.prototype.keys()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/foreach/index.html b/files/de/web/javascript/reference/global_objects/map/foreach/index.html new file mode 100644 index 0000000000..017fa9b069 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/foreach/index.html @@ -0,0 +1,104 @@ +--- +title: Map.prototype.forEach() +slug: Web/JavaScript/Reference/Global_Objects/Map/forEach +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map/forEach +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>forEach()</strong></code> Methode führt eine übergebene Funktion für jedes Schlüssel/Wert Paar in dem <code>Map</code> Objekt in der Einfügereihenfolge aus.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-foreach.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.forEach(<em>callback</em>[, <em>thisArg</em>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funktion, die für jedes Schlüssel/Werte-Paar aufgerufen wird.</dd> + <dt><code>thisArg</code></dt> + <dd>Wert, der bei der Ausführung der <code>callback</code>-Funktion als <code>this</code> genutzt wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>forEach</code> Methode ruft die übergebene Funktion für jedes Schlüssel/Wert Paar in dem <code>Map</code> Objekt aus. Die <code>callback</code> Funktion wird nicht aufgerufen, wenn der Schlüssel gelöscht wurde. Sie wird aber aufgerufen, wenn der aktuelle Wert <code>undefined</code> ist.</p> + +<p>Die <code>callback</code> Funktion wird mit <strong>drei Parametern</strong> aufgerufen:</p> + +<ul> + <li>der <strong>Wert des Elements</strong></li> + <li>der <strong>Schlüssel des Elements</strong></li> + <li>das <strong><code>Map</code> Objekt, das durchlaufen wird</strong></li> +</ul> + +<p>Wenn der <code>thisArg</code>-Parameter an <code>forEach</code> übergeben wird, wird er auch an die <code>callback-Funktion</code> als deren <code>this</code> Wert weitergegeben. Andernfalls wird dafür <code>undefined</code> genutzt. <code>Der this</code>-Wert, der in der <code>callback-Funktion</code> wahrgenommen wird, ist festgelegt durch <a href="/de/docs/Web/JavaScript/Reference/Operators/this">die generellen Regeln für die Nutzung von <code>this</code> in einer Funktion.</a></p> + +<p>Jeder Wert wird einmal besucht, mit Außnahme von Fällen, in denen ein Wert glöscht und neu hinzugefügt wird, bevor <code>forEach</code> fertig ist. Die <code>callback</code> Funktion wird nicht für Wert aufgerufen, die vorher gelöscht wurden. Neue Werte, die vor der Beendigung von <code>forEach</code> hinzugefügt werden, werden berücksichtigt.</p> + +<p>Die <code>forEach</code> Methode ruft <code>callback</code> für jedes Element in dem <code>Map</code> Objekt aus. <code>forEach</code> gibt keinen Wert zurück.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ausgabe_der_Inhalte_eines_Map_Objekts">Ausgabe der Inhalte eines <code>Map</code> Objekts</h3> + +<p>Der folgende Code gibt für jedes Element in der Map eine Nachricht in der Konsole aus.</p> + +<pre class="brush:js">function logMapElements(value, key, map) { + console.log(`m[${key}] = ${value}`); +} +new Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(logMapElements); +// logs: +// "m[foo] = 3" +// "m[bar] = [object Object]" +// "m[baz] = undefined" +</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-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.forEach")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Set.prototype.forEach()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/get/index.html b/files/de/web/javascript/reference/global_objects/map/get/index.html new file mode 100644 index 0000000000..c178c59f0b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/get/index.html @@ -0,0 +1,80 @@ +--- +title: Map.prototype.get() +slug: Web/JavaScript/Reference/Global_Objects/Map/get +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map/get +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>get()</strong></code> Methode gibt eine Spezielles Element aus einem <code>Map</code> Objekt zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-get.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.get(schlüssel);</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>schlüssel</dt> + <dd>Der Schlüssel eines Elements, welches aus der <code>Map</code> zurückgegeben wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Gibt das Element zurück, welches zu dem Schlüssel gehört oder <code>undefined</code>, wenn kein Schlüssel in dem <code>Map</code> Objekt vorhanden ist.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_get_Methode">Einsatz der <code>get</code> Methode</h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'foo'); + +myMap.get('bar'); // Returns "foo". +myMap.get('baz'); // Returns undefined. +</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-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.get")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/has/index.html b/files/de/web/javascript/reference/global_objects/map/has/index.html new file mode 100644 index 0000000000..ea4df56c27 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/has/index.html @@ -0,0 +1,83 @@ +--- +title: Map.prototype.has() +slug: Web/JavaScript/Reference/Global_Objects/Map/has +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map/has +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>has()</strong></code> Methode gibt einen boolean zurück, welcher angibt, ob ein spezieller Schlüssel vorhanden ist oder nicht.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-has.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.has(schlüssel);</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>schlüssel</dt> + <dd>Der Schlüssel, auf dessen Präsenz in dem <code>Map</code> Objekt geprüft wird.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<dl> + <dt>Boolean</dt> + <dd>Gibt <code>true</code> zurück, wenn ein Element mit Schlüssel in dem <code>Map</code> Objekt existiert, andernfalls <code>false</code>.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_has_Methode">Einsatz der <code>has</code> Methode</h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', "foo"); + +myMap.has('bar'); // returns true +myMap.has('baz'); // returns false +</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-map.prototype.has', 'Map.prototype.has')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.has', 'Map.prototype.has')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.has")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/index.html b/files/de/web/javascript/reference/global_objects/map/index.html new file mode 100644 index 0000000000..3cfa11c840 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/index.html @@ -0,0 +1,207 @@ +--- +title: Map +slug: Web/JavaScript/Reference/Global_Objects/Map +tags: + - ECMAScript 2015 + - JavaScript + - Map +translation_of: Web/JavaScript/Reference/Global_Objects/Map +--- +<div>{{JSRef}}</div> + +<div>Das <code><strong>Map</strong></code> Objekt ist eine einfache Schlüssel/Wert Zuordnung. Jeder Wert (Sowohl Objekte, als auch {{Glossary("Primitive", "primitive Datentypen")}}) kann als Schlüssel/Wert verwendet werden.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new Map([iterable])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>iterable</code></dt> + <dd> + <p class="syntaxbox">Der Parameter <code>iterable</code> ist ein Array oder anderes iterierbares Objekt, dessen Elemente Schlüssel-Wert Paare (2-Element Arrays) sind. Jedes Schlüssel-Wert Paar wird der neuen Map hinzugefügt.</p> + </dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Ein Map Object iteriert in der Reihenfolge des Einfügens über seine Elemente — eine {{jsxref("Statements/for...of", "for...of")}} Schleife gibt ein Array mit <code>[key, value]</code> für jede Iteration zurück.</p> + +<p>Es ist festzuhalten, dass eine <code>Map</code>, bestehend aus <code>objects</code>, insbesondere ein "<code>dictionary of dictionaries</code>", nur nach der Einfügereihenfolge angelegt wird, die zufällig und ungeordnet ist.</p> + +<h3 id="Schlüsselvergleich">Schlüsselvergleich</h3> + +<p>Der Schlüsselvergleich basiert auf dem "gleicher-Wert" Algorithmus: <code>NaN</code> wird als gleich mit einer anderen <code>NaN</code> angesehen (trotz dem, dass <code>NaN !== NaN</code>) und alle anderen Werte müssen typ- und wert identisch, wie beim <code>===</code> Operator, sein. In der aktuellen ECMAScript Spezifikation werden <code>-0</code> und <code>+0</code> als gleich behandelt, auch wenn dies in früheren Entwürfen anders war. Details dazu sind der Tabelle <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Map$edit#Browser_compatibility">browser compatibility </a>zu entnehmen. </p> + +<h3 id="Objects_und_Maps_im_Vergleich">Objects und Maps im Vergleich</h3> + +<p>{{jsxref("Object", "Objects")}} und Maps haben einige gemeinsame Eigenschaften. In beiden lassen sich Schlüssel auf Werte setzen, diese Werte wiederfinden, Schlüssel löschen und herausfinden, ob etwas unter einem bestimmten Schlüssel gespeichert ist. Aus diesem Grund (und weil es keine spracheigenen Alternativen gab) wurden früher <code>Objects</code> als <code>Maps</code> benutzt. Doch es gibt bedeutende Unterschiede zwischen diesen beiden Strukturen, die es in verschiedenen Fällen zu beachten gilt:</p> + +<ul> + <li>Die Schlüssel eines <code>Object</code>s sind {{jsxref("String", "Strings")}} und {{jsxref("Symbol", "Symbols")}}, während sie bei einer <code>Map</code> jeglichen Wert haben können. Inklusive <code>functions</code>, <code>objects</code>, und alle <code>primitive</code>.</li> + <li>Die Grösse einer <code>Map</code> lässt sich einfach über die <code>size</code> Eigenschaft ermitteln, während die Zahl der Eigenschaften in einem <code>Object</code> erst manuell herausgefunden werden müssen.</li> + <li>Eine <code>Map</code> ist iterierbar, wohingegen das Iterieren über ein <code>Object </code>erfordert, dass man dessen Schlüssel temporär extrahiert und dann über diese iteriert.</li> + <li>Ein <code>Object</code> hat einen Prototypen mit default-Schlüsseln in seiner Map, die mit den Namen von selbst angelegten Schlüsseln kollidieren können, wenn man nicht aufpasst. Seit ES5 lässt sich dies durch die Anweisung <code>map = Object.create(null)</code> umgehen, was aber selten verwendet wird.</li> + <li>Eine <code>Map</code> bietet in Szenarien mit hochfrequentem Einfügen und Löschen von Schlüssel-Wert Paaren ein besseres Laufzeitverhalten als <code>Objects</code>.</li> +</ul> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Map.length</code></dt> + <dd>Der Wert von <code>length</code> beträgt 0.</dd> + <dt>{{jsxref("Map.@@species", "get Map[@@species]")}}</dt> + <dd>Die Konstruktor-Funktion, zum Erzeugen abgeleiteter Objekte.</dd> + <dt>{{jsxref("Map.prototype")}}</dt> + <dd>Repräsentiert den Prototyp für den <code>Map</code> Konstruktor. Erlaubt das Hinzufügen von Eigenschaften zu allen <code>Map</code> Objekten.</dd> +</dl> + +<h2 id="Map_Instanzen"><code>Map</code> Instanzen</h2> + +<p>Alle <code>Map</code> Instanzen erben von {{jsxref("Map.prototype")}}.</p> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<p>{{page('/de/Web/JavaScript/Reference/Global_Objects/Map/prototype','Eigenschaften')}}</p> + +<h3 id="Methoden">Methoden</h3> + +<p>{{page('/de/Web/JavaScript/Reference/Global_Objects/Map/prototype','Methoden')}}</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_vom_Map_Objekt">Einsatz vom <code>Map</code> Objekt</h3> + +<pre class="brush: js">var myMap = new Map(); + +var keyString = "ein string", + keyObj = {}, + keyFunc = function () {}; + +// setting the values +myMap.set(keyString, "value associated with 'ein string'"); +myMap.set(keyObj, "value associated with keyObj"); +myMap.set(keyFunc, "value associated with keyFunc"); + +myMap.size; // 3 + +// getting the values +myMap.get(keyString); // "value associated with 'ein string'" +myMap.get(keyObj); // "value associated with keyObj" +myMap.get(keyFunc); // "value associated with keyFunc" + +myMap.get("ein string"); // "value associated with 'ein string'" + // because keyString === 'ein string' +myMap.get({}); // undefined, because keyObj !== {} +myMap.get(function() {}) // undefined, because keyFunc !== function () {} +</pre> + +<h3 id="Benutzung_von_NaN_als_Map_Schlüssel">Benutzung von <code>NaN</code> als <code>Map</code> Schlüssel</h3> + +<p><code>NaN</code> kann auch als Schlüssel benutzt werden. Auch wenn jede <code>NaN</code> nicht gleich zu sich selbst ist (<code>NaN !== NaN</code> is true) funktioniert das folgende Beispiel, da <code>NaN</code>s ununterscheidbar von jeder anderen ist:</p> + +<pre class="brush: js">var myMap = new Map(); +myMap.set(NaN, "not a number"); + +myMap.get(NaN); // "not a number" + +var otherNaN = Number("foo"); +myMap.get(otherNaN); // "not a number" +</pre> + +<h3 id="Iterieren_über_Maps_mit_for..of">Iterieren über <code>Maps</code> mit <code>for..of</code></h3> + +<p>Über Maps kann mit der <code>for..of</code> Schleife iteriert werden:</p> + +<pre class="brush: js">var myMap = new Map(); +myMap.set(0, "zero"); +myMap.set(1, "one"); +for (var [key, value] of myMap) { + console.log(key + " = " + value); +} +// 0 = zero +// 1 = one + +for (var key of myMap.keys()) { + console.log(key); +} +// 0 +// 1 + +for (var value of myMap.values()) { + console.log(value); +} +// zero +// one + +for (var [key, value] of myMap.entries()) { + console.log(key + " = " + value); +} +// 0 = zero +// 1 = one +</pre> + +<h3 id="Integration_von_Maps_mit_forEach">Integration von <code>Maps</code> mit <code>forEach()</code></h3> + +<p>Über Maps kann mit der <code>forEach()</code> method iteriert werden:</p> + +<pre class="brush: js">myMap.forEach(function(value, key) { + console.log(key + " = " + value); +}, myMap) +// Will show 2 logs; first with "0 = zero" and second with "1 = one" +</pre> + +<h3 id="Relation_mit_Array_Objekten">Relation mit <code>Array</code> Objekten</h3> + +<pre class="brush: js">var kvArray = [['key1', 'value1'], ['key2', 'value2']]; + +// Use the regular Map constructor to transform a 2D key-value Array into a map +var myMap = new Map(kvArray); + +myMap.get('key1'); // returns "value1" + +// Use the Array.from function to transform a map into a 2D key-value Array +console.log(Array.from(myMap)); // Will show you exactly the same Array as kvArray + +// Or use the keys or values iterators and convert them to an array +console.log(Array.from(myMap.keys())); // Will show ["key1", "key2"] +</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-map-objects', 'Map')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map-objects', 'Map')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697479">Map and Set bug at Mozilla</a></li> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets">ECMAScript Harmony proposal</a></li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/keys/index.html b/files/de/web/javascript/reference/global_objects/map/keys/index.html new file mode 100644 index 0000000000..0f8187752b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/keys/index.html @@ -0,0 +1,69 @@ +--- +title: Map.prototype.keys() +slug: Web/JavaScript/Reference/Global_Objects/Map/keys +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Map + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map/keys +--- +<div>{{JSRef}}</div> + +<p>Die Methode <code><strong>keys()</strong></code> gibt ein neues <code><strong><a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong></code> Objekt zurück, das die Schlüssel für alle Elemente des <code>Map</code> Objekts in der Reihenfolge des Einfügens enthält.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-keys.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.keys()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues {{jsxref("Map")}} Iterator-Objekt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_keys">Verwendung von <code>keys()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +var mapIter = myMap.keys(); + +console.log(mapIter.next().value); // "0" +console.log(mapIter.next().value); // 1 +console.log(mapIter.next().value); // Object +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.keys")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/prototype/index.html b/files/de/web/javascript/reference/global_objects/map/prototype/index.html new file mode 100644 index 0000000000..1c7b6350cf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/prototype/index.html @@ -0,0 +1,86 @@ +--- +title: Map.prototype +slug: Web/JavaScript/Reference/Global_Objects/Map/prototype +tags: + - JavaScript + - Map + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Map +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Map</strong></code><strong><code>.prototype</code></strong> Eigenschaft repräsentiert den Prototyp für den {{jsxref("Map")}} Konstruktor.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>{{jsxref("Map")}} Instanzen erben von {{jsxref("Map.prototype")}}. Man kann das prototype Objekt des Konstruktors nutzen, um Eigenschaften oder Methoden für alle <code>map</code> Instanzen hinzuzufügen.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Map.prototype.constructor</code></dt> + <dd>Gibt die Funktion zurück, die einen Instanzenprototype erstellt. Der Standardwert ist die {{jsxref("Map")}} Funktion.</dd> + <dt>{{jsxref("Map.prototype.size")}}</dt> + <dd>Gibt die Anzahl an Schlüssel/Werte-Paaren in dem <code>Map</code> Objekt zurück.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Map.prototype.clear()")}}</dt> + <dd>Entfernt alle Schlüssel/Werte-Paare von dem <code>Map</code> Objekt.</dd> + <dt>{{jsxref("Map.delete", "Map.prototype.delete(schlüssel)")}}</dt> + <dd>Gibt <code>true</code> zurück, wenn ein Element im <code>Map</code> Objekt existiert und gelöscht wird, oder <code>false</code> wenn das Element nicht existiert. <code>Map.prototype.has(schlüssel)</code> wird danach <code>false</code> zurückgeben.</dd> + <dt>{{jsxref("Map.prototype.entries()")}}</dt> + <dd>Gibt ein neues <code>Iterator</code> Objekt mit allen <strong><code>[Schlüssel, Wert]</code> Paaren als Array</strong> von jedem Element in dem <code>Map</code> Objekt in Einfügereihenfolge zurück.</dd> + <dt>{{jsxref("Map.forEach", "Map.prototype.forEach(callbackFn[, thisArg])")}}</dt> + <dd>Ruft <code>callbackFn</code> einmal für jedes Schlüssel/Wert Paar in dem <code>Map</code> Objekt in der Einfügereihenfolge aus. Wenn ein thisArg Parameter angegeben ist, wird dieser als <code>this</code> für jeden Funktionsaufruf benutzt.</dd> + <dt>{{jsxref("Map.get", "Map.prototype.get(schlüssel)")}}</dt> + <dd>Gibt den Wert zu dem zugehörigen <code>schlüssel</code> zurück oder <code>undefined</code> wenn dieser nicht existiert.</dd> + <dt>{{jsxref("Map.has", "Map.prototype.has(schlüssel)")}}</dt> + <dd>Gibt einen boolean zurück, der angibt, ob ein Wert mit den <code>schlüssel</code> in einem <code>Map</code> Objekt vorhanden ist oder nicht.</dd> + <dt>{{jsxref("Map.prototype.keys()")}}</dt> + <dd>Gibt ein neues <code>Iterator</code> Objekt mit allen Schlüsseln von jedem Element in dem <code>Map</code> Objekt in Einfügereihenfolge zurück.</dd> + <dt>{{jsxref("Map.set", "Map.prototype.set(schlüssel, wert)")}}</dt> + <dd>Setzt den <code>wert</code> für einen <code>schlüssel</code> im <code>Map</code> Objekt. Gibt das <code>Map</code> Objekt zurück.</dd> + <dt>{{jsxref("Map.prototype.values()")}}</dt> + <dd>Gibt ein neues <code>Iterator</code> Objekt mit allen Werten von jedem Element in dem <code>Map</code> Objekt in Einfügereihenfolge zurück.</dd> + <dt>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</dt> + <dd>Gibt ein neues <code>Iterator</code> Objekt mit allen <strong><code>[Schlüssel, Wert]</code> Paaren als Array</strong> von jedem Element in dem <code>Map</code> Objekt in Einfügereihenfolge zurück.</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('ES2015', '#sec-map.prototype', 'Map.prototype')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype', 'Map.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.prototype")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Set.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/set/index.html b/files/de/web/javascript/reference/global_objects/map/set/index.html new file mode 100644 index 0000000000..dd675fab69 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/set/index.html @@ -0,0 +1,96 @@ +--- +title: Map.prototype.set() +slug: Web/JavaScript/Reference/Global_Objects/Map/set +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map/set +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>set()</strong></code> Methode fügt ein ELement mit einem spezifischen <code>schlüssel</code> und <code>wert</code> zu einem <code>Map</code> Objekt hinzu oder aktualisiert es.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-set.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.set(schlüssel, wert);</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>schlüssel</dt> + <dd>Der Schlüssel des Elementes, welches zu dem <code>Map</code> Objekt hinzugefügt wird.</dd> + <dt>wert</dt> + <dd>Der Wert des Elementes, welches zu dem <code>Map</code> Objekt hinzugefügt wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das <code>Map</code> Objekt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_der_set_Methode">Einsatz der <code>set</code> Methode</h3> + +<pre class="brush: js">var myMap = new Map(); + +// Fügt ein neues Element hinzu +myMap.set('bar', 'foo'); +myMap.set(1, 'foobar'); + +// Aktualisiert ein Element +myMap.set('bar', 'baz'); +</pre> + +<h3 id="Einsatz_der_set_Methode_mit_Verkettung">Einsatz der <code>set</code> Methode mit Verkettung</h3> + +<p>Seit die <code>set()</code> Methode das selbe <code>Map</code> Objekt zurück gibt, kann die Methode wie folgt verkettet aufgerufen werden.</p> + +<pre class="brush: js">// Fügt neue Element mit verketteten Aufruf hinzu. +myMap.set('bar', 'foo') + .set(1, 'foobar') + .set(2, 'baz'); + +</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-map.prototype.set', 'Map.prototype.set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.set', 'Map.prototype.set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.set")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/size/index.html b/files/de/web/javascript/reference/global_objects/map/size/index.html new file mode 100644 index 0000000000..3f859dcde5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/size/index.html @@ -0,0 +1,67 @@ +--- +title: Map.prototype.size +slug: Web/JavaScript/Reference/Global_Objects/Map/size +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Map/size +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>size</strong></code> Zugriffseigenschaft gibt die Anzahl der Elemente in einem {{jsxref("Map")}} Objekt zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-size.html")}}</div> + + + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Der Wert von <code>size</code> ist eine ganze Zahl, die angibt, wie viele Einträge ein <code>Map</code> Objekt hat. Die set-Zugriffsfunktion für <code>size</code> ist <code>undefined</code>; diese Eigenschaft kann nicht geändert werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_size">Einsatz von <code>size</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('a', 'alpha'); +myMap.set('b', 'beta'); +myMap.set('g', 'gamma'); + +myMap.size // 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('ES2015', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.size")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/map/values/index.html b/files/de/web/javascript/reference/global_objects/map/values/index.html new file mode 100644 index 0000000000..3cbe8dd064 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/map/values/index.html @@ -0,0 +1,77 @@ +--- +title: Map.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Map/values +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Map + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map/values +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>values()</strong></code> Methode gibt ein neues <strong><a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong> Objekt mit allen Werten aller Elemente des <code>Map</code> Objektes in Einfügereihenfolge zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-values.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.values()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues {{jsxref("Map")}} Iterator Objekt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_values()">Einsatz von <code>values()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set('0', 'foo'); +myMap.set(1, 'bar'); +myMap.set({}, 'baz'); + +var mapIter = myMap.values(); + +console.log(mapIter.next().value); // "foo" +console.log(mapIter.next().value); // "bar" +console.log(mapIter.next().value); // "baz"</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-map.prototype.values', 'Map.prototype.values')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.values', 'Map.prototype.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Map.values")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.keys()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/acos/index.html b/files/de/web/javascript/reference/global_objects/math/acos/index.html new file mode 100644 index 0000000000..3512f639b1 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/acos/index.html @@ -0,0 +1,103 @@ +--- +title: Math.acos() +slug: Web/JavaScript/Reference/Global_Objects/Math/acos +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos +--- +<div>{{JSRef}}</div> + +<p>Die Funktion <code><strong>Math.acos()</strong></code> gibt den Arkuskosinus (im Radiantenmaß) einer Zahl zurück:</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> das gleiche </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>derart, dass</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ das gleiche } \; y \in [0; \pi] \, \text{derart, dass} \; \cos(y)</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-acos.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox">Math.acos(<em>x</em>) </pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Arkuskosinus (im Radiantenmaß) der übergebenen Zahl, wenn diese zwischen <strong>-1</strong> und <strong>1</strong> ist. Anderfalls wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die <code>acos</code> Methode gibt einen numerischen Wert zwischen 0 und {{jsxref("Math/PI", "Pi")}} im Radiantenmaß für x Werte zwischen -1 und 1 zurück. Wenn der übergebene Wert außerhalb dieses Bereiches liegt, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<p>Weil <code>acos</code> eine statische Methode von <code>Math</code> ist, kann dieses immer mit <code>Math.acos()</code> genutzt werden, ohne dass ein Objekt von <code>Math</code> erstellt werden muss (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.acos" name="Example:_Using_Math.acos">Beispiel: <code>Math.acos</code> benutzen</h3> + +<pre class="brush:js">Math.acos(-2); // NaN +Math.acos(-1); // 3.141592653589793 +Math.acos(0); // 1.5707963267948966 +Math.acos(0.5); // 1.0471975511965979 +Math.acos(1); // 0 +Math.acos(2); // NaN +</pre> + +<p>Für Werte kleiner -1 oder größer 1 gibt <code>Math.acos</code> {{jsxref("Global_Objects/NaN", "NaN")}} zurück.</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>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}}</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.Math.acos")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/acosh/index.html b/files/de/web/javascript/reference/global_objects/math/acosh/index.html new file mode 100644 index 0000000000..46703ec486 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/acosh/index.html @@ -0,0 +1,98 @@ +--- +title: Math.acosh() +slug: Web/JavaScript/Reference/Global_Objects/Math/acosh +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh +--- +<div>{{JSRef}}</div> + +<p>Die Funktion <strong><code>Math.acosh()</code></strong> gibt den hyperbolischen<span class="sentence" id="mt1"> </span>Arkuskosinus einer Zahl zurück:</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> das Ergebnis </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>so </mtext><mtext>dass</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cosh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } \; y \geq 0 \; \text{such that} \; \cosh(y) = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-acosh.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.acosh(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der hyperbolische Arkuskosinus der übergebenen Zahl. Wenn die Zahl kleiner als <strong>1</strong> ist, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>acosh()</code> eine statische Methode von <code>Math</code> ist, muss diese immer mit <code>Math.acosh()</code> genutzt werden, ohne dass ein Objekt von <code>Math</code> erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_Math.acosh()">Verwendung von <code>Math.acosh()</code></h3> + +<pre class="brush: js">Math.acosh(-1); // NaN +Math.acosh(0); // NaN +Math.acosh(0.5) // NaN +Math.acosh(1); // 0 +Math.acosh(2); // 1.3169578969248166 +</pre> + +<p>Für Werte kleiner 1 <code>Math.acosh()</code> gibt Math.acosh {{jsxref("NaN")}} zurück.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Für <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>1</mn></mrow><annotation encoding="TeX">x \geq 1</annotation></semantics></math> gilt: <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>-</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)</annotation></semantics></math>, daher kann dieses mit der folgenden Funktion emuliert werden:</p> + +<pre class="brush: js">Math.acosh = Math.acosh || function(x) { + return Math.log(x + Math.sqrt(x * x - 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('ES6', '#sec-math.acosh', 'Math.acosh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}}</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.Math.acosh")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/asin/index.html b/files/de/web/javascript/reference/global_objects/math/asin/index.html new file mode 100644 index 0000000000..bf69f52450 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/asin/index.html @@ -0,0 +1,103 @@ +--- +title: Math.asin() +slug: Web/JavaScript/Reference/Global_Objects/Math/asin +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin +--- +<div>{{JSRef}}</div> + +<p>Die Funktion <strong><code>Math.asin()</code></strong> gibt den Arkussinus (im Radiantenmaß) einer Zahl zurück:</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> das Ergebnis </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>so </mtext><mtext></mtext><mtext>dass</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-asin.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.asin(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Arkussinus (im Radiantenmaß) der übergebenen Zahl, die zwischen <strong>-1</strong> und <strong>1</strong> liegt. Andernfalls wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>Math.asin() </code>Methode gibt einen numerischen Wert zwischen <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> und <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> im Radiantenmaß für x Werte zwischen -1 und 1 zurück. Wenn der übergebene Wert außerhalb dieses Bereiches liegt, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<p><code>Weil asin()</code> eine statische Methode von <code>Math</code> ist, muss diese immer mit <code>Math.asin()</code> genutzt werden, ohne dass ein Objekt von <code>Math</code> erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_Math.asin()">Verwendung von <code>Math.asin()</code></h3> + +<pre class="brush: js">Math.asin(-2); // NaN +Math.asin(-1); // -1.5707963267948966 (-pi/2) +Math.asin(0); // 0 +Math.asin(0.5); // 0.5235987755982989 +Math.asin(1); // 1.5707963267948966 (pi/2) +Math.asin(2); // NaN +</pre> + +<p>Für Werte kleiner -1 oder größer als 1 gibt <code>Math.asin() </code>{{jsxref("NaN")}} zurück.</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>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}}</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.Math.asin")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/asinh/index.html b/files/de/web/javascript/reference/global_objects/math/asinh/index.html new file mode 100644 index 0000000000..fa5e1d0472 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/asinh/index.html @@ -0,0 +1,99 @@ +--- +title: Math.asinh() +slug: Web/JavaScript/Reference/Global_Objects/Math/asinh +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh +--- +<div>{{JSRef}}</div> + +<p>Die Funktion <strong><code>Math.asinh()</code></strong> gibt den hyperbolische<span class="sentence" id="mt1"> </span>Arkussinus (im Radiantenmaß) einer Zahl zurück:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arcsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> das Ergebnis </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>so </mtext><mtext></mtext><mtext>dass</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sinh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } \; y \; \text{such that} \; \sinh(y) = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-asinh.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.asinh(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der hyperbolische Arkussinus der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>Weil asinh()</code> eine statische Methode von <code>Math</code> ist, muss diese immer mit <code>Math.asinh()</code> genutzt werden, ohne dass ein Objekt von <code>Math</code> erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_Math.asinh()">Verwendung von <code>Math.asinh()</code></h3> + +<pre class="brush: js">Math.asinh(1); // 0.881373587019543 +Math.asinh(0); // 0 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Es gilt: <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>+</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX"></annotation></semantics></math>. Daher kann asinh mit der folgenden Funktion emuliert werden:</p> + +<pre class="brush: js">Math.asinh = Math.asinh || function(x) { + if (x === -Infinity) { + return x; + } else { + return Math.log(x + Math.sqrt(x * x + 1)); + } +}; +</pre> + +<p>Die formale Korrektheit hängt von einer Reihe von Problemen mit Floating-Point-Berechnungen ab. Genaue Ergebnisse erfordern die Behandlung von positiven/negativen, kleinen/großen Argumenten, wie es in <a href="https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/ieee754/dbl-64/s_asinh.c">glibc</a> oder <a href="http://git.savannah.gnu.org/cgit/gsl.git/tree/sys/invhyp.c">GNU Scientific Library</a> vorhanden ist.</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('ES6', '#sec-math.asinh', 'Math.asinh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}}</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.Math.asinh")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/atan/index.html b/files/de/web/javascript/reference/global_objects/math/atan/index.html new file mode 100644 index 0000000000..1c37c3dcc4 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/atan/index.html @@ -0,0 +1,105 @@ +--- +title: Math.atan() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan +--- +<div>{{JSRef}}</div> + +<p><code>Die Funktion </code><strong><code>Math.atan()</code></strong> gibt den Arkustangens (im Radiantenmaß) einer Zahl zurück:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> das Ergebnis </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>so </mtext><mtext>dass</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-atan.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.atan(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Arkustangens (im Radiantenmaß) der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>Die Math.atan()</code> Methode gibt einen numerischen Wert zwischen <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> und <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> im Radiantenmaß zurück.</p> + +<p><code>Weil atan()</code> eine statische Methode von Math ist, muss diese immer mit <code>Math.atan()</code> genutzt werden, ohne dass ein Objekt von Math erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_Math.atan()">Verwendung von <code>Math.atan()</code></h3> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Math<span class="punctuation token">.</span><span class="function token">atan</span><span class="punctuation token">(</span><span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// 0.7853981633974483</span> +Math<span class="punctuation token">.</span><span class="function token">atan</span><span class="punctuation token">(</span><span class="number token">0</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// 0</span> +Math<span class="punctuation token">.</span><span class="function token">atan</span><span class="punctuation token">(</span><span class="operator token">-</span><span class="number token">0</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// -0</span> + +Math<span class="punctuation token">.</span><span class="function token">atan</span><span class="punctuation token">(</span><span class="number token">Infinity</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// 1.5707963267948966</span> +Math<span class="punctuation token">.</span><span class="function token">atan</span><span class="punctuation token">(</span><span class="operator token">-</span><span class="number token">Infinity</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// -1.5707963267948966</span> + +<span class="comment token">// The angle that the line [(0,0);(x,y)] forms with the x-axis in a Cartesian coordinate system</span> +Math<span class="punctuation token">.</span><span class="function token">atan</span><span class="punctuation token">(</span>y <span class="operator token">/</span> x<span class="punctuation token">)</span><span class="punctuation token">;</span></code></pre> + +<p>Beachten Sie, dass es manchmal aus stilistischen Gründen gewollt ist, dass <strong>±</strong><code>Infinity</code> vermieden werden soll. In diesen Fällen kann die Funktion {{jsxref("Math.atan2()")}} mit <code>0</code> als zweiten Parameter bessere Ergebnisse liefern.</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>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}}</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.Math.atan")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/atan2/index.html b/files/de/web/javascript/reference/global_objects/math/atan2/index.html new file mode 100644 index 0000000000..5848a76898 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/atan2/index.html @@ -0,0 +1,113 @@ +--- +title: Math.atan2() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan2 +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2 +--- +<div>{{JSRef}}</div> + +<p><code>Die Funktion </code><strong><code>Math.atan2()</code></strong> gibt den Arkustangens (im Radiantenmaß) des Quotienten der Parameter zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-atan2.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.atan2(<var>y</var>, <var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>y</code></dt> + <dd>Eine Zahl.</dd> + <dt><code>x</code></dt> + <dd>Eine zweite Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Arkustangens des Quotienten der übergebenen Parameter.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>Math.atan2()</code> Methode gibt einen numerischen Wert zwischen -π und π zurück, welcher den Winkel Theta eines <code>(x, y)</code> Punktes wiedergibt. Dies ist der Radius entgegen dem Uhrzeigersinn, gemessen in Radianten, zwischen der positiven x Achse, und des Punktes <code>(x, y)</code>. Beachte, dass bei der Funktion der erste Parameter die y Koordinate und der zweite die x Koordinate ist.</p> + +<p><img alt="Ein einfaches Diagramm welches den zurückgegebenen Winkel von atan2(y, x) zeigt" src="https://mdn.mozillademos.org/files/11557/atan2.png" style="height: 300px; width: 300px;"></p> + +<p>Bei <code>Math.atan2()</code> wird <code>x</code> und <code>y</code> separat übergeben, bei <code>Math.atan()</code> hingegen wird das Verhältnis der zwei Parameter übergeben.</p> + +<p>Weil <code>atan2()</code> eine statische Methode von Math ist, muss diese immer mit <code>Math.atan2()</code> genutzt werden, ohne dass ein Objekt von Math erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_Math.atan2()"><code>Verwendung von Math.atan2()</code></h3> + +<pre class="brush: js">Math.atan2(90, 15); // 1.4056476493802699 +Math.atan2(15, 90); // 0.16514867741462683 + +Math.atan2(±0, -0); // ±PI. +Math.atan2(±0, +0); // ±0. +Math.atan2(±0, -x); // ±PI for x > 0. +Math.atan2(±0, x); // ±0 for x > 0. +Math.atan2(-y, ±0); // -PI/2 for y > 0. +Math.atan2(y, ±0); // PI/2 for y > 0. +Math.atan2(±y, -Infinity); // ±PI for finite y > 0. +Math.atan2(±y, +Infinity); // ±0 for finite y > 0. +Math.atan2(±Infinity, x); // ±PI/2 for finite x. +Math.atan2(±Infinity, -Infinity); // ±3*PI/4. +Math.atan2(±Infinity, +Infinity); // ±PI/4. +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}}</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.Math.atan2")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/cbrt/index.html b/files/de/web/javascript/reference/global_objects/math/cbrt/index.html new file mode 100644 index 0000000000..a24c572eb7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/cbrt/index.html @@ -0,0 +1,98 @@ +--- +title: Math.cbrt() +slug: Web/JavaScript/Reference/Global_Objects/Math/cbrt +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt +--- +<div>{{JSRef}}</div> + +<p>Die Funktion <strong><code>Math.cbrt()</code></strong> gibt die Kubikwurzel einer Zahl zurück:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>c</mi><mi>b</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><mtext>das </mtext><mtext>Ergebnis</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>so</mtext><mtext> </mtext><mtext> </mtext><mtext>dass</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>3</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-cbrt.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.cbrt(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Kubikwurzel der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>cbrt()</code> eine statische Methode von <code>Math</code> ist, muss diese immer mit <code>Math.cbrt()</code> genutzt werden, ohne dass ein Objekt von Math erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_Math.cbrt">Verwendung von <code>Math.cbrt()</code></h3> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Math<span class="punctuation token">.</span><span class="function token">cbrt</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">// NaN</span> +Math<span class="punctuation token">.</span><span class="function token">cbrt</span><span class="punctuation token">(</span><span class="operator token">-</span><span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// -1</span> +Math<span class="punctuation token">.</span><span class="function token">cbrt</span><span class="punctuation token">(</span><span class="operator token">-</span><span class="number token">0</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// -0</span> +Math<span class="punctuation token">.</span><span class="function token">cbrt</span><span class="punctuation token">(</span><span class="operator token">-</span><span class="number token">Infinity</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// -Infinity</span> +Math<span class="punctuation token">.</span><span class="function token">cbrt</span><span class="punctuation token">(</span><span class="number token">0</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// 0</span> +Math<span class="punctuation token">.</span><span class="function token">cbrt</span><span class="punctuation token">(</span><span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// 1</span> +Math<span class="punctuation token">.</span><span class="function token">cbrt</span><span class="punctuation token">(</span><span class="number token">Infinity</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// Infinity</span> +Math<span class="punctuation token">.</span><span class="function token">cbrt</span><span class="punctuation token">(</span><span class="keyword token">null</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// 0</span> +Math<span class="punctuation token">.</span><span class="function token">cbrt</span><span class="punctuation token">(</span><span class="number token">2</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// 1.2599210498948734</span></code></pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Für <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>0</mn></mrow><annotation encoding="TeX">x \geq 0</annotation></semantics></math> gilt <math><semantics><mrow><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><msup><mi>x</mi><mrow><mn>1</mn><mo>/</mo><mn>3</mn></mrow></msup></mrow><annotation encoding="TeX">\sqrt[3]{x} = x^{1/3}</annotation></semantics></math> so dass diese Funktion wie folgt emuliert werden kann:</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">if</span> <span class="punctuation token">(</span><span class="operator token">!</span>Math<span class="punctuation token">.</span>cbrt<span class="punctuation token">)</span> <span class="punctuation token">{</span> + Math<span class="punctuation token">.</span>cbrt <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span>x<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> y <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">pow</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">abs</span><span class="punctuation token">(</span>x<span class="punctuation token">)</span><span class="punctuation token">,</span> <span class="number token">1</span><span class="operator token">/</span><span class="number token">3</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> x <span class="operator token"><</span> <span class="number token">0</span> <span class="operator token">?</span> <span class="operator token">-</span>y <span class="punctuation token">:</span> y<span class="punctuation token">;</span> + <span class="punctuation token">}</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('ES6', '#sec-math.cbrt', 'Math.cbrt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}}</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.Math.cbrt")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/ceil/index.html b/files/de/web/javascript/reference/global_objects/math/ceil/index.html new file mode 100644 index 0000000000..06cf4808e7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/ceil/index.html @@ -0,0 +1,170 @@ +--- +title: Math.ceil() +slug: Web/JavaScript/Reference/Global_Objects/Math/ceil +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil +--- +<div>{{JSRef}}</div> + +<p>Die Funktion <strong><code>Math.ceil()</code></strong> gibt die nächste Ganzzahl, die größer oder gleich der gegebenen Zahl ist, zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-ceil.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.ceil(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die kleinste ganze Zahl größer oder gleich der übergebenen Zahl.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>Weil ceil()</code> eine statische Methode von Math ist, muss diese immer mit <code>Math.ceil()</code> genutzt werden, ohne dass ein Objekt von Math erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.ceil" name="Example:_Using_Math.ceil">Verwendung von <code>Math.ceil()</code></h3> + +<p>Das folgende Beispiel zeigt den exemplarischen Einsatz von <code>Math.ceil()</code>.</p> + +<pre class="brush: js">Math.ceil(.95); // 1 +Math.ceil(4); // 4 +Math.ceil(7.004); // 8 +Math.ceil(-0.95); // -0 +Math.ceil(-4); // -4 +Math.ceil(-7.004); // -7 +</pre> + +<h3 id="Example:_Decimal_adjustment" name="Example:_Decimal_adjustment">Dezimales anpassen</h3> + +<pre class="brush: js">// Closure +(function() { + /** + * Decimal adjustment of a number. + * + * @param {String} type The type of adjustment. + * @param {Number} value The number. + * @param {Integer} exp The exponent (the 10 logarithm of the adjustment base). + * @returns {Number} The adjusted value. + */ + function decimalAdjust(type, value, exp) { + // If the exp is undefined or zero... + if (typeof exp === 'undefined' || +exp === 0) { + return Math[type](value); + } + value = +value; + exp = +exp; + // If the value is not a number or the exp is not an integer... + if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { + return NaN; + } + // Shift + value = value.toString().split('e'); + value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))); + // Shift back + value = value.toString().split('e'); + return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)); + } + + // Decimal round + if (!Math.round10) { + Math.round10 = function(value, exp) { + return decimalAdjust('round', value, exp); + }; + } + // Decimal floor + if (!Math.floor10) { + Math.floor10 = function(value, exp) { + return decimalAdjust('floor', value, exp); + }; + } + // Decimal ceil + if (!Math.ceil10) { + Math.ceil10 = function(value, exp) { + return decimalAdjust('ceil', value, exp); + }; + } +})(); + +// Round +Math.round10(55.55, -1); // 55.6 +Math.round10(55.549, -1); // 55.5 +Math.round10(55, 1); // 60 +Math.round10(54.9, 1); // 50 +Math.round10(-55.55, -1); // -55.5 +Math.round10(-55.551, -1); // -55.6 +Math.round10(-55, 1); // -50 +Math.round10(-55.1, 1); // -60 +// Floor +Math.floor10(55.59, -1); // 55.5 +Math.floor10(59, 1); // 50 +Math.floor10(-55.51, -1); // -55.6 +Math.floor10(-51, 1); // -60 +// Ceil +Math.ceil10(55.51, -1); // 55.6 +Math.ceil10(51, 1); // 60 +Math.ceil10(-55.59, -1); // -55.5 +Math.ceil10(-59, 1); // -50 +</pre> + +<h2 id="Specifications" name="Specifications">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>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.ceil', 'Math.ceil')}}</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.Math.ceil")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/clz32/index.html b/files/de/web/javascript/reference/global_objects/math/clz32/index.html new file mode 100644 index 0000000000..ac7c78c4a7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/clz32/index.html @@ -0,0 +1,112 @@ +--- +title: Math.clz32() +slug: Web/JavaScript/Reference/Global_Objects/Math/clz32 +tags: + - ECMAScript 2015 + - Java + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.clz32()</code></strong> Funktion zählt die führenden Nullbits in der 32-Bit binär Repräsentation einer Nummer.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-clz32.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.clz32(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Nummer.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Anzahl der führenden Nullbits in der 32-Bit binör Repräsentation der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>"<code>clz32</code>" steht für <code>CountLeadingZeroes32 (<em>AnzahlFührenderNullen32</em>)</code>.</p> + +<p>Wenn <code>x</code> keine Nummer ist, wird <code>x</code> in eine Nummer konvertiert. Danach wird diese Nummer in einen 32-Bit vorzeichenlose Ganzzahl (unsigned integer) konvertiert.</p> + +<p>Wenn die konvertierte 32-Bit vorzeichenlose Zahl <code>0</code> ist, so wird die Funktion 32 zurück geben, weil alle Bits <code>0</code> sind.</p> + +<p>Diese Funktion ist nützlich für Systeme, die in zu JavaScript kompilieren (z. B. <a href="/en-US/docs/Emscripten">Emscripten</a>).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.clz32()">Einsatz von <code>Math.clz32()</code></h3> + +<pre class="brush: js">Math.clz32(1); // 31 +Math.clz32(1000); // 22 +Math.clz32(); // 32 + +[NaN, Infinity, -Infinity, 0, -0, null, undefined, 'foo', {}, []].filter( +function(n) { + return Math.clz32(n) !== 32 +}); // [] + +Math.clz32(true); // 31 +Math.clz32(3.5); // 30 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Der folgende Polyfill ist der effizienteste.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">if</span> <span class="punctuation token">(</span><span class="operator token">!</span>Math<span class="punctuation token">.</span>clz32<span class="punctuation token">)</span> <span class="punctuation token">{</span> + Math<span class="punctuation token">.</span>clz32 <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span>x<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="comment token">// Let n be ToUint32(x).</span> + <span class="comment token">// Let p be the number of leading zero bits in </span> + <span class="comment token">// the 32-bit binary representation of n.</span> + <span class="comment token">// Return p. </span> + <span class="keyword token">if</span> <span class="punctuation token">(</span>x <span class="operator token">==</span> <span class="keyword token">null</span> <span class="operator token">||</span> x <span class="operator token">===</span> <span class="number token">0</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">return</span> <span class="number token">32</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> <span class="number token">31</span> <span class="operator token">-</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>x <span class="operator token">></span><span class="operator token">></span><span class="operator token">></span> <span class="number token">0</span><span class="punctuation token">)</span> <span class="operator token">*</span> Math<span class="punctuation token">.</span>LOG2E<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</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">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-math.clz32', 'Math.clz32')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.clz32', 'Math.clz32')}}</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.Math.clz32")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math")}}</li> + <li>{{jsxref("Math.imul")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/cos/index.html b/files/de/web/javascript/reference/global_objects/math/cos/index.html new file mode 100644 index 0000000000..300908a90b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/cos/index.html @@ -0,0 +1,98 @@ +--- +title: Math.cos() +slug: Web/JavaScript/Reference/Global_Objects/Math/cos +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.cos()</code></strong> Funktion gibt den <span class="seoSummary">{{interwiki("wikipedia", "Cosinus")}}</span> eines Winkels zurück. Der Winkel muss im <span class="seoSummary">{{interwiki("wikipedia", "Bogenmaß")}}</span> angegeben werden. Der Wert ist <math style="display: inline;"> <mstyle displaystyle="true"> <mfrac> <msub> <mrow> <mtext>length</mtext> </mrow> <mrow> <mrow> <mtext>adjacent</mtext> </mrow> </mrow> </msub> <msub> <mrow> <mtext>length</mtext> </mrow> <mrow> <mrow> <mtext>hypotenuse</mtext> </mrow> </mrow> </msub> </mfrac> </mstyle> </math>.<span style="display: none;"> </span></p> + +<div>{{EmbedInteractiveExample("pages/js/math-cos.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.cos(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl im Winkelmaß (rad).</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Cosinus der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>Math.cos()</code> Funktion gibt einen nummerischen Wert zwischen -1 und 1 zurück. Dieser repräsentiert den Cosinus des Winkels.</p> + +<p>Weil <code>cos()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.cos()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.cos()">Einsatz von <code>Math.cos()</code></h3> + +<pre class="brush: js">Math.cos(0); // 1 +Math.cos(1); // 0.5403023058681398 + +Math.cos(Math.PI); // -1 +Math.cos(2 * Math.PI); // 1 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikationen</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.7', 'Math.cos')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.cos', 'Math.cos')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}}</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.Math.cos")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/cosh/index.html b/files/de/web/javascript/reference/global_objects/math/cosh/index.html new file mode 100644 index 0000000000..9b24cbbeaf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/cosh/index.html @@ -0,0 +1,102 @@ +--- +title: Math.cosh() +slug: Web/JavaScript/Reference/Global_Objects/Math/cosh +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.cosh()</code></strong> Funktion gibt den Cosinus Hyperbolicus einer Zahl zurück. Dieser kann mit dem Einsatz der {{jsxref("Math.E", "Eulerschen Zahl", "", 1)}} folgendermaßen berechnet werden:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.cosh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-cosh.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.cosh(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der hyperbolische Cosinus der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>cosh()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.cosh()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.cosh()">Einsatz von <code>Math.cosh()</code></h3> + +<pre class="brush: js">Math.cosh(0); // 1 +Math.cosh(1); // 1.5430806348152437 +Math.cosh(-1); // 1.5430806348152437 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion kann mit Hilfe der Funktion {{jsxref("Math.exp()")}} emuliert werden:</p> + +<pre class="brush: js">Math.cosh = Math.cosh || function(x) { + return (Math.exp(x) + Math.exp(-x)) / 2; +} +</pre> + +<p>Oder nur mit einem Aufruf der {{jsxref("Math.exp()")}} Funktion:</p> + +<pre class="brush: js">Math.cosh = Math.cosh || function(x) { + var y = Math.exp(x); + return (y + 1 / y) / 2; +}; +</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-math.cosh', 'Math.cosh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.cosh', 'Math.cosh')}}</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.Math.cosh")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/e/index.html b/files/de/web/javascript/reference/global_objects/math/e/index.html new file mode 100644 index 0000000000..1ba5bd74d5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/e/index.html @@ -0,0 +1,83 @@ +--- +title: Math.E +slug: Web/JavaScript/Reference/Global_Objects/Math/E +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/E +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Math.E</strong></code> Eigenschaft repräsentiert die Basis des natürlichen Logarithmus, was gerundet 2,718 ist.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2,718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2,718</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-e.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Weil <code>E</code> eine statische Eigenschaft von <code>Math</code> ist, muss immer <code>Math.E</code> genutzt werden, ohne dass ein <code>Math</code> Objekt erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.E" name="Example:_Using_Math.E">Einsatz von <code>Math.E</code></h3> + +<p>Die folgende Funktion gibt <em>e</em> zurück:</p> + +<pre class="brush: js">function getNapier() { + return Math.E +} + +getNapier() // 2.718281828459045</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.e', 'Math.E')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.e', 'Math.E')}}</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.Math.E")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/exp/index.html b/files/de/web/javascript/reference/global_objects/math/exp/index.html new file mode 100644 index 0000000000..df215203d8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/exp/index.html @@ -0,0 +1,95 @@ +--- +title: Math.exp() +slug: Web/JavaScript/Reference/Global_Objects/Math/exp +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.exp()</code></strong> Funktion gibt <code>e<sup>x</sup></code> zurück, wobei <code>x</code> der Parameter ist. <code>e</code> ist die {{jsxref("Math.E", "Eulersche Zahl", "", 1)}}, die Basis des natürlichen Logarithmus.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-exp.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.exp(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Zahl, die <code>e<sup>x</sup></code> repräsentiert, wobei <code>e</code> die {{jsxref("Math.E", "Eulersche Zahl", "", 1)}} ist und <code>x</code> die übergebene Zahl ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>exp()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.</code><code>exp</code><code>()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.exp()">Einsatz von <code>Math.exp()</code></h3> + +<pre class="brush: js">Math.exp(-1); // 0.36787944117144233 +Math.exp(0); // 1 +Math.exp(1); // 2.718281828459045 +</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">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.8', 'Math.exp')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.exp', 'Math.exp')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.exp', 'Math.exp')}}</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.Math.exp")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.E")}}</li> + <li>{{jsxref("Math.expm1()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/expm1/index.html b/files/de/web/javascript/reference/global_objects/math/expm1/index.html new file mode 100644 index 0000000000..b257953d87 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/expm1/index.html @@ -0,0 +1,94 @@ +--- +title: Math.expm1() +slug: Web/JavaScript/Reference/Global_Objects/Math/expm1 +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.expm1()</code></strong> Funktion gibt <code>e<sup>x</sup> - 1</code> zurück, wobei <code>x</code> der Parameter ist. <code>e</code> ist die {{jsxref("Math.E", "Eulersche Zahl", "", 1)}}, die Basis des natürlichen Logarithmus.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-expm1.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.expm1(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Zahl, die <code>e<sup>x</sup> - 1</code> repräsentiert, wobei <code>e</code> die {{jsxref("Math.E", "Eulersche Zahl", "", 1)}} und <code>x</code> die übergebene Zahl ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>expm1()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.</code><code>expm1</code><code>()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.expm1()">Einsatz von <code>Math.expm1()</code></h3> + +<pre class="brush: js">Math.expm1(-1); // -0.6321205588285577 +Math.expm1(0); // 0 +Math.expm1(1); // 1.718281828459045 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion kann mit Hilfe der Funktion {{jsxref("Math.exp()")}} emitiert werden:</p> + +<pre class="brush: js">Math.expm1 = Math.expm1 || function(x) { + return Math.exp(x) - 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">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.expm1', 'Math.expm1')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}}</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.Math.expm1")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.E")}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/floor/index.html b/files/de/web/javascript/reference/global_objects/math/floor/index.html new file mode 100644 index 0000000000..68f8bf86fa --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/floor/index.html @@ -0,0 +1,137 @@ +--- +title: Math.floor() +slug: Web/JavaScript/Reference/Global_Objects/Math/floor +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.floor()</code></strong> Funktion gibt den größten Integer zurück, der kleiner oder gleich der gegeben Nummer ist. (Abrunden) </p> + +<div>{{EmbedInteractiveExample("pages/js/math-floor.html")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Math.floor(<var>x</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine größte ganze Zahl, die kleiner oder gleich der übergebenen Zahl ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>floor()</code> eine statische Methode von <code>Math</code> ist, wird sie immer als<code> Math.floor() </code>aufgerufen und nicht als eine Methode eines erstellten <code>Math</code> Objektes (<code>Math </code>ist kein Konstruktor).</p> + +<div class="blockIndicator note"> +<p><strong>Hinweis: </strong><code>Math.floor(null)</code> gibt 0, aber nicht {{jsxref("NaN")}}, zurück.</p> +</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.floor">Einsatz von <code>Math.floor()</code></h3> + +<pre class="brush: js">Math.floor(45.95); // 45 +Math.floor(45.05); // 45 +Math.floor(4); // 4 +Math.floor(-45.05); // -46 +Math.floor(-45.95); // -46 +</pre> + +<h3 id="Dezimale_Justierung">Dezimale Justierung</h3> + +<pre class="brush: js">/** + * Decimal adjustment of a number. + * + * @param {String} type The type of adjustment. + * @param {Number} value The number. + * @param {Integer} exp The exponent (the 10 logarithm of the adjustment base). + * @returns {Number} The adjusted value. + */ +function decimalAdjust(type, value, exp) { + // If the exp is undefined or zero... + if (typeof exp === 'undefined' || +exp === 0) { + return Math[type](value); + } + value = +value; + exp = +exp; + // If the value is not a number or the exp is not an integer... + if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { + return NaN; + } + // Shift + value = value.toString().split('e'); + value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))); + // Shift back + value = value.toString().split('e'); + return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)); +} + +// Decimal round +const round10 = (value, exp) => decimalAdjust('round', value, exp); +// Decimal floor +const floor10 = (value, exp) => decimalAdjust('floor', value, exp); +// Decimal ceil +const ceil10 = (value, exp) => decimalAdjust('ceil', value, exp); + +// Round +round10(55.55, -1); // 55.6 +round10(55.549, -1); // 55.5 +round10(55, 1); // 60 +round10(54.9, 1); // 50 +round10(-55.55, -1); // -55.5 +round10(-55.551, -1); // -55.6 +round10(-55, 1); // -50 +round10(-55.1, 1); // -60 +// Floor +floor10(55.59, -1); // 55.5 +floor10(59, 1); // 50 +floor10(-55.51, -1); // -55.6 +floor10(-51, 1); // -60 +// Ceil +ceil10(55.51, -1); // 55.6 +ceil10(51, 1); // 60 +ceil10(-55.59, -1); // -55.5 +ceil10(-59, 1); // -50 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.floor', 'Math.floor')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Math.floor")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/fround/index.html b/files/de/web/javascript/reference/global_objects/math/fround/index.html new file mode 100644 index 0000000000..de905d6637 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/fround/index.html @@ -0,0 +1,112 @@ +--- +title: Math.fround() +slug: Web/JavaScript/Reference/Global_Objects/Math/fround +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/fround +--- +<div>{{JSRef}}</div> + +<p class="seoSummary">Die <strong><code>Math.fround()</code></strong> Funktion gibt die am nächsten gelegenen <a class="external" href="https://de.wikipedia.org/wiki/Einfache_Genauigkeit" title="link to the wikipedia page on single-precision floating-point format">32 Bit einfach genaue</a> Repräsentation einer {{jsxref("Number")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-fround.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>var singleFloat = Math.fround(<var>doubleFloat</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>doubleFloat</code></dt> + <dd>Eine {{jsxref("Number")}}. Wenn der Parameter von einem anderen Typ ist, wird dieser zu einer Zahl konvertiert oder wenn er nicht konvertiert werden kann {{jsxref("NaN")}}.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die am nächsten gelegenen <a class="external" href="https://de.wikipedia.org/wiki/Einfache_Genauigkeit" title="link to the wikipedia page on single-precision floating-point format">32 Bit einfach genaue</a> Repräsentation einer Floatingpoint-Nummer, der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>JavaScript benutzt intern 64 Bit double Gleitkommazahlen, welche eine hohe Präzision haben. Manchmal ist es gewollt mit 32 Bit Gleitkommazahlen zu arbeiten, zum Beispiel, wenn von einem von einem {{jsxref("Float32Array")}} gelesen wird. Das kann verwirrend sein: Prüfen einer 64 Bit Gleitkommazahl und einer 32 Bit Gleitkommazahl auf Gleichheit kann fehlschlagen, auch wenn sie scheinbar identisch sind.</p> + +<p>Um das zu beheben, kann <code>Math.fround()</code> eingesetzt werden um 64 Bit Gleitkommazahlen in 32 Bit Gleitkommazahlen umzuwandeln. Intern wird JavaScript die Zahl als 64 Bit Gleitkommazahl benutzen, es wird jedoch ein "Runden zu geraden Zahlen" (round to even) an der 23. Stelle der Mantisse vorgenommen und alle folgenden Stellen der Mantisse auf <code>0</code> gesetzt. Wenn die Zahl außerhalb des 32 Bit Gleitkommazahlenbereiches liegt wird {{jsxref("Infinity")}} oder <code>-Infinity</code> zurückgegeben.</p> + +<p>Weil <code>fround()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.</code><code>fround</code><code>()</code> eingesetzt, jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.fround()">Einsatz von <code>Math.fround()</code></h3> + +<p>Die Zahl 1-5 kan präzise im Binärsystem dargestellt werden und ist identisch in 32 Bit und 64 Bit:</p> + +<pre class="brush: js">Math.fround(1.5); // 1.5 +Math.fround(1.5) === 1.5 // true</pre> + +<p>Die Zahl 1.337 kan nicht präzise in Binärsystem dargestellt werden und unterscheidet sich in 32 Bit und 64 Bit:</p> + +<pre class="brush: js">Math.fround(1.337); //1.3370000123977661 +Math.fround(1.337) === 1.337; // false +</pre> + +<p><math><semantics><msup><mn>2</mn><mn>150</mn></msup><annotation encoding="TeX">2^150</annotation></semantics></math> ist zu groß für eine 32 Bit Gleitkommazahl, weshalb <code>Infinity</code> zurückgegeben wird.</p> + +<pre class="brush: js">2 ** 150; // 1.42724769270596e+45 +Math.fround(2 ** 150); // Infinity +</pre> + +<p>Wenn der Parameter nicht zu einer Zahl konvertiert werden kann, oder <a href="https://de.wikipedia.org/wiki/NaN">keine Zahl ist (NaN)</a>, gibt <code>Math.fround()</code> <code>NaN</code> zurück:</p> + +<pre class="brush: js">Math.fround('abc'); // NaN +Math.fround(NaN); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion kann emuliert werden, wenn {{jsxref("Float32Array")}} verfügbar ist:</p> + +<pre class="brush: js">Math.fround = Math.fround || (function (array) { + return function(x) { + return array[0] = x, array[0]; + }; +})(Float32Array(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('ES6', '#sec-math.fround', 'Math.fround')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.fround', 'Math.fround')}}</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.Math.fround")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.round()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/hypot/index.html b/files/de/web/javascript/reference/global_objects/math/hypot/index.html new file mode 100644 index 0000000000..b88861e06d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/hypot/index.html @@ -0,0 +1,128 @@ +--- +title: Math.hypot() +slug: Web/JavaScript/Reference/Global_Objects/Math/hypot +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.hypot()</code></strong> Funktion gibt die Quadratwurzel von der Summe der quadrierten Argumente zurück. Das bedeutet</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.hypot</mo><mo stretchy="false">(</mo><msub><mi>v</mi><mn>1</mn></msub><mo>,</mo><msub><mi>v</mi><mn>2</mn></msub><mo>,</mo><mo>…</mo><mo>,</mo><msub><mi>v</mi><mi>n</mi></msub><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mrow><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></munderover><msubsup><mi>v</mi><mi>i</mi><mn>2</mn></msubsup></mrow></msqrt><mo>=</mo><msqrt><mrow><msubsup><mi>v</mi><mn>1</mn><mn>2</mn></msubsup><mo>+</mo><msubsup><mi>v</mi><mn>2</mn><mn>2</mn></msubsup><mo>+</mo><mo>…</mo><mo>+</mo><msubsup><mi>v</mi><mi>n</mi><mn>2</mn></msubsup></mrow></msqrt></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-hypot.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.hypot([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>value1, value2, ...</code></dt> + <dd>Zahlen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Quadratwurzel der Summe der quadrierten übergebenen Parameter. Wenn ein Parameter nicht in eine Zahl konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span id="result_box" lang="de"><span>Das Berechnen der Hypotenuse eines rechtwinkligen Dreiecks oder die Größe einer komplexen Zahl verwendet die Formel <code>Math.sqrt (v1 * v1 + v2 * v2)</code>, wobei v1 und v2 entweder die Seiten des Dreiecks oder die reellen und komplexen Werte sind. </span></span><span id="result_box" lang="de"><span>Zum Berechnen der Entfernung in 2 oder mehr Dimensionen fügt man einfach weitere Quadrate innerhalb des Quadratwurzelzeichens ein, wie z. B. <code>Math.sqrt (v1 * v1 + v2 * v2 + v3 * v3 + v4 * v4)</code>.</span></span></p> + +<p>Diese Funktion macht es ein bisschen einfacher und schneller, man kann einfach <code>Math.hypot(v1, v2)</code> , or <code>Math.hypot(v1, v2, v3, v4, ...)</code> aufrufen.</p> + +<p><span id="result_box" lang="de"><span>Sie vermeidet zudem ein Problem, wenn Zahlen sehr groß werden. Die größte Zahl, die in JavaScript dargestellt werden kann ist </span></span><span style="line-height: 1.5;"><code>Number.MAX_VALUE = 1.797...e+308</code>. Wenn die Zahlen größer als <code>1e154</code> sind, wird das Quadrieren</span> dieser zu dem ergebnis <code><span style="line-height: 1.5;">Infinity</span></code><span style="line-height: 1.5;"> führen und das Ergebnis zerstören. Zum Beispiel: <code>Math.sqrt(1e200*1e200 + 1e200*1e200) = Infinity</code>. Wenn <code>hypot()</code> stattdessen benutzt wird bekommt man ein gutes Ergebnis: <code>Math.hypot(1e200, 1e200) = 1.4142...e+200</code>. Diese gilt auch für sehr kleine Zahlen. <code>Math.sqrt(1e-200*1e-200 + 1e-200*1e-200) = 0</code>, wohingegen </span><code><span style="line-height: 1.5;">Math.hypot(1e-200, 1e-200) =</span></code><span style="line-height: 1.5;"><code>1.4142...e-200</code> eine gute Lösung ist.</span></p> + +<p>Weil <code>hypot()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.hypot()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<p>Wenn kein Argument übergeben wird, ist das Ergebnis <code>+0</code>.</p> + +<p>Wenn einer der übergebenen Parameter nicht zu einer Zahl konvertiert werden kann, ist das Ergebnis {{jsxref("NaN")}}.</p> + +<p>Wenn nur ein Argument übergeben wird, so sind die Ergebnisse der Funktionen <code>Math.hypot()</code> und {{jsxref("Math.abs()")}} gleich.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.hypot()">Einsatz von <code>Math.hypot()</code></h3> + +<pre class="brush: js">Math.hypot(3, 4); // 5 +Math.hypot(3, 4, 5); // 7.0710678118654755 +Math.hypot(); // 0 +Math.hypot(NaN); // NaN +Math.hypot(3, 4, 'foo'); // NaN, +'foo' => NaN +Math.hypot(3, 4, '5'); // 7.0710678118654755, +'5' => 5 +Math.hypot(-3); // 3, das gleiche wie Math.abs(-3) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion kann folgendermaßen emuliert werden:</p> + +<pre class="brush: js">Math.hypot = Math.hypot || function() { + var y = 0, i = arguments.length; + while (i--) y += arguments[i] * arguments[i]; + return Math.sqrt(y); +}; +</pre> + +<p>Ein Polyfill der Underflows und Overflows vermeidet:</p> + +<pre class="brush: js">Math.hypot = function (x, y) { + // https://bugzilla.mozilla.org/show_bug.cgi?id=896264#c28 + var max = 0; + var s = 0; + for (var i = 0; i < arguments.length; i += 1) { + var arg = Math.abs(Number(arguments[i])); + if (arg > max) { + s *= (max / arg) * (max / arg); + max = arg; + } + s += arg === 0 && max === 0 ? 0 : (arg / max) * (arg / max); + } + return max === 1 / 0 ? 1 / 0 : max * Math.sqrt(s); +}; +</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-math.hypot', 'Math.hypot')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}}</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.Math.hypot")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/imul/index.html b/files/de/web/javascript/reference/global_objects/math/imul/index.html new file mode 100644 index 0000000000..ea3bc9abf3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/imul/index.html @@ -0,0 +1,92 @@ +--- +title: Math.imul() +slug: Web/JavaScript/Reference/Global_Objects/Math/imul +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/imul +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.imul()</code></strong> Funktion führt eine C ähnliche 32-Bit Multiplikation der zwei Parameter durch.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-imul.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.imul(<var>a</var>, <var>b</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>a</code></dt> + <dd>Erste Nummer.</dd> + <dt><code>b</code></dt> + <dd>Zweite Nummer.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das Resultat der C-ähnlichen 32-Bit Multiplikation der übergebenen Parameter.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>Math.imul()</code> erlaubt es schnelle 32-Bit Ganzzahlmultiplikationen mit C ähnlicher Semantik durchzuführen. Diese Funktion ist nützlich für Projekte wie <a href="http://en.wikipedia.org/wiki/Emscripten">Emscripten</a>. Weil <code>imul()</code> eine statische Methode von <code>Math</code> ist, muss man immer <code>Math.imul()</code> benutzen und nicht als Methode eines <code>Math</code> Objektes, das man erzeugt (<code>Math</code> ist kein Konstruktor). Wenn normale JavaScript Gleitkommazahlen in <code>imul</code> eingesetzt werden, wird die Performance beeinträchtigt. Das ist wegen der Umwandlung von Gleitkommazahlen zu ganzen Zahlen für die Multiplikation und die anschließende Rückkonvertierung des Ergebnisses in eine Gleitkommazahl. Der Grund warum <code>imul</code> existiert, ist, dass esin (nur) einem Fall schneller ist: AsmJS. AsmJS erlaubt JIST-Optimierungen für einfache Implementierung von ganzen Zahlen in JavaScript. Multiplizieren von zwei Zahlen mit <code>imul</code>, die intern als Integer dargestellt sind (was nur mit AsmJS funktioniert) ist der einzige Grund, wo <code>Math.imul</code> die Performance im Browsern steigern kann.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.imul()">Einsatz von <code>Math.imul()</code></h3> + +<pre class="brush: js">Math.imul(2, 4); // 8 +Math.imul(-1, 8); // -8 +Math.imul(-2, -2); // 4 +Math.imul(0xffffffff, 5); // -5 +Math.imul(0xfffffffe, 5); // -10 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktionalität kann durch folgende Funktion emuliert werden:</p> + +<pre class="brush: js">Math.imul = Math.imul || function(a, b) { + var aHi = (a >>> 16) & 0xffff; + var aLo = a & 0xffff; + var bHi = (b >>> 16) & 0xffff; + var bLo = b & 0xffff; + // the shift by 0 fixes the sign on the high part + // the final |0 converts the unsigned value into a signed value + return ((aLo * bLo) + (((aHi * bLo + aLo * bHi) << 16) >>> 0) | 0); +}; +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.imul', 'Math.imul')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.imul', 'Math.imul')}}</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.Math.imul")}}</p> diff --git a/files/de/web/javascript/reference/global_objects/math/index.html b/files/de/web/javascript/reference/global_objects/math/index.html new file mode 100644 index 0000000000..7dd7493568 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/index.html @@ -0,0 +1,201 @@ +--- +title: Math +slug: Web/JavaScript/Reference/Global_Objects/Math +tags: + - JavaScript + - Math + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math +--- +<div>{{JSRef}}</div> + +<p><strong>Math</strong> ist ein Standardobjekt, das Eigenschaften und Methoden für mathematische Konstanten und Funktionen besitzt. Es ist kein Funktionsobjekt.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Im Unterschied zu den anderen globalen Objekten hat <code>Math</code> keinen Konstruktor. Alle Eigenschaften und Methoden von <code>Math</code> sind statisch. Um die Konstante Pi zu erreichen, wird <code>Math.PI</code> genutzt. Die Sinusfunktion wird mit <code>Math.sin(x)</code> ausgeführt, wobei x der Methodenparameter ist. Konstanten sind so präzise wie der Typ <code>number</code> in JavaScript.</p> + +<h2 id="Properties" name="Properties">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("Math.E")}}</dt> + <dd>Eulersche Zahl und die Basis für den natürlichen Logarithmus (gerundet 2,718).</dd> +</dl> + +<dl> + <dt>{{jsxref("Math.LN2")}}</dt> + <dd>Natürlicher Logarithmus von 2 (gerundet 0,693).</dd> + <dt>{{jsxref("Math.LN10")}}</dt> + <dd>Natürlicher Logarithmus von 10 (gerundet 2,303).</dd> + <dt>{{jsxref("Math.LOG2E")}}</dt> + <dd>Logarithmus zur Basis 2 von der Eulerschen Zahl (gerundet 1,443).</dd> + <dt>{{jsxref("Math.LOG10E")}}</dt> + <dd>Logarithmus zur Basis 10 von der Eulerschen Zahl (gerundet 0,434).</dd> + <dt>{{jsxref("Math.PI")}}</dt> + <dd>Kreiszahl Pi, welche als Verhältnis zwischen Kreisumfang und Durchmesser definiert ist (gerundet 3,14159).</dd> + <dt>{{jsxref("Math.SQRT1_2")}}</dt> + <dd>Quadratwurzel aus 1/2 oder 1 geteilt durch die Quadratwurzel von 2 (gerundet 0,707).</dd> + <dt>{{jsxref("Math.SQRT2")}}</dt> + <dd>Quadratwurzel aus 2 (gerundet 1,414).</dd> +</dl> + +<h2 id="Methods" name="Methods">Methoden</h2> + +<div class="note"><strong>Anmerkung</strong>: Die trigonometrischen Funktionen (<code>sin()</code>, <code>cos()</code>, <code>tan()</code>, <code>asin()</code>, <code>acos()</code>, <code>atan()</code>, <code>atan2()</code>) erwarten Parameter und geben Rückgabewerte im Bogenmaß zurück. Um dieses in das Gradmaß umzurechnen, teilt man durch <code>(Math.PI / 180)</code> und multipliziert das Ergebnis mit der Bogenmaß.</div> + +<div class="note"><strong>Anmerkung:</strong> Bei vielen mathematischen Funktionen ist die Präzision implementationsabhängig. Das bedeutet, dass es bei verschiedenen Browsern verschiedene Ergebnisse geben kann. Auch in der gleichen JavaScript-Umgebung auf verschiedenen Betriebssystemen oder Architekturen können Abweichungen entstehen.</div> + +<dl> +</dl> + +<dl> + <dt>{{jsxref("Global_Objects/Math/abs", "Math.abs(x)")}}</dt> + <dd>Gibt den Betrag einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/acos", "Math.acos(x)")}}</dt> + <dd>Gibt den Arcus Cosinus einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/acosh", "Math.acosh(x)")}}</dt> + <dd>Gibt den Areacosinus Hyperbolicus einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/asin", "Math.asin(x)")}}</dt> + <dd>Gibt den Arcus Sinus einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/asinh", "Math.asinh(x)")}}</dt> + <dd>Gibt den Areasinus Hyperbolicus einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/atan", "Math.atan(x)")}}</dt> + <dd>Gibt den Arcus Tangens einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/atanh", "Math.atanh(x)")}}</dt> + <dd>Gibt den Areatangens Hyperbolicus einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/atan2", "Math.atan2(y, x)")}}</dt> + <dd>Gibt den Arcus Tangens aus dem Quotienten der Argumente zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/cbrt", "Math.cbrt(x)")}}</dt> + <dd>Gibt die Kubikwurzel einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/ceil", "Math.ceil(x)")}}</dt> + <dd>Gibt die kleinste ganze Zahl zurück, die größer oder gleich dem Parameter ist.</dd> + <dt>{{jsxref("Global_Objects/Math/clz32", "Math.clz32(x)")}}</dt> + <dd>Gibt die Anzahl der voranstehenden 0-Bits einer 32-Bit-Repräsentation zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/cos", "Math.cos(x)")}}</dt> + <dd>Gibt den Cosinus einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/cosh", "Math.cosh(x)")}}</dt> + <dd>Gibt den Cosinus Hyperbolicus einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/exp", "Math.exp(x)")}}</dt> + <dd>Gibt E<sup>x</sup> zurück, wobei x der Parameter und E die Eulersche Zahl ist.</dd> + <dt>{{jsxref("Global_Objects/Math/expm1", "Math.expm1(x)")}}</dt> + <dd>Gibt exp(x) - 1 zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/floor", "Math.floor(x)")}}</dt> + <dd>Rundet eine Zahl auf eine ganze Zahl ab.</dd> + <dt>{{jsxref("Global_Objects/Math/fround", "Math.fround(x)")}}</dt> + <dd>Gibt die am nächsten liegende <a href="http://de.wikipedia.org/wiki/Einfache_Genauigkeit">einfache genaue</a> Gleitkommazahl des Parameters zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/hypot", "Math.hypot([x[,y[,…]]])")}}</dt> + <dd>Gibt die Quadratwurzel aus der Summe der quadrierten Parameterwerte zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/imul", "Math.imul(x)")}}</dt> + <dd>Gibt das Ergebnis einer 32-Bit-Ganzzahlmultiplikation zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/log", "Math.log(x)")}}</dt> + <dd>Gibt den natürlichen Logarithmus (log<sub>e</sub> oder ln) einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/log1p", "Math.log1p(x)")}}</dt> + <dd>Gibt den natürlichen Logarithmus (log<sub>e</sub> oder ln) einer mit 1 addierten Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/log10", "Math.log10(x)")}}</dt> + <dd>Gibt den Logarithmus zur Basis 10 einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/log2", "Math.log2(x)")}}</dt> + <dd>Gibt den Logarithmus zur Basis 2 einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/max", "Math.max([x[,y[,…]]])")}}</dt> + <dd>Gibt die größte von null oder mehr Zahlen zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/min", "Math.min([x[,y[,…]]])")}}</dt> + <dd>Gibt die kleinste von null oder mehr Zahlen zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/pow", "Math.pow(x,y)")}}</dt> + <dd>Gibt die Potenz zweier Zahlen zurück (x<sup>y</sup>).</dd> + <dt>{{jsxref("Global_Objects/Math/random", "Math.random()")}}</dt> + <dd>Gibt eine Pseudozufallszahl zwischen 0 und 1 zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/round", "Math.round(x)")}}</dt> + <dd>Gibt den ganzzahlig gerundeten Wert des Parameters zurück.</dd> +</dl> + +<dl> + <dt>{{jsxref("Global_Objects/Math/sign", "Math.sign(x)")}}</dt> + <dd>Gibt das Vorzeichen (positiv, negativ, 0) von x zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/sin", "Math.sin(x)")}}</dt> + <dd>Gibt den Sinus einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/sinh", "Math.sinh(x)")}}</dt> + <dd>Gibt den Sinus Hyperbolicus einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/sqrt", "Math.sqrt(x)")}}</dt> + <dd>Gibt die positive Quadratwurzel einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/tan", "Math.tan(x)")}}</dt> + <dd>Gibt den Tangens einer Zahl zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/tanh", "Math.tanh(x)")}}</dt> + <dd>Gibt den Tangens Hyperbolicus einer Zahl zurück.</dd> + <dt><code>Math.toSource()</code> {{Non-standard_inline() }}</dt> + <dd>Gibt die Zeichenkette <code>"Math"</code> zurück.</dd> + <dt>{{jsxref("Global_Objects/Math/trunc", "Math.trunc(x)")}}</dt> + <dd>Gibt den ganzzahligen Teil der Zahl <code>x</code>, ohne jede Nachkommastellen, zurück.</dd> +</dl> + +<h2 id="Das_Math_Objekt_erweitern">Das <code>Math</code> Objekt erweitern</h2> + +<p>Wie die meisten der Standard-JavaScript Objekte kann auch das <code>Math</code> Objekt um benutzerdefinierten Eigenschaften und Methoden erweitert werden. Zum Erweitern des <code>Math</code> Objektes wird nicht <code>prototype</code> genutzt. Stattdessen wird <code>Math</code> direkt erweitert.</p> + +<pre>Math.propName = propValue; +Math.methodName = methodRef;</pre> + +<p>Im folgenden Beispiel wird eine Methode zum <code>Math</code> Objekt hinzugefügt, welche den größten gemeinsamen Teiler von einer Liste von Argumenten ermittelt.</p> + +<pre class="brush: js">/* Variadic function -- Returns the greatest common divisor of a list of arguments */ +Math.gcd = function () { + if(arguments.length == 2) { + if(arguments[1] == 0) { + return arguments[0]; + } else { + return Math.gcd(arguments[1], arguments[0] % arguments[1]); + } + } else if (arguments.length > 2) { + var result = Math.gcd(arguments[0], arguments[1]); + for (var i = 2; i < arguments.length; i++) { + result = Math.gcd(result, arguments[i]); + } + return result; + } +}</pre> + +<p>Zum Ausprobieren:</p> + +<pre class="brush: js">console.log(Math.gcd(20, 30, 15, 70, 40)); // `5`</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.8', 'Math')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math-object', 'Math')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Die neuen Methoden {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} und {{jsxref("Math.clz32()", "clz32()")}} hinzugefügt.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math-object', 'Math')}}</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.Math")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/ln10/index.html b/files/de/web/javascript/reference/global_objects/math/ln10/index.html new file mode 100644 index 0000000000..b43f317ef4 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/ln10/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LN10 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN10 +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10 +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Math.LN10</strong></code> Eigenschaft repräsentiert den natürlichen Logarithmus von 10, was gerundet 2,302 ist:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2,302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2,302</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-ln10.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Weil <code>LN10</code> eine statische Eigenschaft von <code>Math</code> ist, kann diese immer über <code>Math.LN10</code> erreicht werden, ohne dass ein Objekt von <code>Math</code> erstellt werden muss (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.LN10" name="Example:_Using_Math.LN10">Einsatz von <code>Math.LN10</code></h3> + +<p>Die folgende Funktion gibt das Ergebnis des natürlichen Logarithmus von 10 zurück:</p> + +<pre class="brush:js">function getNatLog10() { + return Math.LN10 +} + +getNatLog10() // 2.302585092994046</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.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}}</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.Math.LN10")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/ln2/index.html b/files/de/web/javascript/reference/global_objects/math/ln2/index.html new file mode 100644 index 0000000000..5577b36c74 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/ln2/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LN2 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN2 +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2 +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Math.LN2</strong></code> Eigenschaft repräsentiert den natürlichen Logarithmus von 2, was gerundet 0,693 ist:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0,693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0,693</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-ln2.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Weil <code>LN2</code> eine statische Eigenschaft von Math ist, kann diese immer mit <code>Math.LN2</code> erreicht werden, ohne dass ein Objekt von Math erstellt werden muss (<code>Math </code>ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.LN2" name="Example:_Using_Math.LN2">Einsatz von <code>Math.LN2</code></h3> + +<p>Die folgende Funktion gibt den Logarithmus zur Basis 2 von einer Zahl zurück. Dabei wird <code>Math.LN2</code> benutzt:</p> + +<pre class="brush:js">function getLog2(x) { + return Math.log(x) / Math.LN2; +} + +getLog2(256) // 8</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.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}}</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.Math.LN2")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/log/index.html b/files/de/web/javascript/reference/global_objects/math/log/index.html new file mode 100644 index 0000000000..d4502d50e2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log/index.html @@ -0,0 +1,113 @@ +--- +title: Math.log() +slug: Web/JavaScript/Reference/Global_Objects/Math/log +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.log()</code></strong> Funktion gibt den natürlichen Logarithmus (Logarithmus zur Basis {{jsxref("Math.E", "e")}}) einer Zahl zurück. Das bedeutet</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>sodass </mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math></p> + +<p>Die JavaScript Function <strong><code>Math.log()</code> </strong>ist gleichbedeutend zu der mathematischen <em>Funktion ln(x)</em>.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-log.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><code>Math.log(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der natürliche Logarithmus (Basis {{jsxref("Math.E", "e")}}) der übergebenen Zahl. Wenn die Zahl negativ ist, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn der Wert von <code>x</code> negativ ist, so gibt die Funktion immer {{jsxref("NaN")}} zurück.</p> + +<p>Weil <code>log()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.log()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<p>Wenn der natürliche Logarithmus von 2 und 10 gebraucht wird, gibt es die Konstanten {{jsxref("Math.LN2")}} und {{jsxref("Math.LN10")}}. Wenn ein Logarithmus zur Basis 2 oder 10 gebracht wird, gibt es die Funktionen {{jsxref("Math.log2()")}} und {{jsxref("Math.log10()")}}. Wenn der Logarithmus zu einer anderen Basis gebraucht wird, benutzt man Math.log(x) / Math.log(andereBasis) wie im Beispiel unten. Manchmal möchte man 1 / Math.log(andereBasis) vorberechnen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.log">Einsatz von <code>Math.log()</code></h3> + +<pre class="brush: js notranslate">Math.log(-1); // NaN, weil negativ +Math.log(0); // -Infinity +Math.log(1); // 0 +Math.log(10); // 2.302585092994046 +</pre> + +<h3 id="Einsatz_von_Math.log_mit_unterschiedlichen_Basen">Einsatz von <code>Math.log()</code> mit unterschiedlichen Basen</h3> + +<p>Die folgende Funktion gibt den Logarithmus von <code>y</code> zur Basis <code>x</code> zurück (log<sub>x</sub> y):</p> + +<pre class="brush: js notranslate">function getBaseLog(x, y) { + return Math.log(y) / Math.log(x); +} +</pre> + +<p>Wenn <code>getBaseLog(10, 1000)</code> ausgeführt wird, ist das Ergebnis <code>2.9999999999999996</code>. Diese Zahl ist nah an 3 und kommt durch Rundungsfehler bei Fließkommazahlen.</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>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log', 'Math.log')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log', 'Math.log')}}</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.Math.log")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/log10/index.html b/files/de/web/javascript/reference/global_objects/math/log10/index.html new file mode 100644 index 0000000000..fad6ea0996 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log10/index.html @@ -0,0 +1,101 @@ +--- +title: Math.log10() +slug: Web/JavaScript/Reference/Global_Objects/Math/log10 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10 +--- +<div>{{JSRef}}</div> + +<div>Die <strong><code>Math.log10()</code></strong> Funktion gibt den Logarithmus zur Basis<code> 10</code> zurück. Das bedeutet</div> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log10</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext></mtext><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>so das</mtext><mspace width="thickmathspace"></mspace><msup><mn>10</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log10.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Math.log10(<var>x</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den Logarithmus zur Basis 10 der gegebenen Zahl. Wenn die Zahl negativ ist, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn der Wert von <code>x</code> negativ ist, so gibt die Funktion immer <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="Die globale NaN Eigenschaft ist ein Wert, der Not-A-Number (keine Zahl) repräsentiert."><code>NaN</code></a> zurück.</p> + +<p>Weil <code>log10()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.log10()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<p>Diese Funktion ist äquivalent zu Math.log(x) / Math.log(10). Für log10(e) gibt es die Konstante {{jsxref("Math.LOG10E")}} welche 1 / {{jsxref("Math.LN10")}} ist.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.log10()">Einsatz von <code>Math.log10()</code></h3> + +<pre class="brush: js">Math.log10(2); // 0.3010299956639812 +Math.log10(1); // 0 +Math.log10(0); // -Infinity +Math.log10(-2); // NaN +Math.log10(100000); // 5 +</pre> + +<h3 id="Polyfill">Polyfill</h3> + +<p>Diese Funktion kann folgendermaßen emitiert werden:</p> + +<pre class="brush: js">Math.log10 = Math.log10 || function(x) { +<code class="language-js"> <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>x<span class="punctuation token">)</span> <span class="operator token">*</span> Math<span class="punctuation token">.</span>LOG10E<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-math.log10', 'Math.log10')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}}</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.Math.log10")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/log10e/index.html b/files/de/web/javascript/reference/global_objects/math/log10e/index.html new file mode 100644 index 0000000000..28d609df71 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log10e/index.html @@ -0,0 +1,85 @@ +--- +title: Math.LOG10E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Math.LOG10E</strong></code> Eigenschaft repräsentiert den Logarithmus zur Basis 10 von e, was gerundet 0,434 ist:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0,434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0,434</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log10e.html")}}</div> + + + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Weil <code>LOG10E</code> eine statische Eigenschaft von <code>Math</code> ist, kann diese immer über <code>Math.LOG10E</code> erreicht werden, ohne dass ein Objekt erstellt werden muss (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.LOG2E" name="Example:_Using_Math.LOG2E">Einsatz von <code>Math.LOG10E</code></h3> + +<p>Die folgende Funktion gibt den Logarithmus zur Basis 10 von <em>e</em> zurück.</p> + +<pre class="brush:js">function getLog10e() { + return Math.LOG10E +} + +getLog10e() // 0.4342944819032518</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>{{Spec2('ES1')}}</p> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <td>Kommentar</td> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}}</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.Math.LOG10E")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/log1p/index.html b/files/de/web/javascript/reference/global_objects/math/log1p/index.html new file mode 100644 index 0000000000..a63eab6b6f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log1p/index.html @@ -0,0 +1,102 @@ +--- +title: Math.log1p() +slug: Web/JavaScript/Reference/Global_Objects/Math/log1p +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.log1p()</code></strong> Funktion gibt den natürlichen Logarithmus (Logarithmus zur Basis {{jsxref("Math.E", "e")}}) von 1 + x zurück. Das bedeutet</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mo>-</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log1p</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log1p.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.log1p(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den natürliche Logarithmus (zur Basis {{jsxref("Math.E", "e")}}) von 1 plus der gegebenen Zahl. Wenn die Zahl kleiner als <strong>-1</strong> ist, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Für sehr kleine Zahlen für <code>x</code> kann das Addieren mit 1 zu verlusten in der Präzision führen. Die Zahlen in JavaScript haben eine Genauigkeit von 15 Stellen. <code> 1 + 1e-15 = 1.000000000000001</code>, aber <code>1 + 1e-16 = 1.000000000000000</code> und damit exakt <code>1</code><code>.0</code> in dieser Arithmetik, weil Ziffern nach der 15 Stelle gerundet werden.</p> + +<p>Wenn <code>log(1 + x)</code> berechnet wird, bekommt man ein Ergebnis sehr na an <code>x</code>, wenn <code>x</code> klein ist (das ist der Grund, warum es 'natürlicher' Logarithmus heißt). Wenn <code>Math.log(1 + 1.1111111111e-15)</code> berechnet wird sollte man ein Ergebnis nah an <code>1.1111111111e-15</code> bekommt. Stattdessen berechnet man den Logarithmus von <code><span style="line-height: 1.5;">1.00000000000000111022</span></code><span style="line-height: 1.5;"> (die Rundung geschieht im Binärsystem und ist manchmal unschön) un erhält das Ergebnis <code>1.11022...e-15</code> mit nur 3 korrekten Stellen. Wenn stattdessen <code>Math.log1p(</code></span><code>1.1111111111e-15</code><span style="line-height: 1.5;"><code>)</code> berechnet wird, bekommt man ein besseres Ergebnis von <code>1.1111111110999995e-15</code> mit 15 korrekten Stellen in der Präzision (aktuell 16 in diesem Fall).</span></p> + +<p>Wenn der Wert von <code>x</code> kleiner als -1 ist, gibt die Funktion immer den Wert {{jsxref("NaN")}} zurück.</p> + +<p>Weil <code>log1p()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.log1p()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.log1p()">Einsatz von <code>Math.log1p()</code></h3> + +<pre class="brush: js">Math.log1p(1); // 0.6931471805599453 +Math.log1p(0); // 0 +Math.log1p(-1); // -Infinity +Math.log1p(-2); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion kann folgendermaßen emuliert werden:</p> + +<pre class="brush: js">Math.log1p = Math.log1p || function(x) { + return Math.log(1 + x); +}; +</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-math.log1p', 'Math.log1p')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}}</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.Math.log1p")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/log2/index.html b/files/de/web/javascript/reference/global_objects/math/log2/index.html new file mode 100644 index 0000000000..de98c13128 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log2/index.html @@ -0,0 +1,101 @@ +--- +title: Math.log2() +slug: Web/JavaScript/Reference/Global_Objects/Math/log2 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2 +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.log2()</code></strong> Funktion gibt den Logarithmus zur Basis<code> 2</code> zurück. Das bedeutet</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log2</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext></mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>so das</mtext><mspace width="thickmathspace"></mspace><msup><mn>2</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log2.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.log2(<var>x</var>)</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den Logarithmus zur Basis 2 der gegebenen Zahl. Wenn die Zahl negativ ist, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn der Wert von <code>x</code> negativ ist, so gibt die Funktion immer <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="Die globale NaN Eigenschaft ist ein Wert, der Not-A-Number (keine Zahl) repräsentiert."><code>NaN</code></a> zurück.</p> + +<p>Weil <code>log2()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.log2()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<p>Diese Funktion ist äquivalent zu Math.log(x) / Math.log(2). Für log2(e) gibt es die Konstante {{jsxref("Math.LOG2E")}} welche 1 / {{jsxref("Math.LN2")}} ist.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.log2()">Einsatz von <code>Math.log2()</code></h3> + +<pre class="brush: js">Math.log2(3); // 1.584962500721156 +Math.log2(2); // 1 +Math.log2(1); // 0 +Math.log2(0); // -Infinity +Math.log2(-2); // NaN +Math.log2(1024); // 10 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion kann mit folgender Funktion emitiert werden. Es kann sein, dass diese Funktion bei einigen eingabewerten ungenau (ungefähr 1 << 29) ist. Schachtel die Funktion in {{jsxref("Math.round()")}} wenn mit Bitmasken gearbeitet wird.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Math<span class="punctuation token">.</span>log2 <span class="operator token">=</span> Math<span class="punctuation token">.</span>log2 <span class="operator token">||</span> <span class="keyword token">function</span><span class="punctuation token">(</span>x<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span>x<span class="punctuation token">)</span> <span class="operator token">*</span> Math<span class="punctuation token">.</span>LOG2E<span class="punctuation token">;</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-math.log2', 'Math.log2')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}}</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.Math.log2")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/log2e/index.html b/files/de/web/javascript/reference/global_objects/math/log2e/index.html new file mode 100644 index 0000000000..2f302bf4a2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log2e/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LOG2E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Math.LOG2E</strong></code> Eigenschaft repräsentiert den Logarithmus zur Basis 2 von e, was gerundet 1,443 ist:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1,442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1,442</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log2e.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Weil <code>LOG2E</code> eine statische Eigenschaft von <code>Math</code> ist, kann diese immer über <code>Math.LOG2E</code> erreicht werden, ohne dass ein Objekt erstellt werden muss (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.LOG2E" name="Example:_Using_Math.LOG2E">Einsatz von <code>Math.LOG2E</code></h3> + +<p>Die folgende Funktion gibt den Logarithmus zur Basis 2 von <em>e</em> zurück.</p> + +<pre class="brush:js">function getLog2e() { + return Math.LOG2E +} + +getLog2e() // 1.4426950408889634</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}}</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.Math.LOG2E")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/math.random/index.html b/files/de/web/javascript/reference/global_objects/math/math.random/index.html new file mode 100644 index 0000000000..6097229c1a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/math.random/index.html @@ -0,0 +1,112 @@ +--- +title: Math.random() +slug: Web/JavaScript/Reference/Global_Objects/Math/math.random +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/random +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.random()</code></strong> Funktion gibt eine Pseudozufallszahl in Form einer Gleitkommazahl im Bereich von 0 - 1 (0 inklusiv, aber 1 nicht) annähernd gleichverteilt zurück, die dann zur gewünschten Größe skaliert werden kann. Die Zufallszahl wird von der Implementierung bestimmt; sie kann nicht vom Benutzer ausgewählt oder zurückgesetzt werden.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-random.html")}}</div> + +<div class="note"> +<p><code>Math.random()</code> stellt <em>keine</em> kryprografisch sicheren Zufallszahlen bereit. <span id="result_box" lang="de"><span class="hps">Verwenden Sie sie auf keinen Fall für </span><span class="hps">etwas, das in Verbindung mit </span><span class="hps">Sicherheit steht</span><span>.</span></span> Benutzen Sie stattdessen die Web Crypto API, genauer gesagt die {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}-Methode.</p> +</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.random()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine pseudozufällige Gleitkommazahl zwischen <code>0</code> (inklusiv) und <code>1</code> (exklusiv).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p><span id="result_box" lang="de"><span class="alt-edited">Beachten Sie, dass, weil Zahlen in JavaScript IEEE 754 Gleitkommazahlen sind, mit dem Verhalten zur nächsten geraden Zahl zu runden, die Bereiche für die folgenden Funktionen - mit Ausnahme für</span></span> <code>Math.random()</code> <span lang="de"><span class="alt-edited">selbst - nicht exakt sind.<br> + Wenn extrem große Grenzen</span></span> (2<sup>53</sup> <span id="result_box" lang="de"><span class="alt-edited">oder höher) gewählt werden, ist es in äußerst seltenen Fällen möglich, dass die eigentlich ausgeschlossenen Obergrenzen mit eingerechnet werden.</span></span></p> + +<h3 id="Erzeugt_eine_Zufallszahl_zwischen_0_inklusive_und_1_exklusive">Erzeugt eine Zufallszahl zwischen 0 (inklusive) und 1 (exklusive)</h3> + +<pre class="brush: js">function getRandom() { + return Math.random(); +} +</pre> + +<h3 id="Erzeugt_eine_Zufallszahl_zwischen_zwei_Zahlen">Erzeugt eine Zufallszahl zwischen zwei Zahlen</h3> + +<p>Das Beispiel gibt eine zufällige Zahl zwischen zwei Zahlen zurück. Der Rückgabewert is größer oder gleich <code>min</code> und kleiner als <code>max</code>.</p> + +<pre class="brush: js">function getRandomArbitrary(min, max) { + return Math.random() * (max - min) + min; +} +</pre> + +<h3 id="Erzeugt_eine_ganze_Zufallszahl_zwischen_zwei_Zahlen">Erzeugt eine ganze Zufallszahl zwischen zwei Zahlen</h3> + +<p>Das Beispiel gibt eine zufällige ganze Zahl zwischen den spezifizierten Werten zurück. Der Wert ist nicht kleiner als <code>min</code> (oder der nächstgrößeren ganzen Zahl von <code>min</code>, wenn <code>min</code> keine ganze Zahl ist) und ist kleiner als (aber nicht gleich) <code>max</code>.</p> + +<pre>function getRandomInt(min, max) { + min = Math.ceil(min); + max = Math.floor(max); + return Math.floor(Math.random() * (max - min)) + min; +} +</pre> + +<div class="note"> +<p><span id="result_box" lang="de"><span>Es könnte verlockend sein, <code>Math.round()</code> zu verwenden, um das Ergebnis zu erreichen, aber das würde dazu führen, dass die zufälligen Zahlen einer ungleichmäßigen Verteilung folgen würden, die möglicherweise nicht den geforderten Bedürfnisse entsprechen würde</span></span><span lang="de"><span>.</span></span></p> +</div> + +<h3 id="Erzeugt_eine_ganze_Zufallszahl_zwischen_zwei_Zahlen_inklusiv">Erzeugt eine ganze Zufallszahl zwischen zwei Zahlen (inklusiv)</h3> + +<p>Die obere <code>getRandomInt()</code> Funktion hat ein inklusives Minimum und ein exklusives Maximum. Was ist, wenn sowohl das Minimum als auch das Maximum inklusive sein sollen? Die <code>getRandomIntInclusive()</code> Funktion ermöglicht dieses:</p> + +<pre>function getRandomIntInclusive(min, max) { + min = Math.ceil(min); + max = Math.floor(max); + return Math.floor(Math.random() * (max - min +1)) + min; +} +</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. JavaScript 1.0 (nur auf UNIX) / JavaScript 1.1 (auf allen Plattformen).</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.random', 'Math.random')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.random', 'Math.random')}}</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.Math.random")}}</p> diff --git a/files/de/web/javascript/reference/global_objects/math/max/index.html b/files/de/web/javascript/reference/global_objects/math/max/index.html new file mode 100644 index 0000000000..e1ac3eba01 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/max/index.html @@ -0,0 +1,118 @@ +--- +title: Math.max() +slug: Web/JavaScript/Reference/Global_Objects/Math/max +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/max +--- +<div>{{JSRef}}</div> + +<p>Die Funktion <strong><code>Math.max()</code></strong> gibt die größte von 0 oder mehr Zahlen zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-max.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.max([<var>wert1</var>[, <var>wert2</var>[, ...]]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>wert1, wert2, ...</code></dt> + <dd>Zahlen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die größte der übergebenen Zahlen. Wenn mindestens ein Parameter nicht zu einer Zahl konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>max()</code> eine statische Methode von <code>Math</code> ist, kann nur <code>Math.max()</code> verwendet werden. Eine Verwendung mit Math als instanziertem Objekt ist nicht möglich (<code>Math</code> ist kein constructor).</p> + +<p>Wenn keine Argumente übergeben wurden ist der Rückgabewert -{{jsxref("Infinity")}}.</p> + +<p>Wenn mindestens eines der Argumente nicht in eine Zahl umgewandelt werden kann, ist der Rückgabewert {{jsxref("NaN")}}.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.max()">Einsatz von <code>Math.max()</code></h3> + +<pre class="brush: js">Math.max(10, 20); // 20 +Math.max(-10, -20); // -10 +Math.max(-10, 20); // 20 +</pre> + +<h4 id="Das_größte_Element_in_einem_Array_ermitteln">Das größte Element in einem Array ermitteln</h4> + +<p>{{jsxref("Array.prototype.reduce", "Array.reduce()")}} kann ebenfalls benutzt werden, um das Maximum eines Arrays zu erhalten, indem jeder Wert verglichen wird.</p> + +<pre class="brush: js">var arr = [1, 2, 3]; +var max = arr.reduce(function(a, b) { + return Math.max(a, b); +}); +</pre> + +<p>Die folgende Funktion benutzt {{jsxref("Function.prototype.apply()")}}, um den maximalen Wert eines numerischen Arrays zu finden. <code>getMaxOfArray([1, 2, 3])</code> entspricht <code>Math.max(1, 2, 3)</code>, aber <code>getMaxOfArray()</code> kann programmatisch erstellte Arrays jeder Art annehmen.</p> + +<pre class="brush: js">function getMaxOfArray(numArray) { + return Math.max.apply(null, numArray); +} +</pre> + +<p>Alternativ ist es mit dem neuen {{jsxref("Operators/Spread_operator", "spread Operator")}} viel einfacher, den maximalen Wert eines Arrays herauszufinden.</p> + +<pre class="brush: js">var arr = [1, 2, 3]; +var max = Math.max(...arr); +</pre> + +<p>Bei dem Einsatz des {{jsxref("Operators/Spread_operator", "spread Operator")}} oder <code>apply</code> kann der Aufruf fehlschlagen oder ein ungültiges Ergebnis herauskommen, wenn das Array zu viele Elemente hat. Das liegt daran, dass versucht wird die Elemente des Arrays als Parameter einer Funktion zu übergeben. Siehe für mehr Details im Abschnitt <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Function/apply#Using_apply_and_built-in_functions">Einsatz von <code>apply</code> und standard Funktionen</a> nach. Die <code>reduce</code> Lösung hat dieses Problem nicht.</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>Initiale Definition. In JavaScript 1.0 implementiert.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.11', 'Math.max')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.max', 'Math.max')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.max', 'Math.max')}}</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.Math.max")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.min()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/min/index.html b/files/de/web/javascript/reference/global_objects/math/min/index.html new file mode 100644 index 0000000000..9cd666fda3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/min/index.html @@ -0,0 +1,112 @@ +--- +title: Math.min() +slug: Web/JavaScript/Reference/Global_Objects/Math/min +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/min +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.min()</code></strong> Funktion gibt den Wert der kleinsten übergebenen Zahl zurück oder {{jsxref("NaN")}}, wenn ein Parameter keine Zahl ist und auch nicht in eine Zahl konvertiert werden kann.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-min.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.min([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>value1, value2, ...</code></dt> + <dd>Zahlen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die kleinste der übergebenen Zahlen. Wenn nur ein Parameter nicht zu einer Zahl konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Da <code>min()</code> eine statische Eigenschaft von <code>Math</code> ist, muss immer <code>Math.min()</code> genutzt werden, ohne dass ein <code>Math-</code>Objekt erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<p>Ohne Übergabeparameter wird {{jsxref("Infinity")}} zurückgegeben.</p> + +<p>Wenn mindestens ein Übergabeparameter nicht in eine Zahl konvertiert werden kann wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.min" name="Example:_Using_Math.min">Einsatz von <code>Math.min()</code></h3> + +<p>Dies findet den kleinsten Wert aus x und y und weist diesen z zu.</p> + +<pre class="brush: js">var x = 10, y = -20; +var z = Math.min(x, y); +</pre> + +<h3 id="Example:_Clipping_a_value_with_Math.min" name="Example:_Clipping_a_value_with_Math.min">Wert mittels <code>Math.min()</code> begrenzen</h3> + +<p><code>Math.min()</code> wird oftmals verwendet um einen Wert so zu begrenzen, dass dieser nicht größer als ein gesetztes Limit werden kann. So kann dies</p> + +<pre class="brush: js">var x = f(foo); + +if (x > limit) { + x = limit; +} +</pre> + +<p>auch folgendermaßen formuliert werden</p> + +<pre class="brush: js">var x = Math.min(f(foo), limit); +</pre> + +<p>Analog kann {{jsxref("Math.max()")}} verwendet werden um einen Mindestwert zu realisieren.</p> + +<h2 id="Specifications" name="Specifications">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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.12', 'Math.min')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.min', 'Math.min')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.min', 'Math.min')}}</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.Math.min")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.max()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/pi/index.html b/files/de/web/javascript/reference/global_objects/math/pi/index.html new file mode 100644 index 0000000000..4a07aadc15 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/pi/index.html @@ -0,0 +1,81 @@ +--- +title: Math.PI +slug: Web/JavaScript/Reference/Global_Objects/Math/PI +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Math.PI</strong></code> Eigenschaft repräsentiert die Kreiszahl Pi, welche als Verhältnis zwischen Kreisumfang und Durchmesser definiert ist und gerundet die Zahl 3,14159 ist.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3,14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3,14159</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-pi.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Weil <code>PI</code> eine statische Eigenschaft von <code>Math</code> ist, muss immer <code>Math.PI</code> genutzt werden, ohne dass ein <code>Math</code> Objekt erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.E" name="Example:_Using_Math.E">Einsatz von <code>Math.PI</code></h3> + +<p>Die folgende Funktion benutzt <code>Math.PI</code>, um aus einem Radius den Umfrang eines Kreises zu berechnen:</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">calculateCircumference</span><span class="punctuation token">(</span>radius<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">return</span> Math<span class="punctuation token">.</span>PI <span class="operator token">*</span> <span class="punctuation token">(</span>radius <span class="operator token">+</span> radius<span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="function token">calculateCircumference</span><span class="punctuation token">(</span><span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// 6.283185307179586</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}}</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.Math.PI")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/pow/index.html b/files/de/web/javascript/reference/global_objects/math/pow/index.html new file mode 100644 index 0000000000..5966acd81f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/pow/index.html @@ -0,0 +1,113 @@ +--- +title: Math.pow() +slug: Web/JavaScript/Reference/Global_Objects/Math/pow +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow +--- +<div>{{JSRef}}</div> + +<p>Die Funktion <strong><code>Math.pow()</code></strong> gibt die P<font face="Consolas, Liberation Mono, Courier, monospace">otenz</font> der <code>Basis</code> mit dem <code>Exponenten</code> an<code> </code>(<code>Basis<sup>Exponent</sup></code>)</p> + +<div>{{EmbedInteractiveExample("pages/js/math-pow.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.pow(<var>Basis</var>, <var>Exponent</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>Basis</code></dt> + <dd>Basis (auch: die Grundzahl).</dd> + <dt><code>Exponent</code></dt> + <dd>der Exponent (auch: die Hochzahl).</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Zahl, die die Basis potenziert mit dem Exponenten repräsentiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>pow()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.pow()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_Math.pow()">Benutzung von <code>Math.pow()</code></h3> + +<pre class="brush: js">// einfach +Math.pow(7, 2); // 49 +Math.pow(7, 3); // 343 +Math.pow(2, 10); // 1024 +// Brüche als Exponenten +Math.pow(4, 0.5); // 2 (Wurzel aus 4) +Math.pow(8, 1/3); // 2 (Kubikwurzel aus 8) +Math.pow(2, 0.5); // 1.4142135623730951 (Wurzel aus 2) +Math.pow(2, 1/3); // 1.2599210498948732 (Kubikwurzel aus 2) +// Negative Exponenten +Math.pow(7, -2); // 0.02040816326530612 (1/49) +Math.pow(8, -1/3); // 0.5 +// Negative Basis +Math.pow(-7, 2); // 49 (Das Quadrat ist positiv) +Math.pow(-7, 3); // -343 (kann negativ sein) +Math.pow(-7, 0.5); // NaN (negative Zahlen haben keine Quadratwurzel) +// auch wegen Grenzen bei der Gleitkomma Berechnung, +// Negative Basis mit Bruch als Exponent gibt immer NaN zurück +Math.pow(-7, 1/3); // 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> + <p>Initiale Deffinition, Implementiert in JavaScript 1.0.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.pow', 'Math.pow')}}</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.Math.pow")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.cbrt()")}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation" title="Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value. The standard arithmetic operators are addition (+), subtraction (-), multiplication (*), and division (/).">Exponentiation operator</a> {{experimental_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/round/index.html b/files/de/web/javascript/reference/global_objects/math/round/index.html new file mode 100644 index 0000000000..8e009bf6cb --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/round/index.html @@ -0,0 +1,99 @@ +--- +title: Math.round() +slug: Web/JavaScript/Reference/Global_Objects/Math/round +tags: + - JavaScript + - Math + - Method + - Number + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/round +--- +<p>{{JSRef}}<br> + Die <strong><code>Math.round()</code></strong> Funktion gibt die nächstgelegenen Ganzzahl einer Zahl zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-round.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox">Math.round(<var>x</var>)</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Description" name="Description">Rückgabewert</h3> + +<p>Den Wert der gegebenen Zahl, der zur nächsten ganzen Zahl gerundet wird.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Wenn der Nachkommateil des Argumentes größer als 0.5 ist, wird das Argument zur nächsten ganzen Zahl, deren Absolutwert größer ist, gerundet. Wenn der Nachkommateil kleiner als 0.5 ist, wird auf die nächsten ganzen Zahl, deren Absolutwert kleiner ist, gerundet. Wenn der Nachkommateil genau 0.5 ist, wird auf die nächst größere ganze Zahl aufgerundet (in Richtung +∞). <strong>Das Verhalten bei 0.5 ist anders als bei vielen anderen Programmiersprachen, welche in der Regel zur nächsten ganzen Zahl, welche weiter entfernt von 0 liegt, runden</strong> (das kann zu unterschiedlichen Ergebnissen bei negativen Zahlen mit einem exakten Nachkommateil von 0.5 führen).</p> + +<p>Weil <code>round()</code> eine statische Methode von <code>Math</code> ist, benutzt man als Aufruf immer <code>Math.round()</code> und nicht in dem man zunächst ein <code>Math</code>-Objekt erzeugt um anschliessend die <code>round()</code>-Methode aufzurufen (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<pre class="brush: js">Math.round(20.49); // 20 +Math.round(20.5); // 21 +Math.round(42); // 42 +Math.round(-20.5); // -20 +Math.round(-20.51); // -21 +</pre> + +<h2 id="Specifications" name="Specifications">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>ECMAScript 1st Edition.</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.round', 'Math.round')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> + <p> </p> + </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.round', 'Math.round')}}</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.Math.round")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.toPrecision()")}}</li> + <li>{{jsxref("Number.toFixed()")}}</li> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/sign/index.html b/files/de/web/javascript/reference/global_objects/math/sign/index.html new file mode 100644 index 0000000000..26a4085eb1 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sign/index.html @@ -0,0 +1,115 @@ +--- +title: Math.sign() +slug: Web/JavaScript/Reference/Global_Objects/Math/sign +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.sign()</code></strong> Funktion gibt das Vorzeichen einer Zahl zurück, welches angibt, ob eine Zahl positiv, negativ oder 0 ist.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-sign.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.sign(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Zahl, die das Vorzeichen des übergebenen Wertes repräsentiert. Wenn der Parameter eine positive Zahl ist, eine negative Zahl ist oder eine Null (0) ist, wird die Funktion <code>1</code>, <code>-1</code>, <code>0</code> oder <code>-0</code> zurückgeben. Andernfalls wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>sign()</code> eine statische Funktion von <code>Math</code> ist, wird sie immer als <code>Math.sign()</code> eingesetzt, jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<p>Diese Funktion hat die 5 möglichen Rückgabewerte <code>1</code>, <code>-1</code>, <code>0</code>, <code>-0</code> und <code>NaN</code>, welche "positive Zahlen", "negative Zahlen", "positiv 0", "negativ 0" und {{jsxref("NaN")}} repräsentieren.</p> + +<p>Der Übergebeparameter dieser Funktion wird implizit zu einem <code>number</code>-Type konvertiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.sign()">Einsatz von <code>Math.sign()</code></h3> + +<pre class="brush: js">Math.sign(3); // 1 +Math.sign(-3); // -1 +Math.sign('-3'); // -1 +Math.sign(0); // 0 +Math.sign(-0); // -0 +Math.sign(NaN); // NaN +Math.sign('foo'); // NaN +Math.sign(); // NaN +</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><span class="operator token">!</span>Math<span class="punctuation token">.</span>sign<span class="punctuation token">)</span> <span class="punctuation token">{</span> + Math<span class="punctuation token">.</span>sign <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span>x<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="comment token">// If x is NaN, the result is NaN.</span> + <span class="comment token">// If x is -0, the result is -0.</span> + <span class="comment token">// If x is +0, the result is +0.</span> + <span class="comment token">// If x is negative and not -0, the result is -1.</span> + <span class="comment token">// If x is positive and not +0, the result is +1.</span> + <span class="keyword token">return</span> <span class="punctuation token">(</span><span class="punctuation token">(</span>x <span class="operator token">></span> <span class="number token">0</span><span class="punctuation token">)</span> <span class="operator token">-</span> <span class="punctuation token">(</span>x <span class="operator token"><</span> <span class="number token">0</span><span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">||</span> <span class="operator token">+</span>x<span class="punctuation token">;</span> + <span class="comment token">// A more aesthetical persuado-representation is shown below</span> + <span class="comment token">//</span> + <span class="comment token">// ( (x > 0) ? 0 : 1 ) // if x is negative then negative one</span> + <span class="comment token">// + // else (because you cant be both - and +)</span> + <span class="comment token">// ( (x < 0) ? 0 : -1 ) // if x is positive then positive one</span> + <span class="comment token">// || // if x is 0, -0, or NaN, or not a number,</span> + <span class="comment token">// +x // Then the result will be x, (or) if x is</span> + <span class="comment token">// // not a number, then x converts to number</span> + <span class="punctuation token">}</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></pre> + +<p>In diesem Polyfill ist keine weitere Typumwandlung nötig, um aus <code>(x > 0)</code> oder <code>(x < 0)</code> Zahlen zu machen, weil das Subtrahieren voneinander eine Typkonvertierung von boolean zu Zahlen erzwingt.</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">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sign', 'Math.sign')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}}</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.Math.sign")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/sin/index.html b/files/de/web/javascript/reference/global_objects/math/sin/index.html new file mode 100644 index 0000000000..69a7a2f559 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sin/index.html @@ -0,0 +1,97 @@ +--- +title: Math.sin() +slug: Web/JavaScript/Reference/Global_Objects/Math/sin +tags: + - JavaScript + - Math + - Meth + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.sin()</code></strong> Funktion gibt den Sinus einer Zahl zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-sin.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.sin(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl im Bogenmaß (rad).</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den Sinus der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>Math.sin()</code> Funktion gibt einen nummerischen Wert zwischen -1 und 1 zurück. Dieser repräsentiert den Sinus des Winkels.</p> + +<p>Weil <code>sin()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.sin()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.sin()">Einsatz von <code>Math.sin()</code></h3> + +<pre class="brush: js">Math.sin(0); // 0 +Math.sin(1); // 0.8414709848078965 + +Math.sin(Math.PI / 2); // 1 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.16', 'Math.sin')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sin', 'Math.sin')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}}</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.Math.sin")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/sinh/index.html b/files/de/web/javascript/reference/global_objects/math/sinh/index.html new file mode 100644 index 0000000000..99e8d1e3c6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sinh/index.html @@ -0,0 +1,102 @@ +--- +title: Math.sinh() +slug: Web/JavaScript/Reference/Global_Objects/Math/sinh +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.sinh()</code></strong> Funktion gibt den Sinus Hyperbolicus einer Zahl zurück. Dieser kann mit dem Einsatz der {{jsxref("Math.E", "Eulerschen Zahl", "", 1)}} folgendermaßen berechnet werden:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.sinh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-sinh.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.sinh(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den Sinus Hyperbolicus der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>sinh()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.sinh()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.sinh()">Einsatz von <code>Math.sinh()</code></h3> + +<pre class="brush: js">Math.sinh(0); // 0 +Math.sinh(1); // 1.1752011936438014 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion kann mit Hilfe der Funktion {{jsxref("Math.exp()")}} emuliert werden:</p> + +<pre class="brush: js">Math.sinh = Math.sinh || function(x) { + return (Math.exp(x) - Math.exp(-x)) / 2; +} +</pre> + +<p>Oder nur mit einem Aufruf der {{jsxref("Math.exp()")}} Funktion:</p> + +<pre class="brush: js">Math.sinh = Math.sinh || function(x) { + var y = Math.exp(x); + return (y - 1 / y) / 2; +} +</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-math.sinh', 'Math.sinh')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}}</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.Math.sinh")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/sqrt/index.html b/files/de/web/javascript/reference/global_objects/math/sqrt/index.html new file mode 100644 index 0000000000..a7ad903569 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sqrt/index.html @@ -0,0 +1,99 @@ +--- +title: Math.sqrt() +slug: Web/JavaScript/Reference/Global_Objects/Math/sqrt +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.sqrt()</code></strong> Funktion gibt die Quadratwurzel einer Zahl zurück. Diese Ist Mathematisch folgendermaßen definiert:</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>s</mi><mi>q</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mi>x</mi></msqrt><mo>=</mo><mtext>ein</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>so das</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-sqrt.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.sqrt(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die Quadratwurzel der übergebenen Zahl. Wenn der Parameter negativ ist, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn der Wert von <code>x</code> negativ ist, gibt <code>Math.sqrt()</code> {{jsxref("NaN")}} zurück.</p> + +<p>Weil <code>sqrt()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.</code><code>sqrt</code><code>()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.sqrt()">Einsatz von <code>Math.sqrt()</code></h3> + +<pre class="brush: js">Math.sqrt(9); // 3 +Math.sqrt(2); // 1.414213562373095 + +Math.sqrt(1); // 1 +Math.sqrt(0); // 0 +Math.sqrt(-1); // NaN +Math.sqrt(-0); // -0</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.17', 'Math.sqrt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sqrt', 'Math.sqrt')}}</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.Math.sqrt")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.cbrt()")}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/sqrt1_2/index.html b/files/de/web/javascript/reference/global_objects/math/sqrt1_2/index.html new file mode 100644 index 0000000000..19e1a24f4d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sqrt1_2/index.html @@ -0,0 +1,84 @@ +--- +title: Math.SQRT1_2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Math.SQRT1_2</strong></code> Eigenschaft repräsentiert die Quadratwurzel aus 1/2, welche gerundet 0,707 ist:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0,707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0,707</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-sqrt1_2.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Weil <code>SQRT1_2</code> eine statische Eigenschaft von <code>Math</code> ist, muss immer <code>Math.SQRT1_2</code> genutzt werden, ohne dass ein <code>Math</code> Objekt erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.E" name="Example:_Using_Math.E">Einsatz von <code>Math.SQRT1_2</code></h3> + +<p>Die folgende Funktion gibt die Quadratwurzel aus 1/2 zurück:</p> + +<pre class="brush:js">function getRoot1_2() { + return Math.SQRT1_2 +} + +getRoot1_2() // 0.7071067811865476</pre> + +<p></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>Initiale Definition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.7', 'Math.SQRT1_2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</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.Math.SQRT1_2")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/sqrt2/index.html b/files/de/web/javascript/reference/global_objects/math/sqrt2/index.html new file mode 100644 index 0000000000..14b748c555 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sqrt2/index.html @@ -0,0 +1,82 @@ +--- +title: Math.SQRT2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Math.SQRT2</strong></code> Eigenschaft repräsentiert die Quadratwurzel aus 2, welche gerundet 1,414 ist:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1,414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1,414</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-sqrt2.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Weil <code>SQRT2</code> eine statische Eigenschaft von <code>Math</code> ist, muss immer <code>Math.SQRT2</code> genutzt werden, ohne dass ein <code>Math</code>-Objekt erstellt wird (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_Math.E" name="Example:_Using_Math.E">Einsatz von <code>Math.SQRT2</code></h3> + +<p>Die folgende Funktion gibt die Quadratwurzel aus 2 zurück:</p> + +<pre class="brush:js">function getRoot2() { + return Math.SQRT2 +} + +getRoot2() // 1.4142135623730951</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.8', 'Math.SQRT2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}}</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.Math.SQRT2")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/tan/index.html b/files/de/web/javascript/reference/global_objects/math/tan/index.html new file mode 100644 index 0000000000..92102e3ae2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/tan/index.html @@ -0,0 +1,102 @@ +--- +title: Math.tan() +slug: Web/JavaScript/Reference/Global_Objects/Math/tan +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.tan()</code></strong> Funktion gibt den Tangens einer Zahl.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-tan.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.tan(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl im Winkelmaß (rad).</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den Tangens der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>Math.tan()</code> Funktion gibt einen numerischen Wert zurück, welcher den Tangens eines Winkels repräsentiert.</p> + +<p>Weil <code>tan()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.tan()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.tan()">Einsatz von <code>Math.tan()</code></h3> + +<pre class="brush: js">Math.tan(1); // 1.5574077246549023 +</pre> + +<p>Weil die <code>Math.tan()</code> Funktion Werte im Winkelmaß erwartet, es aber oftmals einfacher ist mit Winkeln zu rechnen, nutzt die folgende Funktion Winkel (in Grad) und Convertiert diese in das Winkelmaß: </p> + +<pre class="brush: js">function getTanDeg(deg) { + var rad = deg * Math.PI/180; + return Math.tan(rad); +} +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.18', 'Math.tan')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.tan', 'Math.tan')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.tan', 'Math.tan')}}</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.Math.tan")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/tanh/index.html b/files/de/web/javascript/reference/global_objects/math/tanh/index.html new file mode 100644 index 0000000000..7bfa025f4e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/tanh/index.html @@ -0,0 +1,93 @@ +--- +title: Math.tanh() +slug: Web/JavaScript/Reference/Global_Objects/Math/tanh +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.tanh()</code></strong> Funktion gibt den Tangens Hyperbolicus einer Zahl zurück. Dieser kann folgendermaßen errechnet werden:</p> + +<p><math display="block"><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi><mo>=</mo><mfrac><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><mrow><mo lspace="0em" rspace="0em">cosh</mo><mi>x</mi></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>-</mo><mn>1</mn></mrow><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>+</mo><mn>1</mn></mrow></mfrac></mrow><annotation encoding="TeX">\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-tanh.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.tanh(<var>x</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den Tangens Hyperbolicus der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Weil <code>tanh()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.tanh()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.tanh()">Einsatz von <code>Math.tanh()</code></h3> + +<pre class="brush: js">Math.tanh(0); // 0 +Math.tanh(Infinity); // 1 +Math.tanh(1); // 0.7615941559557649 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion kann mit Hilfe der Funktion {{jsxref("Math.exp()")}} emuliert werden:</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js">Math<span class="punctuation token">.</span>tanh <span class="operator token">=</span> Math<span class="punctuation token">.</span>tanh <span class="operator token">||</span> <span class="keyword token">function</span><span class="punctuation token">(</span>x<span class="punctuation token">)</span><span class="punctuation token">{</span> + <span class="keyword token">var</span> a <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">exp</span><span class="punctuation token">(</span><span class="operator token">+</span>x<span class="punctuation token">)</span><span class="punctuation token">,</span> b <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">exp</span><span class="punctuation token">(</span><span class="operator token">-</span>x<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> a <span class="operator token">==</span> <span class="number token">Infinity</span> <span class="operator token">?</span> <span class="number token">1</span> <span class="punctuation token">:</span> b <span class="operator token">==</span> <span class="number token">Infinity</span> <span class="operator token">?</span> <span class="operator token">-</span><span class="number token">1</span> <span class="punctuation token">:</span> <span class="punctuation token">(</span>a <span class="operator token">-</span> b<span class="punctuation token">)</span> <span class="operator token">/</span> <span class="punctuation token">(</span>a <span class="operator token">+</span> b<span class="punctuation token">)</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-math.tanh', 'Math.tanh')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}}</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.Math.tanh")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/math/trunc/index.html b/files/de/web/javascript/reference/global_objects/math/trunc/index.html new file mode 100644 index 0000000000..43aa34b2d7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/trunc/index.html @@ -0,0 +1,125 @@ +--- +title: Math.trunc() +slug: Web/JavaScript/Reference/Global_Objects/Math/trunc +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Math.trunc()</code></strong> Funktion gibt den ganzzahligen Teil einer Zahl zurück, indem alle Nachkommastellen entfernt werden.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-trunc.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Math.trunc(<var>x</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Eine Zahl.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den ganzzahligen Teil der übergebenen Zahl.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Im Gegensatz zu den drei <code>Math</code> Funktionen {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} und {{jsxref("Math.round()")}} arbeitet <code>Math.trunc()</code> sehr einfach. Sie entfernt den Punkt und die Ziffern rechts davon, ohne zu beachten, ob es sich um eine positive oder negative Nummer handelt.</p> + +<p>Beim übergeben eines Parameters wird dieser implizit in einen Nummern-Typ konvertiert.</p> + +<p>Weil <code>trunc()</code> eine statische Funktion von <code>Math</code> ist, wird es immer als <code>Math.trunc()</code> eingesetzt<code>,</code> jedoch nicht als Methode eines erzeugten <code>Math</code> Objektes (<code>Math</code> ist kein Konstruktor).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_Math.trunc">Einsatz von <code>Math.trunc()</code></h3> + +<pre class="brush: js">Math.trunc(13.37); // 13 +Math.trunc(42.84); // 42 +Math.trunc(0.123); // 0 +Math.trunc(-0.123); // -0 +Math.trunc('-1.123'); // -1 +Math.trunc(NaN); // NaN +Math.trunc('foo'); // NaN +Math.trunc(); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if(!Math.trunc) { + Math.trunc = function(v) { + v = +v; + if(!isFinite(v)) return v; + + return (v - v % 1) || (v < 0 ? -0 : v === 0 ? v : 0); + + // returns: + // 0 -> 0 + // -0 -> -0 + // 0.2 -> 0 + // -0.2 -> -0 + // 0.7 -> 0 + // -0.7 -> -0 + // Infinity -> Infinity + // -Infinity -> -Infinity + // NaN -> NaN + // null -> 0 + }; +}</pre> + +<p>oder:</p> + +<pre class="brush: js line-numbers language-js">if(!Math.trunc) { + Math.trunc = function(v) { + return v < 0 ? Math.ceil(v) : Math.floor(v); + } +} +</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-math.trunc', 'Math.trunc')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.trunc', 'Math.trunc')}}</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.Math.trunc")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/nan/index.html b/files/de/web/javascript/reference/global_objects/nan/index.html new file mode 100644 index 0000000000..434f2b811a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/nan/index.html @@ -0,0 +1,97 @@ +--- +title: NaN +slug: Web/JavaScript/Reference/Global_Objects/NaN +tags: + - JavaScript + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/NaN +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die globale <code><strong>NaN</strong></code> Eigenschaft ist ein Wert, der Not-A-Number (keine Zahl) repräsentiert.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-nan.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>NaN</code></pre> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>NaN</code> ist eine Eigenschaft des <em>globalen Objektes.</em></p> + +<p>Der initiale Wert von <code>NaN</code> ist Not-A-Number — der gleiche Wert wie {{jsxref("Number.NaN")}}. In modernen Browsern ist <code>NaN</code> eine nicht konfigurierbare und nicht überschreibbare Eigenschaft. Immer wenn dieses nicht der Fall ist, sollte es vermieden werden, diese zu überschreiben.</p> + +<p>Der Einsatz von <code>NaN</code> in Programmen ist selten. Es wird als Rückgabewert genutzt, wenn {{jsxref("Math")}} Funktionen fehlschlagen (<code>Math.sqrt(-1)</code>) oder wenn der Versuch, eine Zeichenkette in eine Nummer zu konvertieren, fehlschlägt (<code>parseInt("blabla")</code>).</p> + +<h3 id="Tests_mit_NaN">Tests mit <code>NaN</code></h3> + +<p>Gleichheitsoperatoren (<code>==</code>, <code>!=</code>, <code>===</code> und <code>!==</code>) können nicht genutzt werden, um auf <code>NaN</code> zu prüfen. Stattdessen können die Methoden {{jsxref("Number.isNaN()")}} oder {{jsxref("Global_Objects/isNaN", "isNaN()")}} eingesetzt werden. Alternativ kann ein Vergleich auf sich selbst durchgeführt werden, weil nur <code>NaN</code> mit sich selbst verglichen ungleich ist.</p> + +<pre class="brush: js">NaN === NaN; // false +Number.NaN === NaN; // false +isNaN(NaN); // true +isNaN(Number.NaN); // true + +function valueIsNaN(v) { return v !== v; } +valueIsNaN(1); // false +valueIsNaN(NaN); // true +valueIsNaN(Number.NaN); // true +</pre> + +<p>Die Unterschiede zwischen <code>isNaN()</code> and <code>Number.isNaN()</code> sind zu beachten: <span id="result_box" lang="de"><span>ersteres wird <code>true</code> zurückgeben, wenn der übergebene Wert <code>NaN</code> ist, oder wenn er <code>NaN</code> wird, nachdem er zu einer Zahl umgewandelt wurde, während letzteres nur dann <code>true</code> zurückgibt, wenn der aktuelle Wert <code>NaN</code> ist:</span></span></p> + +<pre class="brush: js"><span lang="de"><span>isNaN('hello world'); // returns 'true'. +Number.isNaN('Hello world'); // returns 'false'. +</span></span></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.3</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.1.1', 'NaN')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-nan', 'NaN')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-value-properties-of-the-global-object-nan', 'NaN')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.NaN")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.NaN")}}</li> + <li>{{jsxref("Number.isNaN()")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/null/index.html b/files/de/web/javascript/reference/global_objects/null/index.html new file mode 100644 index 0000000000..323579ee42 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/null/index.html @@ -0,0 +1,93 @@ +--- +title: 'null' +slug: Web/JavaScript/Reference/Global_Objects/null +tags: + - JavaScript + - Literal + - Primitive +translation_of: Web/JavaScript/Reference/Global_Objects/null +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Der Wert <code>null</code> repräsentiert das absichtliche Fehlen eines Wertes. Es ist einer der {{Glossary("Primitive", "Primitiven Werte")}} in Javascript.</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-null.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>null </code></pre> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Der Wert <code>null</code> wird als Literal geschrieben: <code>null</code>. Der Wert <code>null</code> ist ein Literal (keine Eigenschaft des <em>globalen Objektes</em> wie<em> </em>{{jsxref("Global_Objects/undefined", "undefined")}}). <span id="result_box" lang="de"><span>Stattdessen drückt null einen Mangel an Identifikation aus und zeigt an, dass eine Variable auf kein Objekt zeigt</span></span>. In APIs wird <code>null</code> oftmals an Stellen verwendet, an denen ein Objekt optional genutzt werden kann.</p> + +<pre class="brush: js">// foo existiert nicht. Es wurde nicht definiert und nirgendwo initialisiert: +foo; +"ReferenceError: foo is not defined" + +// foo existiert nun, aber die Variable hat keinen Typ oder Wert: +var foo = null; +foo; +"null" +</pre> + +<h3 id="Unterschied_zwischen_null_und_undefined">Unterschied zwischen <code>null</code> und <code>undefined</code></h3> + +<p>Wenn auf null geprüft wird, sollte nicht der Gleichheitsvergleich ({{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}) mit dem Identitätsvergleich ({{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}) verwechselt werden, weil bei der Prüfung auf Gleichheit eine <span class="dpf_sent" id="dpfsent_3">implizite </span>Typumwandlung vorgenommen wird.</p> + +<pre class="brush: js">typeof null // "object" (not "null" for legacy reasons) +typeof undefined // "undefined" +null === undefined // false +null == undefined // true +null === null // true +null == null // true +!null // true +isNaN(1 + null) // false +isNaN(1 + undefined) // true</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-4.3.11', 'null value')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-null-value', 'null value')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-null-value', 'null value')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.null")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("undefined")}}</li> + <li>{{jsxref("NaN")}}</li> +</ul> 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> diff --git a/files/de/web/javascript/reference/global_objects/object/__definegetter__/index.html b/files/de/web/javascript/reference/global_objects/object/__definegetter__/index.html new file mode 100644 index 0000000000..5e88304f5f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/__definegetter__/index.html @@ -0,0 +1,150 @@ +--- +title: Object.prototype.__defineGetter__() +slug: Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__ +translation_of: Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__ +--- +<div>{{JSRef}}</div> + +<div class="warning"> +<p>This feature is deprecated in favor of defining getters using the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">object initializer syntax</a> or the {{jsxref("Object.defineProperty()")}} API. While this feature is widely implemented, it is only described in the <a href="https://tc39.github.io/ecma262/#sec-additional-ecmascript-features-for-web-browsers">ECMAScript specification</a> because of legacy usage. This method should not be used since better alternatives exist.</p> +</div> + +<p>Die <code><strong>__defineGetter__</strong></code> Methode bindet eine Eigenschaft des Objects an eine Funktion, die aufgerufen wird, wenn das Object angesehen wird.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>obj</var>.__defineGetter__(<var>prop</var>, <var>func</var>)</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>prop</code></dt> + <dd><code>Ein String der den Namen der zur Funktion gebundenen Eigenschaft enthält</code></dd> + <dt><code>func</code></dt> + <dd><code>Eine Funktion die zur Eigenschaft gebunden wird.</code></dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Description">Description</h2> + +<p>Die <code>__defineGetter__</code> erlaubt einen {{jsxref("Operators/get", "getter", "", 1)}} auf ein Object zu erstellen.</p> + +<h2 id="Examples">Examples</h2> + +<pre class="brush: js">// Nicht standard und veraltete Weise + +var o = {}; +o.__defineGetter__('gimmeFive', function() { return 5; }); +console.log(o.gimmeFive); // 5 + + +// Üblicher Weg + +// Mithilfe der get Methode +var o = { get gimmeFive() { return 5; } }; +console.log(o.gimmeFive); // 5 + +// Mithilfe von Object.defineProperty +var o = {}; +Object.defineProperty(o, 'gimmeFive', { + get: function() { + return 5; + } +}); +console.log(o.gimmeFive); // 5 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="spectable standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.prototype.__defineGetter__', 'Object.prototype.__defineGetter__()')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Included in the (normative) annex for additional ECMAScript legacy features for Web browsers (note that the specification codifies what is already in implementations).</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatIE("11")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Compatibility_notes">Compatibility notes</h2> + +<ul> + <li>Starting with Firefox 48 {{geckoRelease(48)}}, this method can no longer be called at the global scope without any object. A {{jsxref("TypeError")}} will be thrown otherwise. Previously, the global object was used in these cases automatically, but this is no longer the case ({{bug(1253016)}}).</li> +</ul> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Object.prototype.__defineSetter__()")}}</li> + <li>{{jsxref("Operators/get", "get")}} operator</li> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.prototype.__lookupGetter__()")}}</li> + <li>{{jsxref("Object.prototype.__lookupSetter__()")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">JS Guide: Defining Getters and Setters</a></li> + <li><a href="https://whereswalden.com/2010/04/16/more-spidermonkey-changes-ancient-esoteric-very-rarely-used-syntax-for-creating-getters-and-setters-is-being-removed/">[Blog Post] Deprecation of __defineGetter__ and __defineSetter__</a></li> + <li>{{bug(647423)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/assign/index.html b/files/de/web/javascript/reference/global_objects/object/assign/index.html new file mode 100644 index 0000000000..0359e1e5c9 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/assign/index.html @@ -0,0 +1,277 @@ +--- +title: Object.assign() +slug: Web/JavaScript/Reference/Global_Objects/Object/assign +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Object + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>Object.assign()</code></strong> kopiert die Werte aller aufzählbaren, eigenen Eigenschaften von einem oder mehreren Quellobjekten in ein Zielobjekt. Es wird das Zielobjekt zurückgegeben.</p> + +<div>{{EmbedInteractiveExample("pages/js/object-assign.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Object.assign(<var>target</var>, ...<var>sources</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>target</code></dt> + <dd>Das Zielobjekt.</dd> + <dt><code>sources</code></dt> + <dd>Das(Die) Quellobjekt(e).</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das Zielobjekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Eigenschaften in dem Zielobjekt werden von Eigenschaften aus dem Quellobjekt überschrieben, wenn sie den gleichen Schlüssel haben.</p> + +<p>Die Methode <code>Object.assign()</code> kopiert nur <em>aufzählbare</em> und <em>eigene</em> Eigenschaften eines Quellobjekts ins Zielobjekt. Sie verwendet <code>[[Get]]</code> bei der Quelle und <code>[[Set]]</code> beim Ziel, d.h. es werden getters und setters aufgerufen. Daher <em>weist</em> es Eigenschaften zu statt sie nur zu kopieren oder neue Eigenschaften zu definieren. Daher ist die Methode ungeeignet, um neue Eigenschaften zu einem Prototypen hinzufügen wenn die Quellen getters enthalten. Zum Kopieren von Eigenschaftsdefinitionen, einschließlich ihrer Aufzählbarkeit, in Prototypen sollten daher {{jsxref("Object.getOwnPropertyDescriptor()")}} und {{jsxref("Object.defineProperty()")}} verwendet werden.</p> + +<p>Sowohl {{jsxref("String")}}- als auch {{jsxref("Symbol")}}-Eigenschaften werden kopiert.</p> + +<p>Im Fehlerfall, weil z.B. eine Eigenschaft schreibgeschützt ist, wird ein {{jsxref("TypeError")}} erzeugt. Das Zielobjekt kann verändert sein, wenn ein Eigenschaft schon zuvor hinzugefügt wurde.</p> + +<p>Es gilt zu beachten, dass <code>Object.assign()</code> keine Ausnahme bei {{jsxref("null")}} oder {{jsxref("undefined")}} Quellwerten erzeugt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Klonen_eines_Objekts">Klonen eines Objekts</h3> + +<pre class="brush: js">var obj = { a: 1 }; +var copy = Object.assign({}, obj); +console.log(copy); // { a: 1 } +</pre> + +<h3 id="Warnung_bei_tiefem_Clonen">Warnung bei tiefem Clonen</h3> + +<p>Für tiefes Clonen müssen andere Alternativen eingesetzt werden, weil <code>Object.assign()</code> Werte von Eigenschaften kopiert. Wenn ein Quellwert eine Referenz zu einem Objekt ist, wird nur die Referenz kopiert.</p> + +<pre class="brush: js">function test() { + 'use strict'; + + let obj1 = { a: 0 , b: { c: 0}}; + let obj2 = Object.assign({}, obj1); + console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}} + + obj1.a = 1; + console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}} + console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}} + + obj2.a = 2; + console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}} + console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 0}} + + obj2.b.c = 3; + console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 3}} + console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 3}} + + // Deep Clone + obj1 = { a: 0 , b: { c: 0}}; + let obj3 = JSON.parse(JSON.stringify(obj1)); + obj1.a = 4; + obj1.b.c = 4; + console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}} +} + +test();</pre> + +<h3 id="Objekte_zusammenführen">Objekte zusammenführen</h3> + +<pre class="brush: js">var o1 = { a: 1 }; +var o2 = { b: 2 }; +var o3 = { c: 3 }; + +var obj = Object.assign(o1, o2, o3); +console.log(obj); // { a: 1, b: 2, c: 3 } +console.log(o1); // { a: 1, b: 2, c: 3 }, target object itself is changed. +</pre> + +<h3 id="Objekte_mit_gleichen_Eigenschaften_zusammenführen">Objekte mit gleichen Eigenschaften zusammenführen</h3> + +<pre class="brush: js">var o1 = { a: 1, b: 1, c: 1 }; +var o2 = { b: 2, c: 2 }; +var o3 = { c: 3 }; + +var obj = Object.assign({}, o1, o2, o3); +console.log(obj); // { a: 1, b: 2, c: 3 }</pre> + +<p>Eigenschaften werden von anderen Objekten mit gleichen Eigenschaften später in Parameterreihenfolge überschrieben.</p> + +<h3 id="Kopieren_von_Symboltyp-Eigenschaften">Kopieren von Symboltyp-Eigenschaften</h3> + +<pre class="brush: js">var o1 = { a: 1 }; +var o2 = { [Symbol('foo')]: 2 }; + +var obj = Object.assign({}, o1, o2); +console.log(obj); // { a: 1, [Symbol("foo")]: 2 } (siehe Bug 1207182 in Firefox) +Object.getOwnPropertySymbols(obj); // [Symbol(foo)]</pre> + +<h3 id="Eigenschaften_der_Prototypkette_und_nicht_aufzählbare_Eigenschaften_können_nicht_kopiert_werden">Eigenschaften der Prototypkette und nicht aufzählbare Eigenschaften können nicht kopiert werden</h3> + +<pre class="brush: js">var obj = Object.create({ foo: 1 }, { // foo is on obj's prototype chain. + bar: { + value: 2 // bar is a non-enumerable property. + }, + baz: { + value: 3, + enumerable: true // baz is an own enumerable property. + } +}); + +var copy = Object.assign({}, obj); +console.log(copy); // { baz: 3 } +</pre> + +<h3 id="Primitive_Datentypen_werden_in_Objekte_gepackt">Primitive Datentypen werden in Objekte gepackt</h3> + +<pre class="brush: js">var v1 = 'abc'; +var v2 = true; +var v3 = 10; +var v4 = Symbol('foo'); + +var obj = Object.assign({}, v1, null, v2, undefined, v3, v4); +// Primitives will be wrapped, null and undefined will be ignored. +// Note, only string wrappers can have own enumerable properties. +console.log(obj); // { "0": "a", "1": "b", "2": "c" } +</pre> + +<h3 id="Fehler_unterbrechen_den_laufenden_Kopiervorgang">Fehler unterbrechen den laufenden Kopiervorgang</h3> + +<pre class="brush: js">var target = Object.defineProperty({}, 'foo', { + value: 1, + writable: false +}); // target.foo is a read-only property + +Object.assign(target, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 }); +// TypeError: "foo" is read-only +// The Exception is thrown when assigning target.foo + +console.log(target.bar); // 2, the first source was copied successfully. +console.log(target.foo2); // 3, the first property of the second source was copied successfully. +console.log(target.foo); // 1, exception is thrown here. +console.log(target.foo3); // undefined, assign method has finished, foo3 will not be copied. +console.log(target.baz); // undefined, the third source will not be copied either. +</pre> + +<h3 id="Kopieren_von_Zugriffsmethoden">Kopieren von Zugriffsmethoden</h3> + +<pre class="brush: js">var obj = { + foo: 1, + get bar() { + return 2; + } +}; + +var copy = Object.assign({}, obj); +console.log(copy); +// { foo: 1, bar: 2 }, the value of copy.bar is obj.bar's getter's return value. + +// This is an assign function that copies full descriptors +function completeAssign(target, ...sources) { + sources.forEach(source => { + let descriptors = Object.keys(source).reduce((descriptors, key) => { + descriptors[key] = Object.getOwnPropertyDescriptor(source, key); + return descriptors; + }, {}); + // by default, Object.assign copies enumerable Symbols too + Object.getOwnPropertySymbols(source).forEach(sym => { + let descriptor = Object.getOwnPropertyDescriptor(source, sym); + if (descriptor.enumerable) { + descriptors[sym] = descriptor; + } + }); + Object.defineProperties(target, descriptors); + }); + return target; +} + +var copy = completeAssign({}, obj); +console.log(copy); +// { foo:1, get bar() { return 2 } } +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Dieses {{Glossary("Polyfill","polyfill")}} unterstützt keine Symboleigenschaften, da ES5 ohnehin keine Symbole hat:</p> + +<pre class="brush: js">if (typeof Object.assign != 'function') { + // Must be writable: true, enumerable: false, configurable: true + Object.defineProperty(Object, "assign", { + value: function assign(target, varArgs) { // .length of function is 2 + 'use strict'; + if (target == null) { // TypeError if undefined or null + throw new TypeError('Cannot convert undefined or null to object'); + } + + var to = Object(target); + + for (var index = 1; index < arguments.length; index++) { + var nextSource = arguments[index]; + + if (nextSource != null) { // Skip over if undefined or null + for (var nextKey in nextSource) { + // Avoid bugs when hasOwnProperty is shadowed + if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) { + to[nextKey] = nextSource[nextKey]; + } + } + } + } + return to; + }, + writable: true, + configurable: true + }); +} +</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-object.assign', 'Object.assign')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.assign', 'Object.assign')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Object.assign")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.defineProperties()")}}</li> + <li><a href="/de/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Aufzählbarkeit und Zugehörigkeit von Eigenschaften</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/constructor/index.html b/files/de/web/javascript/reference/global_objects/object/constructor/index.html new file mode 100644 index 0000000000..d524a73679 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/constructor/index.html @@ -0,0 +1,192 @@ +--- +title: Object.prototype.constructor +slug: Web/JavaScript/Reference/Global_Objects/Object/constructor +tags: + - JavaScript + - Object + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/constructor +--- +<div>{{JSRef("Global_Objects", "Object")}}</div> + +<h2 id="Summary" name="Summary">Zusammenfassung</h2> + +<p>Gibt eine Referenz zur {{jsxref("Global_Objects/Object", "Object")}}-Funktion, welche die Instanz vom Prototyp herstellt. Merke: Der Wert dieser Eigenschaft ist eine Referenz auf die Funktion selbst und kein String mit dem Funktionsnamen als Inhalt. Der Wert ist nur lesbar für primitive Werte, wie <code>1</code>, <code>true</code> und <code>"test"</code>.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Alle Objekte erben eine constructor- Eigenschaft von ihrem <code>prototype</code>:</p> + +<pre class="brush: js">var o = {}; +o.constructor === Object; // true + +var a = []; +a.constructor === Array; // true + +var n = new Number(3); +n.constructor === Number; // true +</pre> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Displaying_the_constructor_of_an_object" name="Example:_Displaying_the_constructor_of_an_object">Beispiel: zeigen den Konstruktor von einem Objekt an</h3> + +<p>Das folgende Beispiel erzeugt einen Prototyp: <code>Tree</code>, und ein Objekt von jenem Typ: <code>theTree</code>. Das Beispiel zeigt danach die Konstruktor-Eigenschaft vom <code>Objekt:theTree</code> an.</p> + +<pre class="brush: js">function Tree(name) { + this.name = name; +} + +var theTree = new Tree('Redwood'); +console.log('theTree.constructor is ' + theTree.constructor); +</pre> + +<p>Das Beispiel erzeugt folgende Ausgabe:</p> + +<pre class="brush: js">theTree.constructor is function Tree(name) { + this.name = name; +} +</pre> + +<h3 id="Example:_Changing_the_constructor_of_an_object" name="Example:_Changing_the_constructor_of_an_object">Beispiel: Veränderung des Konstruktors eines Objekts</h3> + +<p>Das folgende Beispiel zeigt, wie man den Konstruktorwert eines generischen Objekts verändert. Nur <code>true</code>, <code>1</code> und <code>"test"</code> werden nicht von der Veränderung betroffen, da sie nur lesbare (read-only) native Konstruktoren haben. Dieses Beispiel zeigt, dass es nicht immer sicher ist, sich auf die Konstruktor-Eigenschaft eines Objekts zu verlassen.</p> + +<pre class="brush:js">function Type () {} + +var types = [ + new Array(), + [], + new Boolean(), + true, // bleibt unverändert + new Date(), + new Error(), + new Function(), + function () {}, + Math, + new Number(), + 1, // bleibt unverändert + new Object(), + {}, + new RegExp(), + /(?:)/, + new String(), + 'test' // bleibt unverändert +]; + +for (var i = 0; i < types.length; i++) { + types[i].constructor = Type; + types[i] = [types[i].constructor, types[i] instanceof Type, types[i].toString()]; +} + +console.log(types.join('\n')); +</pre> + +<p>Das Beispiel zeigt folgende Ausgabe:</p> + +<pre class="brush: js">function Type() {},false, +function Type() {},false, +function Type() {},false,false +function Boolean() { + [native code] +},false,true +function Type() {},false,Mon Sep 01 2014 16:03:49 GMT+0600 +function Type() {},false,Error +function Type() {},false,function anonymous() { + +} +function Type() {},false,function () {} +function Type() {},false,[object Math] +function Type() {},false,0 +function Number() { + [native code] +},false,1 +function Type() {},false,[object Object] +function Type() {},false,[object Object] +function Type() {},false,/(?:)/ +function Type() {},false,/(?:)/ +function Type() {},false, +function String() { + [native code] +},false,тест +</pre> + +<h2 id="Specifications" name="Specifications">Spezifikation</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Komentar</th> + </tr> + <tr> + <td>ECMAScript 1 te Edition.</td> + <td>Standard</td> + <td>Ausgangsdefinition: Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.4.1', 'Object.prototype.constructor')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.prototype.constructor', 'Object.prototype.constructor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserunterstützung</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basis- unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basis- unterstützungt</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/de/web/javascript/reference/global_objects/object/create/index.html b/files/de/web/javascript/reference/global_objects/object/create/index.html new file mode 100644 index 0000000000..824ae41561 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/create/index.html @@ -0,0 +1,268 @@ +--- +title: Object.create() +slug: Web/JavaScript/Reference/Global_Objects/Object/create +tags: + - Methode(2) + - Méthode + - Objekt + - Referenz +translation_of: Web/JavaScript/Reference/Global_Objects/Object/create +--- +<div>{{JSRef("Global_Objects", "Object")}}</div> + +<h2 id="Summary" name="Summary">Summary</h2> + +<p>Die <code><strong>Object.create()</strong></code> Methode erstellt ein neues Objekt mit dem angegebenen Prototype object und ggf. zusätzlichen Eigenschaften (properties).</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Object.create(<var>proto</var>[, <var>propertiesObject</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>proto</code></dt> + <dd>Das Objekt, welches als Prototype object des zu erstellenden Objekts verwendet wird.</dd> + <dt><code>propertiesObject</code></dt> + <dd>Optional. Falls angegeben und nicht {{jsxref("Global_Objects/undefined", "undefined")}}, ein Objekt dessen aufzählbare eigene Eigenschaften (properties, d.h.: Eigenschaften, die für das Objekt selbst definiert wurden und nicht in der prototype chain) als Eigenschaften dem neu erstellten Objekt hinzugefügt werden. Die Eigenschaften entsprechen dem zweiten Parameter von {{jsxref("Object.defineProperties()")}}.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neu erzeugtes Objekt mit dem angegebenen Prototype object und den angebenenen Eigenschaften (properties).</p> + +<h3 id="Throws" name="Throws">Ausnahmen</h3> + +<p>Eine {{jsxref("Global_Objects/TypeError", "TypeError")}}-Ausnahme wird ausgelöst, wenn der <code>proto</code>-Parameter weder {{jsxref("Global_Objects/null", "null")}} noch ein Objekt ist.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Classical_inheritance_with_Object.create" name="Example:_Classical_inheritance_with_Object.create">Beispiel: Klassenbasierte Vererbung mit <code>Object.create()</code></h3> + +<p>Im folgenden sehen Sie ein Beispiel wie man <code>Object.create()</code> verwenden kann, um klassenbasierte Vererbung zu realisieren. JavaScript unterstützt nur einzelne Vererbung.</p> + +<pre class="brush: js">// Shape - superclass +function Shape() { + this.x = 0; + this.y = 0; +} + +// superclass method +Shape.prototype.move = function(x, y) { + this.x += x; + this.y += y; + console.info('Shape moved.'); +}; + +// Rectangle - subclass +function Rectangle() { + Shape.call(this); // call super constructor. +} + +// subclass extends superclass +Rectangle.prototype = Object.create(Shape.prototype); +Rectangle.prototype.constructor = Rectangle; + +var rect = new Rectangle(); + +console.log('Is rect an instance of Rectangle? ' + (rect instanceof Rectangle)); // true +console.log('Is rect an instance of Shape? ' + (rect instanceof Shape)); // true +rect.move(1, 1); // Outputs, 'Shape moved.' +</pre> + +<p>Wenn Sie von mehreren Objekten erben wollen, können mixins verwendet werden.</p> + +<pre class="brush: js">function MyClass() { + SuperClass.call(this); + OtherSuperClass.call(this); +} + +MyClass.prototype = Object.create(SuperClass.prototype); // inherit +mixin(MyClass.prototype, OtherSuperClass.prototype); // mixin + +MyClass.prototype.myMethod = function() { + // do a thing +}; +</pre> + +<p>Die <code>mixin</code> Funktion kopiert die Funktionen des superclass Prototypen in den subclass Prototyp. Die mixin Funktion muss vom Benutzer bereitgestellt werden. Ein Beispiel für eine mixin-ähnliche Funktion ist <a href="http://api.jquery.com/jQuery.extend/">jQuery.extend()</a>.</p> + +<h3 id="Example:_Using_propertiesObject_argument_with_Object.create" name="Example:_Using_propertiesObject_argument_with_Object.create">Beispiel: Benutzung des <code>propertiesObject</code> Parameters von <code>Object.create()</code></h3> + +<pre class="brush: js">var o; + +// create an object with null as prototype +o = Object.create(null); + + +o = {}; +// is equivalent to: +o = Object.create(Object.prototype); + + +// Example where we create an object with a couple of sample properties. +// (Note that the second parameter maps keys to *property descriptors*.) +o = Object.create(Object.prototype, { + // foo is a regular 'value property' + foo: { writable: true, configurable: true, value: 'hello' }, + // bar is a getter-and-setter (accessor) property + bar: { + configurable: false, + get: function() { return 10; }, + set: function(value) { console.log('Setting `o.bar` to', value); } +/* with ES5 Accessors our code can look like this + get function() { return 10; }, + set function(value) { console.log('setting `o.bar` to', value); } */ + } +}); + + +function Constructor() {} +o = new Constructor(); +// is equivalent to: +o = Object.create(Constructor.prototype); +// Of course, if there is actual initialization code in the +// Constructor function, the Object.create() cannot reflect it + + +// create a new object whose prototype is a new, empty object +// and a adding single property 'p', with value 42 +o = Object.create({}, { p: { value: 42 } }); + +// by default properties ARE NOT writable, enumerable or configurable: +o.p = 24; +o.p; +// 42 + +o.q = 12; +for (var prop in o) { + console.log(prop); +} +// 'q' + +delete o.p; +// false + +// to specify an ES3 property +o2 = Object.create({}, { + p: { + value: 42, + writable: true, + enumerable: true, + configurable: true + } +}); +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p>Dieser Polyfill deckt den Hauptanwendungsfall, die Erzeugung eines neuen Objektes für das ein Prototyp ausgewählt wurde, ab.</p> + +<p>Bitte beachten Sie, dass dieses Polyfill im Gegensatz zum echten ES5 <code>Object.create</code> den Einsatz von <code>null</code> als Prototyp-Parameter aufgrund einer Einschränkung von ECMAScript vor Version 5 nicht unterstützt.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">if</span> <span class="punctuation token">(</span><span class="keyword token">typeof</span> Object<span class="punctuation token">.</span>create <span class="operator token">!=</span> <span class="string token">'function'</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + Object<span class="punctuation token">.</span>create <span class="operator token">=</span> <span class="punctuation token">(</span><span class="keyword token">function</span><span class="punctuation token">(</span>undefined<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> Temp <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span><span class="punctuation token">}</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> <span class="keyword token">function</span> <span class="punctuation token">(</span>prototype<span class="punctuation token">,</span> propertiesObject<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">if</span><span class="punctuation token">(</span>prototype <span class="operator token">!==</span> <span class="function token">Object</span><span class="punctuation token">(</span>prototype<span class="punctuation token">)</span> <span class="operator token">&&</span> prototype <span class="operator token">!==</span> <span class="keyword token">null</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">throw</span> <span class="function token">TypeError</span><span class="punctuation token">(</span><span class="string token">'Argument must be an object, or null'</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + Temp<span class="punctuation token">.</span>prototype <span class="operator token">=</span> prototype <span class="operator token">||</span> <span class="punctuation token">{</span><span class="punctuation token">}</span><span class="punctuation token">;</span> + <span class="keyword token">if</span> <span class="punctuation token">(</span>propertiesObject <span class="operator token">!==</span> undefined<span class="punctuation token">)</span> <span class="punctuation token">{</span> + Object<span class="punctuation token">.</span><span class="function token">defineProperties</span><span class="punctuation token">(</span>Temp<span class="punctuation token">.</span>prototype<span class="punctuation token">,</span> propertiesObject<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="keyword token">var</span> result <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Temp</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + Temp<span class="punctuation token">.</span>prototype <span class="operator token">=</span> <span class="keyword token">null</span><span class="punctuation token">;</span> + <span class="comment token">// to imitate the case of Object.create(null)</span> + <span class="keyword token">if</span><span class="punctuation token">(</span>prototype <span class="operator token">===</span> <span class="keyword token">null</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + result<span class="punctuation token">.</span>__proto__ <span class="operator token">=</span> <span class="keyword token">null</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> result<span class="punctuation token">;</span> + <span class="punctuation token">}</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></pre> + +<h2 id="Specifications" name="Specifications">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.5', 'Object.create')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.create', 'Object.create')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browser Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("5")}}</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("11.60")}}</td> + <td>{{CompatSafari("5")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatOperaMobile("11.50")}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>Basierend auf <a href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p> + +<h2 id="See_also" name="See_also">Zusätzliches Material</h2> + +<ul> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.defineProperties()")}}</li> + <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li> + <li>John Resig's post on <a href="http://ejohn.org/blog/objectgetprototypeof/">getPrototypeOf()</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/defineproperty/index.html b/files/de/web/javascript/reference/global_objects/object/defineproperty/index.html new file mode 100644 index 0000000000..7120abb08e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/defineproperty/index.html @@ -0,0 +1,413 @@ +--- +title: Object.defineProperty() +slug: Web/JavaScript/Reference/Global_Objects/Object/defineProperty +tags: + - Méthode + - Objekt +translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperty +--- +<div>{{JSRef}}</div> + +<p>Die Methode <code><strong>Object.defineProperty()</strong></code> definiert eine neue Eigenschaft direkt auf ein Objekt, oder modifiziert eine Eigenschaft. Schließlich gibt die Funktion das Objekt zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Object.defineProperty(<var>obj</var>, <var>prop</var>, <var>descriptor</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Das Objekt, welchem die neue Eigenschaft zugewiesen werden soll.</dd> + <dt><code>prop</code></dt> + <dd>Der Name der Eigenschaft, welche hinzugefügt oder modifiziert werden soll.</dd> + <dt><code>descriptor</code></dt> + <dd>Die Beschreibung/ der Wert, welche die neue Eigenschaft annehmen soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das Objekt, welches behandelt wurde.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode erlaubt präzises Hinzufügen oder Modifizieren von Eigenschaften eines Objektes. Normal property addition through assignment creates properties which show up during property enumeration ({{jsxref("Statements/for...in", "for...in")}} loop or {{jsxref("Object.keys")}} method), whose values may be changed, and which may be {{jsxref("Operators/delete", "deleted", "", 1)}}. This method allows these extra details to be changed from their defaults. Standardmäßig sind Werte die mit <code>Object.defineProperty()</code> hinzugefügt wurden unveränderbar.</p> + +<p>Attribut Deskriptoren unterscheiden sich in zwei Varianten: Daten Deskriptoren und Zugiffsdeskriptoren. Ein <em>Datendeskriptor</em> ist ein Attribut welches einen Wert hat das schreibbar oder nicht schreibbar sein kann. Ein <em>Zugriffsdeskriptor</em> ist ein Attribut das mit einem "getter/setter Paar" beschrieben wird. Ein Deskriptor muss von einer dieser beiden Arten sein, er kann nicht beides sein.</p> + +<p>Beide, Daten- und Zugriffsdeskriptoren sind Objekte. Sie teilen die folgenden benötigten Objektschlüssel:</p> + +<dl> + <dt><code>configurable</code></dt> + <dd><code>true</code> if and only if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.<br> + <strong>Defaults to <code>false</code>.</strong></dd> + <dt><code>enumerable</code></dt> + <dd><code>true</code> if and only if this property shows up during enumeration of the properties on the corresponding object.<br> + <strong>Defaults to <code>false</code>.</strong></dd> +</dl> + +<p>Ein Datendeskriptor hat außerdem die folgenden, optionalen Schlüssel:</p> + +<dl> + <dt><code>value</code></dt> + <dd>The value associated with the property. Can be any valid JavaScript value (number, object, function, etc).<br> + <strong>Defaults to {{jsxref("undefined")}}.</strong></dd> + <dt><code>writable</code></dt> + <dd><code>true</code> if and only if the value associated with the property may be changed with an {{jsxref("Operators/Assignment_Operators", "assignment operator", "", 1)}}.<br> + <strong>Defaults to <code>false</code>.</strong></dd> +</dl> + +<p>Ein Zugriffsdeskriptor hat außerdem die folgenden, optionalen Schlüssel:</p> + +<dl> + <dt><code>get</code></dt> + <dd>A function which serves as a getter for the property, or {{jsxref("undefined")}} if there is no getter. The function return will be used as the value of property.<br> + <strong>Defaults to {{jsxref("undefined")}}.</strong></dd> + <dt><code>set</code></dt> + <dd>A function which serves as a setter for the property, or {{jsxref("undefined")}} if there is no setter. The function will receive as only argument the new value being assigned to the property.<br> + <strong>Defaults to {{jsxref("undefined")}}.</strong></dd> +</dl> + +<p>Bear in mind that these options are not necessarily the descriptor's own properties, and properties inherited from the prototype chain will be considered too. In order to ensure these defaults are preserved you might freeze the {{jsxref("Object.prototype")}} upfront or specify all options explicitly.</p> + +<pre class="brush: js">// being explicit +Object.defineProperty(obj, 'key', { + enumerable: false, + configurable: false, + writable: false, + value: 'static' +}); + +// recycling same object +function withValue(value) { + var d = withValue.d || ( + withValue.d = { + enumerable: false, + writable: false, + configurable: false, + value: null + } + ); + d.value = value; + return d; +} +// ... and ... +Object.defineProperty(obj, 'key', withValue('static')); + +// if freeze is available, prevents adding or +// removing the object prototype properties +// (value, get, set, enumerable, writable, configurable) +(Object.freeze || Object)(Object.prototype); +</pre> + +<h2 id="Examples">Examples</h2> + +<p>If you want to see how to use the <code>Object.defineProperty</code> method with a <em>binary-flags-like</em> syntax, see <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty/Additional_examples">additional examples</a>.</p> + +<h3 id="Creating_a_property">Creating a property</h3> + +<p>When the property specified doesn't exist in the object, <code>Object.defineProperty()</code> creates a new property as described. Fields may be omitted from the descriptor, and default values for those fields are imputed. All of the Boolean-valued fields default to <code>false</code>. The <code>value</code>, <code>get</code>, and <code>set</code> fields default to {{jsxref("undefined")}}. A property which is defined without <code>get</code>/<code>set</code>/<code>value</code>/<code>writable</code> is called “generic” and is “typed” as a data descriptor.</p> + +<pre class="brush: js">var o = {}; // Creates a new object + +// Example of an object property added with defineProperty with a data property descriptor +Object.defineProperty(o, 'a', { + value: 37, + writable: true, + enumerable: true, + configurable: true +}); +// 'a' property exists in the o object and its value is 37 + +// Example of an object property added with defineProperty with an accessor property descriptor +var bValue = 38; +Object.defineProperty(o, 'b', { + get: function() { return bValue; }, + set: function(newValue) { bValue = newValue; }, + enumerable: true, + configurable: true +}); +o.b; // 38 +// 'b' property exists in the o object and its value is 38 +// The value of o.b is now always identical to bValue, unless o.b is redefined + +// You cannot try to mix both: +Object.defineProperty(o, 'conflict', { + value: 0x9f91102, + get: function() { return 0xdeadbeef; } +}); +// throws a TypeError: value appears only in data descriptors, get appears only in accessor descriptors +</pre> + +<h3 id="Modifying_a_property">Modifying a property</h3> + +<p>When the property already exists, <code>Object.defineProperty()</code> attempts to modify the property according to the values in the descriptor and the object's current configuration. If the old descriptor had its <code>configurable</code> attribute set to <code>false</code> (the property is said to be “non-configurable”), then no attribute besides <code>writable</code> can be changed. In that case, it is also not possible to switch back and forth between the data and accessor property types.</p> + +<p>If a property is non-configurable, its <code>writable</code> attribute can only be changed to <code>false</code>.</p> + +<p>A {{jsxref("TypeError")}} is thrown when attempts are made to change non-configurable property attributes (besides the <code>writable</code> attribute) unless the current and new values are the same.</p> + +<h4 id="Writable_attribute">Writable attribute</h4> + +<p>When the <code>writable</code> property attribute is set to <code>false</code>, the property is said to be “non-writable”. It cannot be reassigned.</p> + +<pre class="brush: js">var o = {}; // Creates a new object + +Object.defineProperty(o, 'a', { + value: 37, + writable: false +}); + +console.log(o.a); // logs 37 +o.a = 25; // No error thrown (it would throw in strict mode, even if the value had been the same) +console.log(o.a); // logs 37. The assignment didn't work. +</pre> + +<p>As seen in the example, trying to write into the non-writable property doesn't change it but doesn't throw an error either.</p> + +<h4 id="Enumerable_attribute">Enumerable attribute</h4> + +<p>The <code>enumerable</code> property attribute defines whether the property shows up in a {{jsxref("Statements/for...in", "for...in")}} loop and {{jsxref("Object.keys()")}} or not.</p> + +<pre class="brush: js">var o = {}; +Object.defineProperty(o, 'a', { value: 1, enumerable: true }); +Object.defineProperty(o, 'b', { value: 2, enumerable: false }); +Object.defineProperty(o, 'c', { value: 3 }); // enumerable defaults to false +o.d = 4; // enumerable defaults to true when creating a property by setting it + +for (var i in o) { + console.log(i); +} +// logs 'a' and 'd' (in undefined order) + +Object.keys(o); // ['a', 'd'] + +o.propertyIsEnumerable('a'); // true +o.propertyIsEnumerable('b'); // false +o.propertyIsEnumerable('c'); // false +</pre> + +<h4 id="Configurable_attribute">Configurable attribute</h4> + +<p>The <code>configurable</code> attribute controls at the same time whether the property can be deleted from the object and whether its attributes (other than <code>writable</code>) can be changed.</p> + +<pre class="brush: js">var o = {}; +Object.defineProperty(o, 'a', { + get: function() { return 1; }, + configurable: false +}); + +Object.defineProperty(o, 'a', { configurable: true }); // throws a TypeError +Object.defineProperty(o, 'a', { enumerable: true }); // throws a TypeError +Object.defineProperty(o, 'a', { set: function() {} }); // throws a TypeError (set was undefined previously) +Object.defineProperty(o, 'a', { get: function() { return 1; } }); // throws a TypeError (even though the new get does exactly the same thing) +Object.defineProperty(o, 'a', { value: 12 }); // throws a TypeError + +console.log(o.a); // logs 1 +delete o.a; // Nothing happens +console.log(o.a); // logs 1 +</pre> + +<p>If the <code>configurable</code> attribute of <code>o.a</code> had been <code>true</code>, none of the errors would be thrown and the property would be deleted at the end.</p> + +<h3 id="Adding_properties_and_default_values">Adding properties and default values</h3> + +<p>It's important to consider the way default values of attributes are applied. There is often a difference between simply using dot notation to assign a value and using <code>Object.defineProperty()</code>, as shown in the example below.</p> + +<pre class="brush: js">var o = {}; + +o.a = 1; +// is equivalent to: +Object.defineProperty(o, 'a', { + value: 1, + writable: true, + configurable: true, + enumerable: true +}); + + +// On the other hand, +Object.defineProperty(o, 'a', { value: 1 }); +// is equivalent to: +Object.defineProperty(o, 'a', { + value: 1, + writable: false, + configurable: false, + enumerable: false +}); +</pre> + +<h3 id="Custom_Setters_and_Getters">Custom Setters and Getters</h3> + +<p>Example below shows how to implement a self-archiving object. When <code>temperature</code> property is set, the <code>archive</code> array gets a log entry.</p> + +<pre class="brush: js">function Archiver() { + var temperature = null; + var archive = []; + + Object.defineProperty(this, 'temperature', { + get: function() { + console.log('get!'); + return temperature; + }, + set: function(value) { + temperature = value; + archive.push({ val: temperature }); + } + }); + + this.getArchive = function() { return archive; }; +} + +var arc = new Archiver(); +arc.temperature; // 'get!' +arc.temperature = 11; +arc.temperature = 13; +arc.getArchive(); // [{ val: 11 }, { val: 13 }] +</pre> + +<p>or</p> + +<pre class="brush: js">var pattern = { + get: function () { + return 'I always return this string, whatever you have assigned'; + }, + set: function () { + this.myname = 'this is my name string'; + } +}; + + +function TestDefineSetAndGet() { + Object.defineProperty(this, 'myproperty', pattern); +} + + +var instance = new TestDefineSetAndGet(); +instance.myproperty = 'test'; +console.log(instance.myproperty); // I always return this string, whatever you have assigned + +console.log(instance.myname); // this is my name string + +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.6', 'Object.defineProperty')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.defineproperty', 'Object.defineProperty')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.defineproperty', 'Object.defineProperty')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Firefox (Gecko)</th> + <th>Chrome</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>{{CompatChrome("5")}}</td> + <td>{{CompatIE("9")}} [1]</td> + <td>{{CompatOpera("11.60")}}</td> + <td>{{CompatSafari("5.1")}} [2]</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Firefox Mobile (Gecko)</th> + <th>Android</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatGeckoMobile("2")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOperaMobile("11.5")}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] In Internet Explorer 8 only on DOM objects and with some non-standard behaviors.</p> + +<p>[2] Also supported in Safari 5, but not on DOM objects.</p> + +<h2 id="Compatibility_notes">Compatibility notes</h2> + +<h3 id="Redefining_the_length_property_of_an_Array_object">Redefining the <code>length</code> property of an <code>Array</code> object</h3> + +<p>It is possible to redefine the {{jsxref("Array.length", "length")}} property of arrays, subject to the usual redefinition restrictions. (The {{jsxref("Array.length", "length")}} property is initially non-configurable, non-enumerable, and writable. Thus on an unaltered array it is possible to change the {{jsxref("Array.length", "length")}} property's value, or to make it non-writable. It is not allowed to change its enumerability or configurability, or if it is non-writable to change its value or writability.) However, not all browsers permit this redefinition.</p> + +<p>Firefox 4 through 22 will throw a {{jsxref("TypeError")}} on any attempt whatsoever (whether permitted or not) to redefine the {{jsxref("Array.length", "length")}} property of an array.</p> + +<p>Versions of Chrome which implement <code>Object.defineProperty()</code> in some circumstances ignore a length value different from the array's current {{jsxref("Array.length", "length")}} property. In some circumstances changing writability seems to silently not work (and not throw an exception). Also, relatedly, some array-mutating methods like {{jsxref("Array.prototype.push")}} don't respect a non-writable length.</p> + +<p>Versions of Safari which implement <code>Object.defineProperty()</code> ignore a <code>length</code> value different from the array's current {{jsxref("Array.length", "length")}} property, and attempts to change writability execute without error but do not actually change the property's writability.</p> + +<p>Only Internet Explorer 9 and later, and Firefox 23 and later, appear to fully and correctly implement redefinition of the {{jsxref("Array.length", "length")}} property of arrays. For now, don't rely on redefining the {{jsxref("Array.length", "length")}} property of an array to either work, or to work in a particular manner. And even when you <em>can</em> rely on it, <a href="http://whereswalden.com/2013/08/05/new-in-firefox-23-the-length-property-of-an-array-can-be-made-non-writable-but-you-shouldnt-do-it/">there's really no good reason to do so</a>.</p> + +<h3 id="Internet_Explorer_8_specific_notes">Internet Explorer 8 specific notes</h3> + +<p>Internet Explorer 8 implemented a <code>Object.defineProperty()</code> method that could <a class="external" href="https://msdn.microsoft.com/en-us/library/dd229916%28VS.85%29.aspx">only be used on DOM objects</a>. A few things need to be noted:</p> + +<ul> + <li>Trying to use <code>Object.defineProperty()</code> on native objects throws an error.</li> + <li>Property attributes must be set to some values. <code>Configurable</code>, <code>enumerable</code> and <code>writable</code> attributes should all be set to <code>true</code> for data descriptor and <code>true</code> for <code>configurable</code>, <code>false</code> for <code>enumerable</code> for accessor descriptor.(?) Any attempt to provide other value(?) will result in an error being thrown.</li> + <li>Reconfiguring a property requires first deleting the property. If the property isn't deleted, it stays as it was before the reconfiguration attempt.</li> +</ul> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li> + <li>{{jsxref("Object.defineProperties()")}}</li> + <li>{{jsxref("Object.propertyIsEnumerable()")}}</li> + <li>{{jsxref("Object.getOwnPropertyDescriptor()")}}</li> + <li>{{jsxref("Object.prototype.watch()")}}</li> + <li>{{jsxref("Object.prototype.unwatch()")}}</li> + <li>{{jsxref("Operators/get", "get")}}</li> + <li>{{jsxref("Operators/set", "set")}}</li> + <li>{{jsxref("Object.create()")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty/Additional_examples">Additional <code>Object.defineProperty</code> examples</a></li> + <li>{{jsxref("Reflect.defineProperty()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/entries/index.html b/files/de/web/javascript/reference/global_objects/object/entries/index.html new file mode 100644 index 0000000000..4ac921f62b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/entries/index.html @@ -0,0 +1,168 @@ +--- +title: Object.entries() +slug: Web/JavaScript/Reference/Global_Objects/Object/entries +tags: + - Entries + - Iterieren + - JavaScript + - Méthode + - Objekt + - Referenz + - Schleife +translation_of: Web/JavaScript/Reference/Global_Objects/Object/entries +--- +<div>{{JSRef}}</div> + +<p><code><strong>Object.entries()</strong></code><strong> </strong>ist eine Methode für Objekte. Zurückgegeben wird ein Array mit den Eigenschaften des Objektes. Diese Eigenschaften werden in Key-Value-Paaren als zählbare strings zurückgegeben.</p> + +<p>Im Gegensatz zur {{jsxref("Statements/for...in", "for...in")}}-Schleife werden dabei nicht die constructor- Eigenschaften zurückgegeben, die das Objekt von seinem <code>prototype</code> geerbt hat.</p> + +<div> +<p>Die Reihenfolge der Key-Value-Paare ist dabei die gleiche wie bei einer {{jsxref("Statements/for...in", "for...in")}}-Schleife. Sie hängt nicht davon ab, wie das ursprüngliche Objekt aufgebaut ist. Ist eine bestimmte Reihenfolge erwünscht, muss der Array sortiert werden:<br> + <code>Object.entries(obj).sort((a, b) => b[0].localeCompare(a[0]));</code>.</p> + +<p> </p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/object-entries.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Object.entries(<var>obj</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Ein Objekt besitzt Eigenschaften in Form von Key-Value-Paaren. </dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Zurückgegeben wird ein Array mit den Key-Value-Paaren (<code>[key, value]</code>) eines Objektes in Form von zählbaren strings.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>Object.entries()</code> erzeugt einen Array auf Basis eines Objekts. Die Eigenschaften des Objekts werden im Array als Key-Value-Paare gespeichert.<br> + Die Reihenfolge der Eigenschaften ist dabei gleich einer manuellen Iteration über das Objekt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">const obj = { foo: 'bar', baz: 42 }; +console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ] + +// Array-ähnliches Objekt +const obj = { 0: 'a', 1: 'b', 2: 'c' }; +console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ] + +// Array-ähnliches Objekt mit zufälliger Reihenfolge der Keys +const anObj = { 100: 'a', 2: 'b', 7: 'c' }; +console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ] + +// getFoo- Eigenschaft ist nicht zählbar +const myObj = Object.create({}, { getFoo: { value() { return this.foo; } } }); +myObj.foo = 'bar'; +console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ] + +// Das Argument, das kein Objekt ist, wird in ein Objekt umgewandelt +console.log(Object.entries('foo')); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ] + +// Gibt einen Leeren Array zurück, da primitive Datentypen keine eigenen Eigenschaften haben +console.log(Object.entries(100)); // [ ] + +// Elegant über Key-Value-Paare iterieren +const obj = { a: 5, b: 7, c: 9 }; +for (const [key, value] of Object.entries(obj)) { + console.log(`${key} ${value}`); // "a 5", "b 7", "c 9" +} + +// Mit array extras über Key-Value-Paare iterieren +Object.entries(obj).forEach(([key, value]) => { + console.log(`${key} ${value}`); // "a 5", "b 7", "c 9" +}); +</pre> + +<h3 id="Ein_Object_in_ein_Map-Objekt_umwandeln">Ein <code>Object</code> in ein <code>Map-Objekt</code> umwandeln</h3> + +<p>Der {{jsxref("Map", "new Map()")}}-constructor akzeptiert zählbare <code>entries</code>. Mithilfe von <code>Object.entries</code> kann ein {{jsxref("Object")}} in ein {{jsxref("Map")}}-Objekt umgewandelt werden:</p> + +<pre class="brush: js">const obj = { foo: 'bar', baz: 42 }; +const map = new Map(Object.entries(obj)); +console.log(map); // Map { foo: "bar", baz: 42 } +</pre> + +<h3 id="Durch_das_Object_iterieren">Durch das <code>Object</code> iterieren</h3> + +<p>Mit der Technik der <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Destrukturierende_Zuweisung">destrukturierenden Zuweisung</a> kann durch Objekte iteriert werden.</p> + +<pre class="brush: js">const obj = { foo: 'bar', baz: 42 }; +Object.entries(obj).forEach(([key, value]) => console.log(`${key}: ${value}`)); // "foo: bar", "baz: 42" +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Um <code>Object.entries</code> auch in älteren Umgebungen zu nutzen, die diese Methode nicht nativ unterstützen, sind Polyfills im <a href="https://github.com/tc39/proposal-object-values-entries">tc39/proposal-object-values-entries</a> (ohne IE) order im <a href="https://github.com/es-shims/Object.entries">es-shims/Object.entries</a>-Repository finden. Untenstehender Polyfill ist ebenfalls verwendbar:</p> + +<pre class="brush: js">if (!Object.entries) { + Object.entries = function( obj ){ + var ownProps = Object.keys( obj ), + i = ownProps.length, + resArray = new Array(i); // preallocate the Array + while (i--) + resArray[i] = [ownProps[i], obj[ownProps[i]]]; + + return resArray; + }; +} +</pre> + +<p>Sollten Sie auch IE < 9 unterstützen müssen, brauchen sie jedoch zusätzlich den <code>Object.keys</code>-Polyfill, zu finden auf {{jsxref("Object.keys")}}.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.entries', 'Object.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-object.entries', 'Object.entries')}}</td> + <td>{{Spec2('ES8')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Object.entries")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li> + <li>{{jsxref("Object.keys()")}}</li> + <li>{{jsxref("Object.values()")}}</li> + <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li> + <li>{{jsxref("Object.create()")}}</li> + <li>{{jsxref("Object.fromEntries()")}}</li> + <li>{{jsxref("Object.getOwnPropertyNames()")}}</li> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.keys()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/freeze/index.html b/files/de/web/javascript/reference/global_objects/object/freeze/index.html new file mode 100644 index 0000000000..b0379d636c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/freeze/index.html @@ -0,0 +1,253 @@ +--- +title: Object.freeze() +slug: Web/JavaScript/Reference/Global_Objects/Object/freeze +tags: + - ECMAScript5 + - JavaScript + - Methode(2) + - Objekt +translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze +--- +<div>{{JSRef}}</div> + +<p>Die Methode <code><strong>Object.freeze()</strong></code> <strong>friert</strong> ein Objekt <strong>ein</strong>. Ein eingefrorenes Objekt kann nicht mehr geändert werden. Das Einfrieren eines Objekts verhindert, dass neue Eigenschaften hinzugefügt oder existierende entfernt und die Aufzählbarkeit, Konfigurierbarkeit oder Schreibbarkeit vorhandener Eigenschaften und deren Werte geändert werden können. Durch das Einfrieren eines Objekts wird außerdem verhindert, dass der Prototyp geändert wird. <code>freeze()</code> gibt das gleiche Objekt zurück, das übergeben wurde.</p> + +<div>{{EmbedInteractiveExample("pages/js/object-freeze.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Object.freeze(<var>obj</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Das einzufrierende Objekt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das Objekt, welches an die Funktion übergeben wurde.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Zum Eigenschaftssatz eines eingefrorenen Objekts kann nichts hinzugefügt oder daraus entfernt werden. Jeder Versuch, dies zu tun, schlägt fehl, entweder im Hintergrund oder durch Auslösen einer {{jsxref("TypeError")}} Exception (meistens, jedoch nicht ausschließlich, wenn im {{jsxref("Strict_mode", "strikten Modus", "", 1)}}).</p> + +<p>Bei Dateneigenschaften eines eingefrorenen Objekts können Werte nicht geändert werden. Die Attribute für Beschreibbarkeit und Konfigurierbarkeit werden auf false gesetzt. Accessor-Eigenschaften (Getter und Setter) funktionieren gleich (und lassen einen nach wie vor in dem Glauben etwas zu ändern). Beachten Sie, dass Werte, die Objekte sind, immer noch geändert werden können, es sei denn, sie werden ebenfalls eingefroren. Da ein Array ein Objekt ist, kann es eingefroren werden. Danach können seine Elemente nicht mehr geändert und keine Elemente hinzugefügt oder entfernt werden.</p> + +<p><code>freeze()</code> gibt das gleiche Objekt zurück, das an die Funktion übergeben wurde. Es wird <em>keine</em> eingefrorene Kopie erstellt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Objekte_einfrieren">Objekte einfrieren</h3> + +<pre class="brush: js">var obj = { + prop: function() {}, + foo: 'bar' +}; + +// Vor dem Einfrieren: neue Eigenschaften können hinzugefügt +// und vorhandene Eigenschaften geändert oder entfernt werden +obj.foo = 'baz'; +obj.lumpy = 'woof'; +delete obj.prop; + +// Einfrieren +var o = Object.freeze(obj); + +// Der Rückgabewert ist dasselbe Objekt, das übergeben wurde +o === obj; // true + +// Das Objekt ist eingefroren +Object.isFrozen(obj); // === true + +// Jetzt schlagen sämtliche Änderungen fehl +obj.foo = 'quux'; // nichts passiert, im Stillen +// fügt die Eigenschaft nicht hinzu, im Stillen +obj.quaxxor = 'the friendly duck'; + +// Im strikten Modus lösen solche Versuche TypeErrors aus +function fail(){ + 'use strict'; + obj.foo = 'sparky'; // löst TypeError aus + delete obj.foo; // löst TypeError aus + delete obj.quaxxor; // gibt true zurück, da Attribut 'quaxxor' nie hinzugefügt wurde + obj.sparky = 'arf'; // löst TypeError aus +} + +fail(); + +// Versuchte Änderungen über Object.defineProperty; +// beide Anweisungen lösen TypeError aus +Object.defineProperty(obj, 'ohai', { value: 17 }); +Object.defineProperty(obj, 'foo', { value: 'eit' }); + +// Der prototype kann ebenfalls nicht geändert werden +// beide Anweisungen lösen TypeError aus +Object.setPrototypeOf(obj, { x: 20 }) +obj.__proto__ = { x: 20 } +</pre> + +<h3 id="Arrays_einfrieren">Arrays einfrieren</h3> + +<pre class="brush: js">let a = [0]; +Object.freeze(a); // Das Array kann nicht mehr geändert werden + +a[0]=1; // schlägt still fehl +a.push(2); // schlägt still fehl + +// Im strikten Modus lösen solche Versuche TypeErrors aus +function fail() { + "use strict" + a[0] = 1; + a.push(2); +} + +fail();</pre> + +<p>Das eingefrorene Objekt ist <em>unveränderlich</em> (engl. <em>immutable</em>). Es ist jedoch nicht notwendigerweise <em>konstant</em>. Das folgende Beispiel zeigt, dass ein eingefrorenes Objekt nicht konstant ist (Einfrieren ist flach).</p> + +<pre class="brush: js">obj1 = { + internal: {} +}; + +Object.freeze(obj1); +obj1.internal.a = 'aValue'; + +obj1.internal.a // 'aValue'</pre> + +<p>Um ein konstantes Objekt zu sein, muss der gesamte Referenzgraph (direkte und indirekte Verweise auf andere Objekte) nur unveränderliche eingefrorene Objekte referenzieren. Das eingefrorene Objekt wird als unveränderlich (immutable) bezeichnet, da der gesamte <em>Objektzustand</em> (Werte und Verweise auf andere Objekte) innerhalb des gesamten Objekts fix ist. Beachten Sie, dass Strings, Zahlen und Booleans immer unveränderlich (immutable) und Funktionen und Arrays Objekte sind.</p> + +<h4 id="Was_ist_flaches_Einfrieren">Was ist "flaches Einfrieren"?</h4> + +<p>Das Ergebnis des Aufrufs von <code>Object.freeze(<var>object</var>)</code> gilt nur für die unmittelbaren Eigenschaften von <code>object</code> selbst und verhindert, dass zukünftige Eigenschaften hinzugefügt, entfernt oder Werte auf <em>diesem</em> <code>object</code> neu zugewiesen werden. Wenn der Wert dieser Eigenschaften selbst Objekte sind, werden diese Objekte nicht eingefroren und können das Ziel von Eigenschaftszusatz-, Entfernungs- oder Wertzuordnungsvorgängen sein.</p> + +<pre class="brush: js">var employee = { + name: "Mayank", + designation: "Developer", + address: { + street: "Rohini", + city: "Delhi" + } +}; + +Object.freeze(employee); + +employee.name = "Dummy"; // schlägt im nicht-strikten Modus still fehl +employee.address.city = "Noida"; // Attribute von Kind-Objekt können geändert werden + +console.log(employee.address.city) // Ausgabe: "Noida" +</pre> + +<p>Um ein Objekt unveränderlich zu machen, frieren Sie rekursiv jede Eigenschaft vom Typ <code>object</code> ein (deep freeze). Verwenden Sie das Muster im Einzelfall basierend auf Ihrem Entwurf, wenn Sie wissen, dass das Objekt keine {{interwiki("wikipedia", "Zyklus_(Graphentheorie)", "Zyklen")}} im Referenzgraph enthält, andernfalls kommt es zu einer Endlosschleife. Eine Verbesserung von <code>deepFreeze()</code> wäre eine interne Funktion, die ein Argument für einen Pfad (z. B. ein Array) empfängt, sodass Sie den Aufruf von <code>deepFreeze()</code> rekursiv unterdrücken können, wenn ein Objekt gerade unveränderlich gemacht wird. Es besteht weiterhin die Gefahr, dass ein Objekt eingefroren wird, das nicht eingefroren werden sollte, wie z. B. [window].</p> + +<pre class="brush: js">function deepFreeze(object) { + + // Abrufen der definierten Eigenschaftsnamen des Objekts + var propNames = Object.getOwnPropertyNames(object); + + // Eigenschaften vor dem eigenen Einfrieren einfrieren + + for (let name of propNames) { + let value = object[name]; + + object[name] = value && typeof value === "object" ? + deepFreeze(value) : value; + } + + return Object.freeze(object); +} + +var obj2 = { + internal: { + a: null + } +}; + +deepFreeze(obj2); + +obj2.internal.a = 'anotherValue'; // schlägt im nicht-strikten Modus still fehl +obj2.internal.a; // null +</pre> + +<h2 id="Nutzungshinweise">Nutzungshinweise</h2> + +<p>Wenn das Argument für diese Methode kein Objekt (ein Primitiv) ist, führt dies in ES5 zu einem {{jsxref("TypeError")}}. In ES2015 wird ein Nicht-Objekt-Argument wie ein eingefrorenes gewöhnliches Objekt behandelt und einfach zurückgegeben.</p> + +<pre class="brush: js">> Object.freeze(1) +TypeError: 1 is not an object // ES5 Code + +> Object.freeze(1) +1 // ES2015 Code +</pre> + +<p>Ein {{domxref("ArrayBufferView")}} mit Elementen verursacht einen {{jsxref("TypeError")}}, da diese Ansichten über den Arbeitsspeicher sind und auf jeden Fall andere mögliche Probleme verursachen können:</p> + +<pre class="brush: js">> Object.freeze(new Uint8Array(0)) // Keine Elemente +Uint8Array [] + +> Object.freeze(new Uint8Array(1)) // Hat Elemente +TypeError: Cannot freeze array buffer views with elements + +> Object.freeze(new DataView(new ArrayBuffer(32))) // Keine Elemente +DataView {} + +> Object.freeze(new Float64Array(new ArrayBuffer(64), 63, 0)) // Keine Elemente +Float64Array [] + +> Object.freeze(new Float64Array(new ArrayBuffer(64), 32, 2)) // Hat Elemente +TypeError: Cannot freeze array buffer views with elements +</pre> + +<p>Beachten Sie, da die drei Standard-Eigenschaften (<code>buf.byteLength</code>, <code>buf.byteOffset</code> und <code>buf.buffer</code>) schreibgeschützt sind (wie die Eigenschaften eines {{jsxref("ArrayBuffer")}} oder {{jsxref("SharedArrayBuffer")}}) gibt es keinen Grund, diese einzufrieren.</p> + +<h3 id="Vergleich_zu_Object.seal()">Vergleich zu <code>Object.seal()</code></h3> + +<p>Vorhandene Eigenschaften in Objekten, die mit {{jsxref("Object.seal()")}} versiegelt wurden, können geändert werden. Vorhandene Eigenschaften in Objekten, die mit <code>Object.freeze()</code> eingefroren wurden, werden unveränderlich gemacht.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.9', 'Object.freeze')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.freeze', 'Object.freeze')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.freeze', 'Object.freeze')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Object.freeze")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.isFrozen()")}}</li> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> + <li>{{jsxref("Object.seal()")}}</li> + <li>{{jsxref("Object.isSealed()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/getownpropertynames/index.html b/files/de/web/javascript/reference/global_objects/object/getownpropertynames/index.html new file mode 100644 index 0000000000..1e76977b49 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/getownpropertynames/index.html @@ -0,0 +1,201 @@ +--- +title: Object.getOwnPropertyNames() +slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames +tags: + - german +translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Object.getOwnPropertyNames()</code></strong> Methode gibt einen Array mit allen Eigenschaftsnamen (aufzählbar oder nicht) zurück, welche direkt auf einem Objekt gefunden werden. </p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Object.getOwnPropertyNames(<var>obj</var>)</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Das Objekt dessen aufzählbaren und nicht aufzählbaren Eigenschaftsnamen gesucht sind. </dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Object.getOwnPropertyNames () gibt ein Array zurück, dessen Elemente Strings sind, die den aufzählbar und nicht aufzählbar Eigenschaften direkt auf dem Objekt gefunden werden. Die Reihenfolge der Enumerable-Objekte im Array steht im Einklang mit der Benutzung von einer exponierten Schleife {{jsxref ("Statements / for ... in", "for ... in")}} (oder durch {{jsxref ("Object.keys () ")}}) über die Eigenschaften des Objekts. Die Reihenfolge der nicht-aufzählbar Objekte im Array, und unter den aufzählbare Eigenschaften, ist nicht definiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_Object.getOwnPropertyNames()"><code>Benutzung von Object.getOwnPropertyNames()</code></h3> + +<pre class="brush: js">var arr = ['a', 'b', 'c']; +console.log(Object.getOwnPropertyNames(arr).sort()); // logs '0,1,2,length' + +// Array-like object +var obj = { 0: 'a', 1: 'b', 2: 'c' }; +console.log(Object.getOwnPropertyNames(obj).sort()); // logs '0,1,2' + +// Logging property names and values using Array.forEach +Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) { + console.log(val + ' -> ' + obj[val]); +}); +// logs +// 0 -> a +// 1 -> b +// 2 -> c + +// non-enumerable property +var my_obj = Object.create({}, { + getFoo: { + value: function() { return this.foo; }, + enumerable: false + } +}); +my_obj.foo = 1; + +console.log(Object.getOwnPropertyNames(my_obj).sort()); // logs 'foo,getFoo' +</pre> + +<p>Wenn Sie nur die aufzählbare Eigenschaften möchten, kann man die Funktion {{jsxref ("Object.keys ()")}} benutzen. Alternativ können auch Schlaufen {{jsxref ("Statements / for ... in", "for ... in")}} verwendet werden (dies gibt nicht nur die aufzählbaren Eigenschaften des Objektes, sondern auch entlang der Prototypkette zurück. Behoben kann diese mit der Methode {{jsxref ("Object.prototype.hasOwnProperty ()", "hasOwnProperty ()" )}}).</p> + +<p>Items welche sich im Prototype chain befinden, werden nicht aufgelistet.</p> + +<pre class="brush: js">function ParentClass() {} +ParentClass.prototype.inheritedMethod = function() {}; + +function ChildClass() { + this.prop = 5; + this.method = function() {}; +} +ChildClass.prototype = new ParentClass; +ChildClass.prototype.prototypeMethod = function() {}; + +console.log( + Object.getOwnPropertyNames( + new ChildClass() // ['prop', 'method'] + ) +); +</pre> + +<h3 id="Nur_unzählige_Eigenschaften">Nur unzählige Eigenschaften</h3> + +<p>Es wird die {{jsxref("Array.prototype.filter()")}} Funktion benötigt um alle zählbaren Schlüssel (erhalten mit {{jsxref("Object.keys()")}}) von einer Liste mit allen Schlüsseln (erhalten mit <code>Object.getOwnPropertyNames()</code>) zu vergleichen, welches nur die unzähligen Eigenschaften zurück lässt.</p> + +<pre class="brush: js">var target = myObject; +var enum_and_nonenum = Object.getOwnPropertyNames(target); +var enum_only = Object.keys(target); +var nonenum_only = enum_and_nonenum.filter(function(key) { + var indexInEnum = enum_only.indexOf(key); + if (indexInEnum == -1) { + // not found in enum_only keys mean the key is non-enumerable, + // so return true so we keep this in the filter + return true; + } else { + return false; + } +}); + +console.log(nonenum_only); +</pre> + +<h2 id="Notizen">Notizen</h2> + +<p>Wenn bei ES5 das Argument der Methode kein primitives Objekt ist, wird der Funktionsaufruf ein {{jsxref("TypeError")}} werfen. In ES6 wird ein nicht-Objekt Argument automatisch in ein Objekt gecasted.</p> + +<pre class="brush: js">Object.getOwnPropertyNames('foo'); +// TypeError: "foo" is not an object (ES5 code) + +Object.getOwnPropertyNames('foo'); +// ['length', '0', '1', '2'] (ES6 code) +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.4', 'Object.getOwnPropertyNames')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initialdefinition. Implementiert in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.getownpropertynames', 'Object.getOwnPropertyNames')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basissupport</td> + <td>{{CompatChrome("5")}}</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12")}}</td> + <td>{{CompatSafari("5")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basissupport</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="SpiderMonkey-spezifische_Notizen">SpiderMonkey-spezifische Notizen</h2> + +<p> </p> + +<p>Vor SpiderMonkey 28 {{geckoRelease("28")}}, ignorierte die Funktion <code>Object.getOwnPropertyNames</code> unaufgelöste Eigenschaften eines {{jsxref("Error")}} Objektes. Dieser Fehler wurde in den letzten Versionen behoben ({{bug("724768")}}).</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li> + <li>{{jsxref("Object.prototype.hasOwnProperty()")}}</li> + <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li> + <li>{{jsxref("Object.create()")}}</li> + <li>{{jsxref("Object.keys()")}}</li> + <li>{{jsxref("Array.forEach()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/getprototypeof/index.html b/files/de/web/javascript/reference/global_objects/object/getprototypeof/index.html new file mode 100644 index 0000000000..cb2c6c0028 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/getprototypeof/index.html @@ -0,0 +1,133 @@ +--- +title: Object.getPrototypeOf() +slug: Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf +translation_of: Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Object.getPrototypeOf()</strong></code> Methode gibt den Prototyp (den Wert der internen <code>[[Prototype]]</code> Eigenschaft) des angegebenen Objekts <em>obj</em> zurück</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Object.getPrototypeOf(<var>obj</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Das Objekt, dessen Prototyp zurückgegeben werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der Prototyp des Objekts <em>obj</em> wird zurückgegeben. Wenn keine Eigenschaften vererbt werden, wird {{jsxref("null")}} zurück gegeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var proto = {}; +var obj = Object.create(proto); +Object.getPrototypeOf(obj) === proto; // true +</pre> + +<h2 id="Notizen">Notizen</h2> + +<p>In ES5 wird eine {{jsxref("TypeError")}} exception geworfen, falls der Parameter obj kein Objekt ist . In ES2015 wird der Parameter <em>obj</em> in ein {{jsxref("Object")}} umgewandelt.</p> + +<pre class="brush: js">Object.getPrototypeOf('foo'); +// TypeError: "foo" is not an object (ES5 code) +Object.getPrototypeOf('foo'); +// String.prototype (ES2015 code) +</pre> + +<h2 id="Spezifikation">Spezifikation</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.2', 'Object.getPrototypeOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.getprototypeof', 'Object.getProtoypeOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.getprototypeof', 'Object.getProtoypeOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("5")}}</td> + <td>{{CompatGeckoDesktop("1.9.1")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12.10")}}</td> + <td>{{CompatSafari("5")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Opera-spezfische_Notizen">Opera-spezfische Notizen</h2> + +<p>Even though older Opera versions don't support <code>Object.getPrototypeOf()</code> yet, Opera supports the non-standard {{jsxref("Object.proto", "__proto__")}} property since Opera 10.50.</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li> + <li>{{jsxref("Object.setPrototypeOf()")}}</li> + <li>{{jsxref("Object.prototype.__proto__")}}</li> + <li>John Resig's post on <a class="external" href="http://ejohn.org/blog/objectgetprototypeof/">getPrototypeOf</a></li> + <li>{{jsxref("Reflect.getPrototypeOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/hasownproperty/index.html b/files/de/web/javascript/reference/global_objects/object/hasownproperty/index.html new file mode 100644 index 0000000000..1d990d3bfa --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/hasownproperty/index.html @@ -0,0 +1,203 @@ +--- +title: Object.prototype.hasOwnProperty() +slug: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty +--- +<div>{{JSRef}}</div> + +<p>Die Methode <code><strong>hasOwnProperty() </strong></code>gibt einen boolean Wert zurück abhängig von der Existenz des gegebenen <strong>Attributs</strong> in einem <strong>Objekt.</strong></p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>obj</var>.hasOwnProperty(<var>prop</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>prop</code></dt> + <dd>Der Name des Attributs auf dessen Existenz im Objekt geprüft wird</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Boolean")}} der besagt, ob eine Eigenschaft in dem gegebenen Objekte vorhanden ist oder nicht.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Jedes untergeordnete Objekt / jeder untergeordneter Wert in einem Objekt trägt die hasOwnProperty Methode mit sich. Diese Methode ermöglicht das Nachfragen eines untergeordneten Wertes/Objekts innerhalb eines Objekts. Anders als die {{jsxref("Operators/in", "in")}} Methode ermöglicht die hasOwnProperty Methode keinen Zugriff auf die Kindeskinder eines Objekts.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_hasOwnProperty_zur_Überprüfung_der_Existenz_eines_Attributs_in_einem_Objekt">Einsatz von hasOwnProperty zur Überprüfung der Existenz eines Attributs in einem Objekt</h3> + +<p>Das folgende Beispiel prüft ob das Objekt <code>o</code> ein Attribut mit dem Namen <code>prop</code> beinhaltet.</p> + +<pre class="brush: js">o = new Object(); +o.prop = 'exists'; + +function changeO() { + o.newprop = o.prop; + delete o.prop; +} + +o.hasOwnProperty('prop'); // gibt true zurück +changeO(); +o.hasOwnProperty('prop'); // gibt false zurück +</pre> + +<h3 id="Direkter_Nachfolger_vs_Geerbtes_Attribut">Direkter Nachfolger vs Geerbtes Attribut</h3> + +<p>Das folgende Beispiel unterscheidet zwischen direkten Kind-Attributen eines Objekts und den Attributen die durch die prototype - Verarbeitung entstehen.</p> + +<pre class="brush: js">o = new Object(); +o.prop = 'exists'; +o.hasOwnProperty('prop'); // gibt true zurück +o.hasOwnProperty('toString'); // gibt false zurück +o.hasOwnProperty('hasOwnProperty'); // gibt false zurück +</pre> + +<h3 id="Über_die_Eigenschaften_eines_Objektes_iterieren">Über die Eigenschaften eines Objektes iterieren</h3> + +<p>Das folgende Beispiel zeigt, wie man über die Eigenschaften eines Objektes iteriert ohne vererbte Eigenschaften auszuführen. Zu Beachten ist, dass eine {{jsxref("Statements/for...in", "for...in")}} Schleife nur über zählbare (enumerable) Eigenschaften iteriert, jedoch sollte man durch diese Einschränkung nicht annehmen, dass nicht-zählbare Eigenschaften gezeigt werden, denn <code>hasOwnProperty</code> selbst kann nur auf zählbare Eigenschaften angewendet werden (wie auch die {{jsxref("Object.getOwnPropertyNames()")}} Funktion):</p> + +<pre class="brush: js">var buz = { + fog: 'stack' +}; + +for (var name in buz) { + if (buz.hasOwnProperty(name)) { + console.log('this is fog (' + name + ') for sure. Value: ' + buz[name]); + } + else { + console.log(name); // toString or something else + } +} +</pre> + +<h3 id="Einsatz_von_hasOwnProperty_als_Eigenschaftsname">Einsatz von <code>hasOwnProperty</code> als Eigenschaftsname</h3> + +<p>JavaScript schützt die den Eigenschaftsnamen <code>hasOwnProperty</code> nicht. Dadurch ist es möglich, dass ein Objekt eine Eigenschaft mit diesem namen hat. Das ermöglicht es eine externe <code>hasOwnProperty</code> Funktion zu benutzen:</p> + +<pre class="brush: js">var foo = { + hasOwnProperty: function() { + return false; + }, + bar: 'Here be dragons' +}; + +foo.hasOwnProperty('bar'); // always returns false + +// Use another Object's hasOwnProperty and call it with 'this' set to foo +({}).hasOwnProperty.call(foo, 'bar'); // true + +// It's also possible to use the hasOwnProperty property from the Object prototype for this purpose +Object.prototype.hasOwnProperty.call(foo, 'bar'); // true +</pre> + +<p>Zu beachten ist, dass im letzten Fall kein neues Objekt erstellt wird.</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.2.4.5', 'Object.prototype.hasOwnProperty')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>Firefox OS</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>iOS WebKit<br> + <sup><sub>(Safari/Chrome/Firefox/etc)</sub></sup></th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Aufzählbarkeit_und_Zugehörigkeit_von_Eigenschaften">Aufzählbarkeit und Zugehörigkeit von Eigenschaften</a></li> + <li>{{jsxref("Object.getOwnPropertyNames()")}}</li> + <li>{{jsxref("Statements/for...in", "for...in")}}</li> + <li>{{jsxref("Operators/in", "in")}}</li> + <li><a href="/de/docs/Web/JavaScript/Inheritance_and_the_prototype_chain">Vererbung und die Prototypenkette</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/index.html b/files/de/web/javascript/reference/global_objects/object/index.html new file mode 100644 index 0000000000..55eb55035d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/index.html @@ -0,0 +1,186 @@ +--- +title: Object +slug: Web/JavaScript/Reference/Global_Objects/Object +tags: + - Constructor + - JavaScript + - Object +translation_of: Web/JavaScript/Reference/Global_Objects/Object +--- +<div>{{JSRef}}</div> + +<h2 id="Summary" name="Summary">Zusammenfassung</h2> + +<p>Der <code><strong>Object</strong></code>-Konstruktor erstellt ein Objekt</p> + +<h2 id="Syntax" name="Syntax">Konstruktor</h2> + +<pre class="syntaxbox"><code><code>// Object Initialisierer / Literal +{ <em>[ NameWertPaar1 [, NameWertPaar2 [, ...NameWertPaarN] ] ]</em> } + +// Konstruktor-Form +</code>new Object( <em>[ Wert ]</em> )</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt>NameWertPaar1, NameWertPaar2, ... NameWertPaarN</dt> + <dd>Paare von Namen (<code><strong>String</strong></code>) und Werten (eines beliebigen Typs) bei denen der Name durch ein Doppelpunkt vom Wert getrennt ist.</dd> +</dl> + +<dl> + <dt>Wert</dt> + <dd>Ein Wert eines beliebigen Typs.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Der <code>Object</code> Konstruktor erstellt ein Objekt für den übergebenen Wert. Wenn der Wert {{jsxref("null")}} oder {{jsxref("undefined")}} ist, wird ein leeres <code>Object</code> erstellt und zurückgegeben. Ansonsten wird ein Objekt des Typs erstellt, welcher dem übergebenen Wert entspricht. Sollte der Wert bereits ein vom Typ <code>Object</code> sein, wird dieses zurückgeggeben.</p> + +<p>Wenn sie nicht als Konstruktor aufgerufen wird (d.h. ohne <code>new</code>), verhält sich die Funktion <code>Object</code> genau so wie <code>new Object()</code>.</p> + +<p>Siehe auch den <a href="/de/docs/Web/JavaScript/Reference/Operators/Objekt_Initialisierer">Object Intialisierer / Literal Syntax</a>.</p> + +<h2 id="Properties" name="Properties">Eigenschaften des <code>Object</code> Konstruktors</h2> + +<dl> + <dt><code>Object.length</code></dt> + <dd>Hat den Wert 1.</dd> + <dt>{{jsxref("Object.prototype")}}</dt> + <dd>Erlaubt es neue Eigenschaften zu allen Objekten des Typs Object hinzuzufügen.</dd> +</dl> + +<h2 id="Methods" name="Methods">Methoden des <code>Object</code> Konstruktors</h2> + +<dl> + <dt>{{jsxref("Object.assign()")}}</dt> + <dd>Kopiert die Werte aller <strong>eigenen</strong>, aufzählbaren Eigenschaften von einem oder mehreren Quellobjekten in ein Zielobjekt.</dd> + <dt>{{jsxref("Object.create()")}}</dt> + <dd>Erstellt ein neues Objekt mit dem angegebenen Protoyp-Objekt und optionalen Eigenschaften.</dd> + <dt>{{jsxref("Object.defineProperty()")}}</dt> + <dd>Fügt eine neue Eigenschaft einem bestimmten Objekt hinzu, welche durch Zusatzinformationen beschrieben wird.</dd> + <dt>{{jsxref("Object.defineProperties()")}}</dt> + <dd>Fügt mehrere Eigenschaften einem bestimmten Objekt hinzu, welche durch Zusatzinformationen beschrieben werden.</dd> + <dt>{{jsxref("Object.entries()")}}</dt> + <dd>Gibt ein Array zurück, welches alle <strong>eigenen</strong>, aufzählbaren String-Eigenschaften in der Form von <code>[Name, Wert]</code>-Paaren enthält.</dd> + <dt>{{jsxref("Object.freeze()")}}</dt> + <dd><strong>Friert</strong> ein Objekt <strong>ein</strong>: Die Eigenschaften können nicht mehr geändert oder gelöscht werden.</dd> + <dt>{{jsxref("Object.fromEntries()")}}</dt> + <dd>Erstellt ein Objekt aus einer Liste von <code>[Name, Wert]</code>-Paaren (kehrt {{jsxref("Object.entries")}} um).</dd> + <dt>{{jsxref("Object.getOwnPropertyDescriptor()")}}</dt> + <dd>Gibt die Zusatzinformationen einer bestimmten <strong>eigenen</strong> Eigenschaft zurück.</dd> + <dt>{{jsxref("Object.getOwnPropertyDescriptors()")}}</dt> + <dd>Gibt ein Objekt zurück, welches die Zusatzinformationen aller <strong>eigenen</strong> Eigenschaften enthält.</dd> + <dt>{{jsxref("Object.getOwnPropertyNames()")}}</dt> + <dd>Gibt ein Array zurück, welches die Namen aller <strong>eigenen</strong>, aufzählbaren und nicht-aufzählbaren Eigenschaften enthält.</dd> + <dt>{{jsxref("Object.getOwnPropertySymbols()")}}</dt> + <dd>Gibt ein Array zurück, welches die Symbole aller <strong>eigenen</strong> Eigenschaften enthält.</dd> + <dt>{{jsxref("Object.getPrototypeOf()")}}</dt> + <dd>Gibt den Protoypen des angegebenen Objekts zurück.</dd> + <dt>{{jsxref("Object.is()")}}</dt> + <dd>Vergleicht ob zwei Werte den gleichen Wert haben.</dd> + <dt>{{jsxref("Object.isExtensible()")}}</dt> + <dd>Gibt an, ob ein Objekt erweitert werden kann (ob neue Eigenschaften angelegt werden können).</dd> + <dt>{{jsxref("Object.isFrozen()")}}</dt> + <dd>Gibt an, ob ein Objekt eingefroren ist.</dd> + <dt>{{jsxref("Object.isSealed()")}}</dt> + <dd>Gibt an, ob ein Objekt versiegelt ist.</dd> + <dt>{{jsxref("Object.keys()")}}</dt> + <dd>Gibt ein Array zurück, welches die Namen aller <strong>eigenen</strong> aufzählbaren String-Eigenschaften enthält.</dd> + <dt>{{jsxref("Object.preventExtensions()")}}</dt> + <dd>Verbietet das ein Objekt erweitert werden kann.</dd> + <dt>{{jsxref("Object.seal()")}}</dt> + <dd>Verbietet das Eigenschaften gelöscht werden können - versiegelt das Objekt.</dd> + <dt>{{jsxref("Object.setPrototypeOf()")}}</dt> + <dd>Legt den Prototyp fest (z.Bsp. die interne <code>[[Prototype]]</code> Eigenschaft)</dd> + <dt>{{jsxref("Object.values()")}}</dt> + <dd>Gibt ein Array zurück, welches die Werte aller <strong>eigenen</strong> aufzählbaren String-Eigenschaften enthält.</dd> +</dl> + +<h2 id="Object_instances" name="Object_instances"><code>Object</code> Instanzen und das Prototyp-Objekt</h2> + +<p>Alle Objekte in JavaScript stammen von <code>Object</code> ab; alle Objekte bekommen die Methoden und Eigenschaften vom {{jsxref("Object.prototype")}} vererbt, jedoch können sie überschrieben werden. Zum Beispiel können Prototypen andere Kontruktoren die <code>constructor</code>-Eigenschaft überschreiben oder aber ihre eigene <code>toString()</code> Methode implementieren. Änderungen am <code>Object</code> Prototypen wirken sich auch auf alle anderen Objekte aus, es sei denn die Eigenschaften oder Methoden sind entlang der Prototyp-Kette schon überschrieben worden.</p> + +<h3 id="Properties_of_Object_instances" name="Properties_of_Object_instances">Eigenschaften</h3> + +<div>{{ page('/de/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Attribute') }}</div> + +<h3 id="Methods_of_Object_instances" name="Methods_of_Object_instances">Methoden</h3> + +<div>{{ page('/de/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Methoden') }}</div> + +<h2 id="Eine_Eigenschaft_von_einem_Objekt_löschen">Eine Eigenschaft von einem Objekt löschen</h2> + +<p>Es gibt keine Methode von <code>Object</code> selbst, um eine Eigenschaft zu löschen (wie z.Bsp. <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Map/delete">Map.prototype.delete()</a></code>). Um das zu erreichen, muss der <a href="/de/docs/Web/JavaScript/Reference/Operators/delete">delete Operator</a> benutzt werden.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example.3A_Using_Object_given_undefined_and_null_types" name="Example.3A_Using_Object_given_undefined_and_null_types"><code>Object</code> mit <code>undefined</code> und <code>null</code> Typen nutzen</h3> + +<p>Die folgenden Beispiele speichern ein leeres <code>Object</code> in <code>o</code>:</p> + +<pre class="brush: js">var o = new Object(); +</pre> + +<pre class="brush: js">var o = new Object(undefined); +</pre> + +<pre class="brush: js">var o = new Object(null); +</pre> + +<h3 id="Object_nutzen_um_Boolean-Objekte_zu_erstellen"><code>Object</code> nutzen um <code>Boolean</code>-Objekte zu erstellen</h3> + +<p>Die folgenden Beispiele speichern {{jsxref("Boolean")}}-Objekte in <code>o</code>:</p> + +<pre class="brush: js">// das gleiche wie: var o = new Boolean(true); +var o = new Object(true); +</pre> + +<pre class="brush: js">// das gleiche wie: var o = new Boolean(false); +var o = new Object(Boolean()); +</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.<br> + In JavaScript 1.0 implementiert</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2', 'Object')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object-objects', 'Object')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> + <p><code>Object.assign</code>, <code>Object.getOwnPropertySymbols</code>, <code>Object.setPrototypeOf</code> und <code>Object.is</code> hinzugefügt</p> + </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object-objects', 'Object')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td><code>Object.entries</code>, <code>Object.values</code> und <code>Object.getOwnPropertyDescriptors</code> hinzugefügt.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<p>{{Compat("javascript.builtins.Object")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Objekt_Initialisierer">Object initializer</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/is/index.html b/files/de/web/javascript/reference/global_objects/object/is/index.html new file mode 100644 index 0000000000..348dbeebe9 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/is/index.html @@ -0,0 +1,120 @@ +--- +title: Object.is() +slug: Web/JavaScript/Reference/Global_Objects/Object/is +tags: + - ECMAScript 2015 + - Experimental + - Expérimental(2) + - Method + - Object +translation_of: Web/JavaScript/Reference/Global_Objects/Object/is +--- +<div>{{JSRef("Global_Objects", "Object")}}</div> + +<h2 id="Zusammenfassung">Zusammenfassung</h2> + +<p>Die <code><strong>Object.is()</strong></code> Methode entscheidet, ob zwei Werte <a href="/en-US/docs/Web/JavaScript/Guide/Sameness">die gleichen Werte sind</a>.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>var <var>isSame</var> = Object.is(<var>value1</var>, <var>value2</var>);</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>value1</code></dt> + <dd>Der erste Wert zum vergleichen.</dd> + <dt><code>value2</code></dt> + <dd>Der zweite Wert zum vergleichen.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><span class="short_text" id="result_box" lang="en"><span><code>Object.is()</code> bestimmt, ob zwei Werte <a href="/en-US/docs/Web/JavaScript/Guide/Sameness" title="/en-US/docs/Web/JavaScript/Guide/Sameness"><dfn>gleich sind</dfn></a>. </span></span><span class="short_text" lang="en"><span>Dabei gelten zwei Werte genau dann als gleich, wenn eine der folgenden Bedingungen zutrifft:</span></span></p> + +<ul> + <li><span class="short_text" lang="en"><span>beide sind <code>undefined</code></span></span></li> + <li><span class="short_text" lang="en"><span>beide sind <code>null</code></span></span></li> + <li><span class="short_text" lang="en"><span>beide sind <code>true</code> oder beide sind <code>false</code></span></span></li> + <li><span class="short_text" lang="en"><span>beide sind Strings mit selber Länge und den selben Zeichen</span></span></li> + <li><span class="short_text" lang="en"><span>beide sind das selbe Objekt</span></span></li> + <li><span class="short_text" lang="en"><span>beide sind Zahlen und eine der folgenden Bedingungen trifft zu:</span></span> + <ul> + <li>beide sind <code>+0</code></li> + <li>beide sind <code>-0</code></li> + <li>beide sind <code>NaN</code></li> + <li>beide sind nicht Null, beide sind nicht <code>NaN</code> und beide haben den selben Zahlenwert</li> + </ul> + </li> +</ul> + +<p>Dies ist <em>nicht</em> das selbe wie der <code>==</code>-Operator. Dieser verwendet verschiedene, situationsabhängige Typ-Umwandlungen auf beiden Seiten bevor auf Gleichheit getestet wird (was z.B. dazu führt, dass der Ausdruck <code>"" == false</code> zu <code>true</code> ausgewertet wird). <code>Object.is</code> hingegen wandelt keinen der beiden Werte um.</p> + +<p>Es ist ebenfalls nicht das selbe wie der strikte <code>===</code>-Operator. Dieser – ebenso wie der <code>==</code>-Operator – behandelt zum Beispiel <code>+0</code> und <code>-0</code> als identisch während <code>NaN</code> und <code>NaN</code> als nicht identisch behandelt werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">Object.is('foo', 'foo'); // true +Object.is(window, window); // true + +Object.is('foo', 'bar'); // false +Object.is([], []); // false + +var test = { a: 1 }; +Object.is(test, test); // true + +Object.is(null, null); // true + +// Special Cases +Object.is(0, -0); // false +Object.is(-0, -0); // true +Object.is(NaN, 0/0); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>Object.</code> ist eine vorgeschlagene Ergänzung des ECMA-262 Standard; als solcher könnte dieser nicht von allen Browser verstanden werden. Du kannst drum herum arbeiten, indem du den folgenden Code an den Anfang deines Scripts packst. Das erlaubt dir die <code>Object.is Methode</code> zu verwenden, auch wenn es keine eingebaute Unterstützung dafür gibt.</p> + +<pre><code>if (!Object.is) { + Object.is = function(x, y) { + // SameValue algorithm + if (x === y) { // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + return x !== 0 || 1 / x === 1 / y; + } else { + // Step 6.a: NaN == NaN + return x !== x && y !== y; + } + }; +}</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-object.is', 'Object.is')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Object.is")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Sameness">JavaScript Guide: Sameness</a> — ein Vergleich aller drei eingebauten Gleichheitseinrichtungen</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/isextensible/index.html b/files/de/web/javascript/reference/global_objects/object/isextensible/index.html new file mode 100644 index 0000000000..a54bb5f6c4 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/isextensible/index.html @@ -0,0 +1,153 @@ +--- +title: Object.isExtensible() +slug: Web/JavaScript/Reference/Global_Objects/Object/isExtensible +tags: + - ECMAScript 5 + - Erweiterbarkeit + - JavaScript + - Méthode + - Object +translation_of: Web/JavaScript/Reference/Global_Objects/Object/isExtensible +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>Object.isExtensible()</code></strong> bestimmt, ob ein Objekt erweiterbar ist. Das heißt, es können dem Objekt neue Eigenschaften hinzugefügt werden.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Object.isExtensible(<var>obj</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Das Objekt, das überprüft werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Boolean")}}, der angibt, ob das übergebene Objekt erweiterbar ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Standardmäßig sind Objekte erweiterbar: Es ist möglich, ihnen neue Eigenschaften zuzuweisen und sie dadurch zu verändern. In Engines, die {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}} unterstützen, kann auch deren __proto__ Eigenschaft geändert werden. Ein Objekt kann mittels {{jsxref("Object.preventExtensions()")}}, {{jsxref("Object.seal()")}} oder {{jsxref("Object.freeze()")}} explizit als nicht-erweiterbar markiert werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">// Neue Objekte sind erweiterbar. +var empty = {}; +Object.isExtensible(empty); // === true + +// ...aber das kann sich ändern. +Object.preventExtensions(empty); +Object.isExtensible(empty); // === false + +// Versiegelte Objekte sind per Definition nicht erweiterbar. +var sealed = Object.seal({}); +Object.isExtensible(sealed); // === false + +// Eingefrorene Objekte sind ebenfalls per Definition nicht erweiterbar. +var frozen = Object.freeze({}); +Object.isExtensible(frozen); // === false +</pre> + +<h2 id="Anmerkungen">Anmerkungen</h2> + +<p>In ES5 muss das Argument der Methode ein echtes Objekt sein. Ist dies nicht der Fall, wird ein {{jsxref("TypeError")}} geworfen. In ES2015 hingegen wird ein Nicht-Objekt einfach als nicht-erweiterbares Objekt behandelt, sodass von der Methode <code>false </code>zurückgegeben wird.</p> + +<pre class="brush: js">Object.isExtensible(1); +// TypeError: 1 is not an object (ES5 code) + +Object.isExtensible(1); +// false (ES2015 code) +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.13', 'Object.isExtensible')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.isextensible', 'Object.isExtensible')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.isextensible', 'Object.isExtensible')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("6")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12")}}</td> + <td>{{CompatSafari("5.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Zusätzliches_Material">Zusätzliches Material</h2> + +<ul> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.seal()")}}</li> + <li>{{jsxref("Object.isSealed()")}}</li> + <li>{{jsxref("Object.freeze()")}}</li> + <li>{{jsxref("Object.isFrozen()")}}</li> + <li>{{jsxref("Reflect.isExtensible()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/isfrozen/index.html b/files/de/web/javascript/reference/global_objects/object/isfrozen/index.html new file mode 100644 index 0000000000..fedcba2572 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/isfrozen/index.html @@ -0,0 +1,173 @@ +--- +title: Object.isFrozen() +slug: Web/JavaScript/Reference/Global_Objects/Object/isFrozen +translation_of: Web/JavaScript/Reference/Global_Objects/Object/isFrozen +--- +<div>{{JSRef}}</div> + +<p><code><strong>Object.isFrozen()</strong></code> gibt an ob ein Objekt {{jsxref("Object.freeze()", "eingefroren", "", 1)}} ist.</p> + +<div>{{EmbedInteractiveExample("pages/js/object-isfrozen.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Object.isFrozen(<var>obj</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Das Objekt, welches überprüft werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Boolean")}}-Wert, der angibt ob das Objekt eingefroren ist oder nicht.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Ein Objekt gilt dann und nur dann als eingefroren, wenn es nicht {{jsxref("Object.isExtensible()", "erweiterbar", "", 1)}} ist, all seine Eigenschaften nicht konfigurierbar sind und all seine Daten-Eigenschaften (d.h. Eigenschaften die nicht durch Getter oder Setter definiert sind) nicht schreibbar sind.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">// Ein neues Objekt ist erweiterbar, also nicht eingefroren. +Object.isFrozen({}); // === false + +// An leeres Objekt, das nicht erweiterbar ist, +// ist sinnlos eingefroren. +var sinnlos = Object.preventExtensions({}); +Object.isFrozen(sinnlos); // === true + +// Ein neues Objekt mit einer einzelnen Eigenschaft, ist auch erweiterbar, +// ergo nicht eingefroren. +var eineEigenschaft = { p: 42 }; +Object.isFrozen(eineEigenschaft); // === false + +// Das Objekt nicht erweiterbar zu machen, friert es nicht ein, +// da die Eigenschaft immer nocht konfigurierbar und schreibbar ist. +Object.preventExtensions(eineEigenschaft); +Object.isFrozen(eineEigenschaft); // === false + +// ...wenn man die Eigenschaft aber löscht, +// wird das Objekt sinnlos +delete eineEigenschaft.p; +Object.isFrozen(eineEigenschaft); // === true + +// Ein nicht erweiterbares Objekt, mit einer nicht schreibbaren +// jedoch konifgurierbaren Eigenschaft gilt als nicht eingefroren. +var nichtSchreibbar = { e: 'plep' }; +Object.preventExtensions(nichtSchreibbar); +Object.defineProperty(nichtSchreibbar, 'e', { + writable: false +}); // `e` wird nicht schreibbar +Object.isFrozen(nichtSchreibbar); // === false + +// Wird diese Eigenschaft nicht konfigurierbar, +// so friert das Objekt ein. +Object.defineProperty(nichtSchreibbar, 'e', { + configurable: false +}); // `e` wird nicht konfigurierbar +Object.isFrozen(nichtSchreibbar); // === true + +// Ein nicht erweiterbares Objekt, mit einer nicht konfigurierbaren +// jedoch schreibbaren Eigenschaft gilt ebenfalls als nicht eingefroren. +var nichtKonfigurierbar = { release: 'the kraken!' }; +Object.preventExtensions(nichtKonfigurierbar); +Object.defineProperty(nichtKonfigurierbar, 'release', { + configurable: false +}); +Object.isFrozen(nichtKonfigurierbar); // === false + +// Wird diese Eigenschaft nicht schreibbar, +// so friert das Objekt ein. +Object.defineProperty(nichtKonfigurierbar, 'release', { + writable: false +}); +Object.isFrozen(nichtKonfigurierbar); // === true + +// Ein nicht erweiterbares Objekt, mit einer konfigurierbaren +// dynamischen Eigenschaft (get/set) ist nicht eingefroren. +var dynamisch = { get food() { return 'yum'; } }; +Object.preventExtensions(dynamisch); +Object.isFrozen(dynamisch); // === false + +// ABER, wird diese Eigenschaft nicht konfigurierbar, +// friert das Objekt ein. +Object.defineProperty(dynamisch, 'food', { + configurable: false +}); +Object.isFrozen(dynamisch); // === true + +// Am Ende ist die einfachste Methode um ein Objekt einzufrieren, +// Object.freeze aufzurufen. +var eingefroren = { 1: 81 }; +Object.isFrozen(eingefroren); // === false +Object.freeze(eingefroren); +Object.isFrozen(eingefroren); // === true + +// Per Definition ist ein eingefrorenes Objekt nicht erweiterbar. +Object.isExtensible(eingefroren); // === false + +// Und es ist ebenfalls versiegelt. +Object.isSealed(eingefroren); // === true +</pre> + +<h2 id="Anmerkungen">Anmerkungen</h2> + +<p>In ES5, wirft die Methode einen {{jsxref("TypeError")}}, wenn der Parameter kein primitives Objekt ist.</p> + +<p>In ES2015 wird der Parameter, sollte er kein primitives Objekt sein, als bereits eingefrorenes Objekt betrachtet und gibt dementsprechend einfach <code>true</code> zurück.</p> + +<pre class="brush: js">Object.isFrozen(1); +// TypeError: 1 is not an object (ES5 code) + +Object.isFrozen(1); +// true (ES2015 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('ES5.1', '#sec-15.2.3.12', 'Object.isFrozen')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. In JavaScript 1.8.5 implementiert.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.isfrozen', 'Object.isFrozen')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.isfrozen', 'Object.isFrozen')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Object.isFrozen")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.freeze()")}}</li> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> + <li>{{jsxref("Object.seal()")}}</li> + <li>{{jsxref("Object.isSealed()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/keys/index.html b/files/de/web/javascript/reference/global_objects/object/keys/index.html new file mode 100644 index 0000000000..5fda29ca15 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/keys/index.html @@ -0,0 +1,206 @@ +--- +title: Object.keys() +slug: Web/JavaScript/Reference/Global_Objects/Object/keys +tags: + - ECMAScript5 + - JavaScript + - JavaScript 1.8.5 + - Method + - Object +translation_of: Web/JavaScript/Reference/Global_Objects/Object/keys +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>Object.keys()</code></strong> Funktion gibt ein Array zurück, das die eigenen aufzählbaren Eigenschaften des Objektes in der selben Reihenfolge enthält wie in der {{jsxref("Statements/for...in", "for...in")}} Schleife (der Unterschied zwischen diesen beiden Varianten besteht darin, dass eine for-in Schleife auch die aufzählbaren Eigenschaften der Prototypen beinhaltet).</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Object.keys(<var>obj</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>ein Objekt, dessen aufzählbare eigene Eigenschaften zurückgegeben werden sollen</dd> +</dl> + +<h3 id="Description" name="Description">Rückgabewert</h3> + +<p>Ein Array mit Strings, die alle aufzählbare Eigenschaften des gegebenen Objektes repräsentieren.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>Object.keys()</code> liefert ein Array, dessen Elemente Strings sind, welche die aufzählbaren Eigenschaften des Objekts respräsentieren. Die Reihenfolge der Eigenschaften ist die selbe wie bei einer for-in Schleife über das Objekt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var arr = ['a', 'b', 'c']; +console.log(Object.keys(arr)); // console: ['0', '1', '2'] + +// array like object +var obj = { 0: 'a', 1: 'b', 2: 'c' }; +console.log(Object.keys(obj)); // console: ['0', '1', '2'] + +// array like object with random key ordering +var an_obj = { 100: 'a', 2: 'b', 7: 'c' }; +console.log(Object.keys(an_obj)); // console: ['2', '7', '100'] + +// getFoo is property which isn't enumerable +var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } }); +my_obj.foo = 1; + +console.log(Object.keys(my_obj)); // console: ['foo']</pre> + +<p><span style="line-height: 1.5;">Die Liste aller eigenen aufzählbaren und nicht-aufzählbaren Eigenschaften eines Objekt erhält man mit der Funktion {{jsxref("Object.getOwnPropertyNames()")}}.</span></p> + +<h2 id="Notes" name="Notes">Notizen</h2> + +<p>In ES5 wird, wenn das Argument für die Funktion kein Objekt ist, ein {{jsxref("TypeError")}} Fehler geworfen. In ES2015 wird das Argument, welches kein Objekt ist, in ein Objekt umgewandelt, das aber nicht mehr dem eigentlichen Wert entspricht (siehe Beispiel).</p> + +<pre class="brush: js">> Object.keys("foo") +TypeError: "foo" is not an object // ES5 code + +> Object.keys("foo") +["0", "1", "2"] // ES2015 code +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Kopieren Sie das folgende Code-Schnipsel, um <code>Object.keys()</code> auch in älteren Umgebungen ohne native Unterstützung nutzen zu können:</p> + +<pre class="brush: js">// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys +if (!Object.keys) { + Object.keys = (function() { + 'use strict'; + var hasOwnProperty = Object.prototype.hasOwnProperty, + hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'), + dontEnums = [ + 'toString', + 'toLocaleString', + 'valueOf', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'constructor' + ], + dontEnumsLength = dontEnums.length; + + return function(obj) { + if (typeof obj !== 'function' && (typeof obj !== 'object' || obj === null)) { + throw new TypeError('Object.keys called on non-object'); + } + + var result = [], prop, i; + + for (prop in obj) { + if (hasOwnProperty.call(obj, prop)) { + result.push(prop); + } + } + + if (hasDontEnumBug) { + for (i = 0; i < dontEnumsLength; i++) { + if (hasOwnProperty.call(obj, dontEnums[i])) { + result.push(dontEnums[i]); + } + } + } + return result; + }; + }()); +} +</pre> + +<p>Bitte beachten Sie, dass der obenstehende Code auch die Namen der nicht-aufzählbaren Eigenschaften im IE7 (und evtl. auch im IE8) berücksichtigt, wenn ein Objekt aus einem anderen Fenster übergeben wird.</p> + +<p>Ein einfaches Polyfill finden Sie außerdem hier: <a href="http://tokenposts.blogspot.com.au/2012/04/javascript-objectkeys-browser.html">Javascript - Object.keys Browser Compatibility</a>.</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">Kommantar</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.14', 'Object.keys')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-object.keys', 'Object.keys')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.keys', 'Object.keys')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatChrome("5")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12")}}</td> + <td>{{CompatSafari("5")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li> + <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li> + <li>{{jsxref("Object.create()")}}</li> + <li>{{jsxref("Object.getOwnPropertyNames()")}}</li> + <li>{{jsxref("Object.values()")}} {{experimental_inline}}</li> + <li>{{jsxref("Object.entries()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/observe/index.html b/files/de/web/javascript/reference/global_objects/object/observe/index.html new file mode 100644 index 0000000000..df68348028 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/observe/index.html @@ -0,0 +1,199 @@ +--- +title: Object.observe() +slug: Web/JavaScript/Reference/Global_Objects/Object/observe +tags: + - Beobachter + - Data-Binding + - Deprecated + - JavaScript + - Méthode + - Object + - Veraltet +translation_of: Archive/Web/JavaScript/Object.observe +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p>Die <strong><code>Object.observe()</code></strong> Methode kann genutzt werden, um auf Änderungen an einem Objekt asynchron zu reagieren. Sie bietet einen Stream der Änderungen in der Reihenfolge ihres Auftretens. Da die Methode veraltet ist und Beschränkungen aufweist, sollte lieber ein {{jsxref("Proxy")}} Objekt verwendet werden.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Object.observe(<var>obj</var>, <var>callback</var>[, <var>acceptList</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Das Objekt, das beobachtet werden soll.</dd> + <dt><code>callback</code></dt> + <dd>Eine Callback-Funktion, die jedes mal aufgerufen wird, wenn eine Änderung am Objekt vorgenommen wird + <dl> + <dt><code>changes</code></dt> + <dd>Ein Array von Objekten, die die vorgenommenen Änderungen repräsentieren. Die Eigenschaften der Objekte sind jeweils + <ul> + <li><strong><code>name</code></strong>: Der Name der Eigenschaft, welche geändert wurde</li> + <li><strong><code>object</code></strong>: Das (bereits) geänderte Objekt.</li> + <li><strong><code>type</code></strong>: Ein String der Angibt, welcher Art die vorgenommene Änderung war. Entspricht <code>"add"</code>, <code>"update"</code>, oder <code>"delete"</code>.</li> + <li><strong><code>oldValue</code></strong>: Existiert nur, wenn der type <code>"update"</code> oder <code>"delete"</code> ist. Der ursprüngliche Wert vor der Änderung.</li> + </ul> + </dd> + </dl> + </dd> + <dt><code>acceptList</code></dt> + <dd>Eine Liste von Änderungstypen die für das gegebene Objekt und jeweilige Callback beobachtet werden sollen. Standardmäßig <code>["add", "update", "delete", "reconfigure", "setPrototype", "preventExtensions"]</code> .</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>callback</code> wird jedes mal aufgerufen, wenn das <code>obj</code> geändert wird. Die Funktion erhält dabei die Liste aller Änderungen in chronologischer Reihenfolge ihres Auftretens.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ausgabe_aller_sechs_Änderungsarten">Ausgabe aller sechs Änderungsarten</h3> + +<pre class="brush: js">var obj = { + foo: 0, + bar: 1 +}; + +Object.observe(obj, function(changes) { + console.log(changes); +}); + +obj.baz = 2; +// [{name: 'baz', object: <obj>, type: 'add'}] + +obj.foo = 'hello'; +// [{name: 'foo', object: <obj>, type: 'update', oldValue: 0}] + +delete obj.baz; +// [{name: 'baz', object: <obj>, type: 'delete', oldValue: 2}] + +Object.defineProperty(obj, 'foo', {writable: false}); +// [{name: 'foo', object: <obj>, type: 'reconfigure'}] + +Object.setPrototypeOf(obj, {}); +// [{name: '__proto__', object: <obj>, type: 'setPrototype', oldValue: <prototype>}] + +Object.seal(obj); +// [ +// {name: 'foo', object: <obj>, type: 'reconfigure'}, +// {name: 'bar', object: <obj>, type: 'reconfigure'}, +// {object: <obj>, type: 'preventExtensions'} +// ] +</pre> + +<h3 id="Data_Binding">Data Binding</h3> + +<pre class="brush: js">// A user model +var user = { + id: 0, + name: 'Brendan Eich', + title: 'Mr.' +}; + +// Create a greeting for the user +function updateGreeting() { + user.greeting = 'Hello, ' + user.title + ' ' + user.name + '!'; +} +updateGreeting(); + +Object.observe(user, function(changes) { + changes.forEach(function(change) { + // Any time name or title change, update the greeting + if (change.name === 'name' || change.name === 'title') { + updateGreeting(); + } + }); +}); +</pre> + +<h3 id="Eigens_definierter_Änderungstyp">Eigens definierter Änderungstyp</h3> + +<pre class="brush: js">// A point on a 2D plane +var point = {x: 0, y: 0, distance: 0}; + +function setPosition(pt, x, y) { + // Performing a custom change + Object.getNotifier(pt).performChange('reposition', function() { + var oldDistance = pt.distance; + pt.x = x; + pt.y = y; + pt.distance = Math.sqrt(x * x + y * y); + return {oldDistance: oldDistance}; + }); +} + +Object.observe(point, function(changes) { + console.log('Distance change: ' + (point.distance - changes[0].oldDistance)); +}, ['reposition']); + +setPosition(point, 3, 4); +// Distance change: 5 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p><a href="https://github.com/arv/ecmascript-object-observe">Strawman proposal for ECMAScript 7</a>.</p> + +<h2 id="Browserunterstützung">Browserunterstützung</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("36")}}</td> + <td>{{CompatNo}} [1]</td> + <td>{{CompatNo}} [2]</td> + <td>{{CompatOpera("23")}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("36")}}</td> + <td>{{CompatNo}} [1]</td> + <td>{{CompatNo}} [2]</td> + <td>{{CompatOpera("23")}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1]: See {{bug(800355)}}</p> + +<p>[2]: See relevant <a href="https://dev.modern.ie/platform/status/objectobserve/">MS Edge platform status entry</a></p> + +<h2 id="Siehe_Auch">Siehe Auch</h2> + +<ul> + <li>{{jsxref("Object.unobserve()")}} {{experimental_inline}}</li> + <li>{{jsxref("Array.observe()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/proto/index.html b/files/de/web/javascript/reference/global_objects/object/proto/index.html new file mode 100644 index 0000000000..6c085634e7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/proto/index.html @@ -0,0 +1,196 @@ +--- +title: Object.prototype.__proto__ +slug: Web/JavaScript/Reference/Global_Objects/Object/proto +translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto +--- +<div class="warning"> +<p><strong>Achtung:</strong> Das Ändern des <code>[[Prototype]]</code> von einem Objekt, in der Art wie moderne JavaScript Engines den Zugriff auf Eigenschaften optimieren, ist eine sehr langsame Operation - in <strong><em>jedem</em></strong> Browser und JavaScript-Engine. Die Auswirkungen auf die Perfomance der veränderten Vererbung sind subtil und weit verstreut und sind nicht einfach auf die Zeit des Zugriffs von <code>obj.__proto__ = ...</code> Ausdruck limitiert, sondern können sich auf jeden Code erstrecken, der Zugriff auf ein Objekt hat, dessen <code>[[Prototype]]</code> geändert wurde. Wenn du dir um die Perfomance sorgen machst, dann solltest du das Setzen des <code>[[Prototype]]</code> auf ein Objekt vermeiden. Stattdessen kannst du ein neues Objekt mit dem gewünschten <code>[[Prototype]]</code> mit {{jsxref("Object.create()")}} erstellen.</p> +</div> + +<div class="warning"> +<p><strong>Achtung:</strong> Während <code>Object.prototype.__proto__</code> von den meisten Browsern unterstützt wird, ist seine Existenz und exaktes Verhalten nur in der ECMAScript 2015 Spezifikation als Vermächtnis-Funktion standardisiert, um die Kompatibilität für Web-Browser zu gewährleisten. Für bessere Unterstützung wird stattdessen empfohlen {{jsxref("Object.getPrototypeOf()")}} zu nutzen.</p> +</div> + +<div>{{JSRef}}</div> + +<p>Die <code>__proto__</code> Eigenschaft von {{jsxref("Object.prototype")}} ist eine Zugriffs-Eigenschaft (ein Erhalten- und Setzen-Funktion), welche den internen <code>[[Prototype]]</code> (entweder ein Objekt oder {{jsxref("Global_Objects/null", "null")}}) des Objektes, auf das zugegriffen wird, freilegt.</p> + +<p>Die Nutzung von <code>__proto__</code> ist umstritten und wird nicht mehr empfohlen. Es war niemals ein Originalteil<em> </em>in der EcmaScript Sprach-Spezifikation, doch haben moderne Browser entschieden es trotzdem zu implementieren. Erst vor kurzem wurde die <code>__proto__</code> Eigenschaft als Standard in die ECMAScript 2015 Sprach-Spezifikation aufgenommen, um die Kompatibiliät von modernen Web-Browsern sicherzustellen, sodass es in der Zukunft unterstützt wird. Es ist veraltet zu Gunsten von {{jsxref("Object.getPrototypeOf")}}/{{jsxref("Reflect.getPrototypeOf")}} und {{jsxref("Object.setPrototypeOf")}}/{{jsxref("Reflect.setPrototypeOf")}} (obgleich das Setzen des <code>[[Prototype]]</code> eines Objektes immer noch eine langsame Operation ist und daher vermieden werden sollte, wenn Performance eine Rolle spielt).</p> + +<p>Die <code>__proto__</code> Eigenschaft kann auch in einer Objekt-Literal-Definition verwendet werden, um das Objekt [[Prototyp]] bei der Erstellen zu setzen - als Alternative zu {{jsxref("Object.create()")}}. See: <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">object initializer / literal syntax</a>.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="brush: js">var Circle = function () {}; +var shape = {}; +var circle = new Circle(); + +// Setzt den Objekt Prototypen. +// DEPRECATED. Dies ist nur eine beispielhafte Verwendung und sollte NICHT in produktivem Code verwendet werden. +shape.__proto__ = circle; + +// Liefert den Objekt Prototypen zurück +console.log(shape.__proto__ === circle); // true +</pre> + +<pre class="brush: js">var shape = function () { +}; +var p = { + a: function () { + console.log('aaa'); + } +}; +shape.prototype.__proto__ = p; + +var circle = new shape(); + +circle.a();//aaa + +console.log(shape.prototype === circle.__proto__);//true + +//oder + +var shape = function () { +}; +var p = { + a: function () { + console.log('a'); + } +}; + +var circle = new shape(); +circle.__proto__ = p; + + +circle.a(); // a + +console.log(shape.prototype === circle.__proto__);//false + +//oder + +function test() { +} +test.prototype.myname = function () { + console.log('myname'); + +} +var a = new test() + +console.log(a.__proto__ === test.prototype);//true + +a.myname();//myname + + +//oder + +var fn = function () { +}; +fn.prototype.myname = function () { + console.log('myname'); +} + +var obj = { + __proto__: fn.prototype +}; + + +obj.myname();//myname +</pre> + +<p>Anmerkung: das sind zwei Unterstriche, gefolgt von den fünf Zeichen "Proto", gefolgt von zwei weiteren Unterstrichen.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>The <code>__proto__</code> getter function exposes the value of the internal <code>[[Prototype]]</code> of an object. For objects created using an object literal, this value is {{jsxref("Object.prototype")}}. For objects created using array literals, this value is {{jsxref("Array.prototype")}}. For functions, this value is {{jsxref("Function.prototype")}}. For objects created using <code>new fun</code>, where <code>fun</code> is one of the built-in constructor functions provided by JavaScript ({{jsxref("Array")}}, {{jsxref("Boolean")}}, {{jsxref("Date")}}, {{jsxref("Number")}}, {{jsxref("Object")}}, {{jsxref("String")}}, and so on — including new constructors added as JavaScript evolves), this value is always <code>fun.prototype</code>. For objects created using <code>new fun</code>, where <code>fun</code> is a function defined in a script, this value is the value of <code>fun.prototype</code>. (That is, if the constructor didn't return an other object explicitly, or the <code>fun.prototype</code> has been reassigned since the instance was created).</p> + +<p>The <code>__proto__</code> setter allows the <code>[[Prototype]]</code> of an object to be mutated. The object must be extensible according to {{jsxref("Object.isExtensible()")}}: if it is not, a {{jsxref("Global_Objects/TypeError", "TypeError")}} is thrown. The value provided must be an object or {{jsxref("Global_Objects/null", "null")}}. Providing any other value will do nothing.</p> + +<p>To understand how prototypes are used for inheritance, see guide article <a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">Inheritance and the prototype chain</a>.</p> + +<p>The <code>__proto__</code> property is a simple accessor property on {{jsxref("Object.prototype")}} consisting of a getter and setter function. A property access for <code>__proto__</code> that eventually consults {{jsxref("Object.prototype")}} will find this property, but an access that does not consult {{jsxref("Object.prototype")}} will not find it. If some other <code>__proto__</code> property is found before {{jsxref("Object.prototype")}} is consulted, that property will hide the one found on {{jsxref("Object.prototype")}}.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Included in the (normative) annex for additional ECMAScript legacy features for Web browsers (note that the specification codifies what is already in implementations).</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basis Unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatIE("11")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basis Unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Kompatibiliäts_Notizen">Kompatibiliäts Notizen</h2> + +<p>Während die ECMAScript 2015-Spezifikation vorschreibt, dass die Unterstützung für <code>__proto__</code> nur für Webbrowser erforderlich ist (obwohl sie bestimmend sind), können andere Umgebungen sie auch für den Gebrauch von Benutzern unterstützen</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li> + <li>{{jsxref("Object.getPrototypeOf()")}}</li> + <li>{{jsxref("Object.setPrototypeOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/prototype/index.html b/files/de/web/javascript/reference/global_objects/object/prototype/index.html new file mode 100644 index 0000000000..71a504f6dd --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/prototype/index.html @@ -0,0 +1,219 @@ +--- +title: Object.prototype +slug: Web/JavaScript/Reference/Global_Objects/Object/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object +--- +<div>{{JSRef}}</div> + +<p>Das <code><strong>Object.prototype</strong></code> Attribut repräsentiert das Prototype Objekt von {{jsxref("Object")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Alle Objekte in JavaScript stammen von {{jsxref("Object")}}; alle Objekte erben Methoden und Attribute von <code>Object.prototype</code>, wobei diese überschrieben werden können (mit Ausnahme von Objekten mit einem <code>null-</code>Prototyp, sprich <code>Object.create(null)</code>). Die Prototypen anderer Konstruktoren zum Beispiel, überschreiben das <code>constructor</code> Attribut und stellen ihre eigenen Methoden zur Verfügung {{jsxref("Object.prototype.toString()", "toString()")}}. Änderungen am <code>Object</code> prototype Objekt werden an alle Objekte weitergeleitet, solange die betroffenen Attribute und Methoden nicht zuvor in der Kette der Prototypen überschrieben wurden.</p> + +<h2 id="Attribute">Attribute</h2> + +<dl> + <dt>{{jsxref("Object.prototype.constructor")}}</dt> + <dd>Die Funktion, die den Prototypen eines Objekts erstellt.</dd> + <dt>{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}</dt> + <dd>Zeigt auf das Objekt, das als bei der Initialisierung des Objektes als Prototyp diente.</dd> + <dt>{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}</dt> + <dd>Erlaubt das Erstellen einer Funktion, die dann ausgeführt wird, wenn ein undefiniertes Objekt als Methode aufgerufen wird.</dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.count","Object.prototype.__count__")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Wurde benutzt um die Anzahl der aufzählbaren Attribute direkt durch das Objekt zurückzugeben; mittlerweile entfernt.</s></dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.parent","Object.prototype.__parent__")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Wurde benutzt um auf den Kontext eines Objektes zu verweisen; mittlerweile entfernt.</s></dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Verknüpft eine Funktion mit einem Attribut, das, wenn darauf zugegriffen wird eine Funktion ausführt und deren Rückgabewert zurück gibt.</dd> + <dt>{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Verknüpft eine Funktion mit einem Attribut, das, wenn dieses gesetzt werden soll, eine Funktion ausführt, die das Attribut modifiziert.</dd> + <dt>{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Gibt die Funktion zurück, die mit dem spezifizierten Attribut über die Methode {{jsxref("Object.prototype.__defineGetter__()", "__defineGetter__()")}} verknüpft ist.</dd> + <dt>{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Gibt die Funktion zurück, die mit dem spezifizierten Attribut über die Methode {{jsxref("Object.prototype.__defineSetter__()", "__defineSetter__()")}} verknüpft ist.</dd> + <dt>{{jsxref("Object.prototype.hasOwnProperty()")}}</dt> + <dd>Gibt einen Boolean Wert zurück, der anzeigt, ob ein Attribut ein direktes Attribut dieses Objekts ist, oder über Vererbung durch einen Prototypen hinzugefügt wurde.</dd> + <dt>{{jsxref("Object.prototype.isPrototypeOf()")}}</dt> + <dd>Gibt einen Boolean Wert zurück, der anzeigt, ob das spezifizierte Objekt in der Prototyp-Kette des Objekts, das diese Funktion aufruft, enthalten ist.</dd> + <dt>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</dt> + <dd>Gibt einen Boolean Wert zurück, der anzeigt, ob das interne <a href="/en-US/docs/Web/JavaScript/Data_structures#Properties">ECMAScript [[Enumerable]] attribute</a> gesetzt ist.</dd> + <dt>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Liefert einen String zurück, der die Quelle eines Objekt-Literals enthält, und das Objekt darstellt, das diese Funktion aufruft; man kann diesen Wert benutzen, um ein neues Objekt zu erstellen.</dd> + <dt>{{jsxref("Object.prototype.toLocaleString()")}}</dt> + <dd>Ruft {{jsxref("Object.toString", "toString()")}} auf.</dd> + <dt>{{jsxref("Object.prototype.toString()")}}</dt> + <dd>Gibt eine String-Darstellung des Objekts zurück.</dd> + <dt>{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}</dt> + <dd>Entfernt einen Kontrollpunkt von einem Attribut des Objekts.</dd> + <dt>{{jsxref("Object.prototype.valueOf()")}}</dt> + <dd>Gibt den primitiven Wert des spezifizierten Objekts zurück.</dd> + <dt>{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}</dt> + <dd>Fügt einem Attribut des Objekts einen Kontrollpunkt hinzu.</dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}</s></dt> + <dd>Wurde genutzt, um einen String bestehend aus JavaScript Code, im Kontext des aktuellen Objekts auszuwerten; wurde entfernt;</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Weil JavaScript keine klassischen Sub-Klassen-Funktionalität hat, sind Prototypen ein guter Weg, um "Base Class" Objekte mit bestimmten Funktionen zu erstellen, die als Objekte fungieren. Zum Beispiel:</p> + +<pre class="brush: js">var Person = function() { + this.canTalk = true; +}; + +Person.prototype.greet = function() { + if (this.canTalk) { + console.log('Hi, I am ' + this.name); + } +}; + +var Employee = function(name, title) { + Person.call(this); + this.name = name; + this.title = title; +}; + +Employee.prototype = Object.create(Person.prototype); +Employee.prototype.constructor = Employee; + +Employee.prototype.greet = function() { + if (this.canTalk) { + console.log('Hi, I am ' + this.name + ', the ' + this.title); + } +}; + +var Customer = function(name) { + Person.call(this); + this.name = name; +}; + +Customer.prototype = Object.create(Person.prototype); +Customer.prototype.constructor = Customer; + +var Mime = function(name) { + Person.call(this); + this.name = name; + this.canTalk = false; +}; + +Mime.prototype = Object.create(Person.prototype); +Mime.prototype.constructor = Mime; + +var bob = new Employee('Bob', 'Builder'); +var joe = new Customer('Joe'); +var rg = new Employee('Red Green', 'Handyman'); +var mike = new Customer('Mike'); +var mime = new Mime('Mime'); + +bob.greet(); +// Hi, I am Bob, the Builder + +joe.greet(); +// Hi, I am Joe + +rg.greet(); +// Hi, I am Red Green, the Handyman + +mike.greet(); +// Hi, I am Mike + +mime.greet(); +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.prototype', 'Object.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introduction to Object-Oriented JavaScript</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/tosource/index.html b/files/de/web/javascript/reference/global_objects/object/tosource/index.html new file mode 100644 index 0000000000..d7c7bcf93a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/tosource/index.html @@ -0,0 +1,169 @@ +--- +title: Object.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Object/toSource +translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <strong><code>toSource()</code></strong> Methode liefert einen String der den Quellcode des Objekts representiert.</p> + +<pre class="syntaxbox"><code>Object.toSource(); +<var>obj</var>.toSource(); +</code></pre> + +<h3 id="Zurückgelieferter_Wert">Zurückgelieferter Wert</h3> + +<p>Ein String der den Quellcode des Objekts representiert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toSource()</code> Methode liefer die folgenden Werte:</p> + +<p>Für das eingebaute {{jsxref("Object")}} Objekt, <code>liefert toSource() den folgenden String, welcher angibt, dass der Quellcode nicht verfügbar ist.</code></p> + +<ul> + <li> + <pre class="brush: js">function Object() { + [native code] +} +</pre> + </li> + <li>Für instanzen von {{jsxref("Object")}}, liefert <code>toSource()</code> einen String der den Sourcecode representiert.</li> +</ul> + +<p><code>toSource()</code> kann während der Entwicklung aufgerufen werden um die Inhalte eines Objekts zu inspizieren.</p> + +<h3 id="Überschreiben_der_toSource()_Methode">Überschreiben der toSource() Methode</h3> + +<p>Es ist sicher die toSource() Methode zu überschreiben. Zum Beispiel:</p> + +<pre class="brush: js">function Person(name) { + this.name = name; +} + +Person.prototype.toSource = function Person_toSource() { + return 'new Person(' + uneval(this.name) + ')'; +}; + +console.log(new Person('Joe').toSource()); // ---> new Person("Joe") +</pre> + +<h3 id="Eingebaute_toSource()_Methoden">Eingebaute toSource() Methoden</h3> + +<p>Jeder Kern-JavaScript Typ hat seine eigene t<code>oSource()</code> Methode. Diese sind:</p> + +<ul> + <li>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Array")}} Objekt.</li> + <li>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Boolean")}} Objekt.</li> + <li>{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Date")}} Objekt.</li> + <li>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Function")}} Objekt.</li> + <li>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Number")}} Objekt.</li> + <li>{{jsxref("RegExp.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("RegExp")}} Objekt.</li> + <li>{{jsxref("SIMD.toSource()", "SIMD.%type%.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("SIMD")}} Objekt.</li> + <li>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("String")}} Objekt.</li> + <li>{{jsxref("Symbol.prototype.toSource()")}} {{non-standard_inline}} — {{jsxref("Symbol")}} Objekt.</li> + <li><code>Math.toSource()</code> — Liefert den String "Math".</li> +</ul> + +<h3 id="Limits_bei_zyklischen_Objekten">Limits bei zyklischen Objekten</h3> + +<p>Im Falle, dass Objekte auf sich selbst referenzieren, z.B.: eine zyklisch verbundene Liste oder ein Baum der beide wege durchquert, erstellt <code>toSource()</code> nicht eine neue Selbst-Referenz. Dies passiert seit Firefox 24. Zum Beispiel:</p> + +<pre class="brush: js">var obj1 = {}; +var obj2 = { a: obj1 }; +obj1.b = obj2; + +console.log('Cyclical: ' + (obj1.b.a == obj1)); + +var objSource = obj1.toSource(); // returns "({b:{a:{}}})" + +obj1 = eval(objSource); + +console.log('Cyclical: ' + (obj1.b.a == obj1)); +</pre> + +<p>Wenn eine zyklische Struktur existiert und <code>toSource()</code> benötigt wird, muss das Objekt eine überschriebene toSource() Methode besitzen. Entweder durch benützen einer Referenz zum Construktor oder einer anonymen Funktion.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzen_von_toSource()"><code><font face="x-locale-heading-primary, zillaslab, Palatino, Palatino Linotype, x-locale-heading-secondary, serif">Benutzen von </font>toSource()</code></h3> + +<p>Der folgende Code defniert den "Dog" Objekt Typ und kreiert "theDog", welches ein Objekt des Typs "Dog" ist:</p> + +<pre class="brush: js">function Dog(name, breed, color, sex) { + this.name = name; + this.breed = breed; + this.color = color; + this.sex = sex; +} + +theDog = new Dog('Gabby', 'Lab', 'chocolate', 'female'); +</pre> + +<p>Durch aufrufen der <code>toSource()</code> Methode von "<code>theDog"</code> liefert die JavaScript Quelle, welche das Objekt definiert.</p> + +<pre class="brush: js">theDog.toSource(); +// returns ({name:"Gabby", breed:"Lab", color:"chocolate", sex:"female"}) +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Kein Teil eines Standards. Implementiert seit JavaScript 1.3.</p> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/valueof/index.html b/files/de/web/javascript/reference/global_objects/object/valueof/index.html new file mode 100644 index 0000000000..1b3d561756 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/valueof/index.html @@ -0,0 +1,115 @@ +--- +title: Object.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Object/valueOf +tags: + - JavaScript + - Method + - Object + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>valueOf()</strong></code> Methode liefert den primitiven Wert des spezifizierten Objekts zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/object-prototype-valueof.html")}}</div> + +<p class="hidden">Der source code für dieses interaktive Beispiel ist in einem GitHub repository verfügbar. Wenn Sie sich an dem Projekt für interaktive Beispiele beteiligen möchten, dann rufen Sie bitte eine Kopie des Repositories via git clone ab: <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und senden uns einen pull request.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>object</var>.valueOf()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Der primitive Wert des spezifizierten Objekts.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>JavaScript ruft die <code>valueOf</code> Methode auf, um das Objekt zu einem primitiven Wert zu konvertieren. Nur in seltenen Fällen ist es nötig, selbst die <code>valueOf</code> Methode aufzurufen; JavaScript tut dies automatisch dann, wenn es ein Objekt vorfindet und ein primitiver Wert erforderlich ist.</p> + +<p>Standardmäßig erbt jedes Objekt die <code>valueOf</code> Methode von {{jsxref("Object")}}. Jedes built-in core object überschreibt zudem diese Methode, um jeweils den geeigneten Wert zu liefern. Falls ein Objekt keinen primitiven Wert haben sollte, liefert <code>valueOf</code> das Objekt selbst zurück.</p> + +<p>Die Methode <code>valueOf</code> kann in eigenem Code verwendet werden, um etwa ein built-in object in seinen primitiven Wert zu wandeln. Bei der Implementierung eines eigenen Objekttyps sollte die Methode <code>Object.prototype.valueOf()</code> entsprechend überschrieben werden, anstelle der standardmäßig durch {{jsxref("Object")}} bereitgestellten Methode.</p> + +<h3 id="Überschreiben_von_valueOf_für_eigene_Objekttypen">Überschreiben von <code>valueOf</code> für eigene Objekttypen</h3> + +<p>Es ist möglich eine function zu implementieren, welche anstelle der standardmäßig bereit gestellten <code>valueOf</code> Methode aufgerufen wird. Diese empfängt und benötigt keine Argumente.</p> + +<p>Angenommen, in einem Projekt gibt es den Objekttyp <code>MyNumberType</code> und für diesen soll nun eine passende <code>valueOf</code> Methode implementiert werden. Der folgende Code zeigt wie mit einer function die <code>valueOf</code> Methode des Typs implementiert wird:</p> + +<pre class="brush: js">MyNumberType.prototype.valueOf = function() { return customPrimitiveValue; };</pre> + +<p>Mit Hilfe dieses Codes wird JavaScript automatisch diese Funktion aufrufen, sobald ein Objekt des Typs <code>MyNumberType</code> in einem Kontext steht, wo es als primitiver Wert benötigt wird.</p> + +<p>Die Methode <code>valueOf</code> eines Objekts wird üblicherweise nur von JavaScript selbst aufgerufen, kann aber ebenso wie folgt jederzeit aufgerufen werden:</p> + +<pre class="brush: js">myNumberType.valueOf()</pre> + +<div class="note"> +<p><strong>Wichtig:</strong> Objekte in String-Kontexten werden über die Methode {{jsxref("Object.toString", "toString()")}} zu String umgewandelt, was etwas anderes ist als ein {{jsxref("String")}} Objekt welches über <code>valueOf</code> zum string primitive konvertiert wird. Alle Objekte haben eine Möglichkeit, zu einem String konvertiert zu werden, selbst wenn dies lediglich resultiert in "<code>[object <em>type</em>]</code>". Die meisten Objekte hingegen können nicht gewandelt werden zu number, boolean, oder function.</p> +</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_valueOf">Verwendung von <code>valueOf</code></h3> + +<pre class="brush: js">function MyNumberType(n) { + this.number = n; +} + +MyNumberType.prototype.valueOf = function() { + return this.number; +}; + +var myObj = new MyNumberType(4); +myObj + 3; // 7 +</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">Hinweise</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.4.4', 'Object.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.prototype.valueof', 'Object.prototype.valueOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.prototype.valueof', 'Object.prototype.valueOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Object.valueOf")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> + <li>{{jsxref("parseInt", "parseInt()")}}</li> + <li>{{jsxref("Symbol.toPrimitive")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/object/values/index.html b/files/de/web/javascript/reference/global_objects/object/values/index.html new file mode 100644 index 0000000000..f3a66e5714 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/object/values/index.html @@ -0,0 +1,148 @@ +--- +title: Object.values() +slug: Web/JavaScript/Reference/Global_Objects/Object/values +translation_of: Web/JavaScript/Reference/Global_Objects/Object/values +--- +<div>{{JSRef}}</div> + +<p style="margin-bottom: 0cm; line-height: 100%;">Die Methode <code><strong>Object.values()</strong></code> gibt ein Array mit den Eigenschaftswerten eines gegebenen Objekts in der selben Reihenfolge wie eine {{jsxref("Statements/for...in", "for...in")}}-Schleife sie geben würde zurück (Der Unterschied ist dabei, dass eine for-in Schleife zusätzlich die Eigenschaften der Protoype-Kette aufzählt).</p> + +<p style="margin-bottom: 0cm; line-height: 100%;"> </p> + +<div>{{EmbedInteractiveExample("pages/js/object-values.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Object.values(<var>obj</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>Ein Objekt, dessen Eigenschaftswerte zurück gegeben werden sollen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein Array, welches die Eigenschaftswerte eines gegebenen Objekts enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>Object.values()</code> gibt ein Array zurück, dessen Elemente mit den Werten der Eigenschaften eines gegebenen Objekts übereinstimmen. Die Reihenfolge der Eigenschaften ist die selbe, wie sie sich bei einem manuellen Durchlauf über die Eigenschaften ergeben würde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">var obj = { foo: 'bar', baz: 42 }; +console.log(Object.values(obj)); // ['bar', 42] + +// Array-ähnliches Objekt +var obj = { 0: 'a', 1: 'b', 2: 'c' }; +console.log(Object.values(obj)); // ['a', 'b', 'c'] + +// Array-ähnliches Objekt mit zufälliger Sortierung der Eigenschaften +var an_obj = { 100: 'a', 2: 'b', 7: 'c' }; +console.log(Object.values(an_obj)); // ['b', 'c', 'a'] + +// getFoo ist eine nicht aufzählbare Eigenschaft +var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } }); +my_obj.foo = 'bar'; +console.log(Object.values(my_obj)); // ['bar'] + +// non-object argument will be coerced to an object +console.log(Object.values('foo')); // ['f', 'o', 'o'] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Um <code>Object.values</code> auch in älteren Umgebungen zu nutzen, die diese Methode nicht nativ unterstützen, können Sie ein Polyfill im <a href="https://github.com/tc39/proposal-object-values-entries">tc39/proposal-object-values-entries</a> oder im <a href="https://github.com/es-shims/Object.values">es-shims/Object.values</a> Repository finden.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-object.values', 'Object.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Erste Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-object.values', 'Object.values')}}</td> + <td>{{Spec2('ES8')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(54)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop(47)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari(10.1)}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android Webview</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(54)}}</td> + <td>{{CompatChrome(54)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile(47)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari(10.3)}}</td> + </tr> + </tbody> +</table> +</div> + +<p> </p> + +<p>Siehe auch</p> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li> + <li>{{jsxref("Object.keys()")}}</li> + <li>{{jsxref("Object.entries()")}} {{experimental_inline}}</li> + <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li> + <li>{{jsxref("Object.create()")}}</li> + <li>{{jsxref("Object.getOwnPropertyNames()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/parsefloat/index.html b/files/de/web/javascript/reference/global_objects/parsefloat/index.html new file mode 100644 index 0000000000..72dddf6c5b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/parsefloat/index.html @@ -0,0 +1,147 @@ +--- +title: parseFloat() +slug: Web/JavaScript/Reference/Global_Objects/parseFloat +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/parseFloat +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<p>Die <code><strong>parseFloat()</strong></code>-Funktion parst ein Zeichenketten-Argument und gibt eine Fließkommazahl zurück.</p> + +<div>{r{EmbedInteractiveExample("pages/js/globalprops-parsefloat.html")}}</div> + +<p class="hidden">Die Quelle für dieses Beispiel ist in einem GitHub-Repository abgelegt. Wenn Sie etwas zu dem Interactive Examples Project beitragen möchten, klonen Sie bitte <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und senden uns einen Pull-Request.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">parseFloat(<em>value</em>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Der Wert, den man parsen möchte.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine Fließkommazahl, die vom übergebenen Wert geparst wurde. Wenn der Wert nicht zu einer Zahl konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>parseFloat</code> ist eine Top-Level-Funktion und mit keinen Objekt assoziiert.</p> + +<p><code>parseFloat</code> übersetzt ihr Argument in eine Fließkommazahl. Trifft sie dabei auf ein anderes Zeichen als ein Vorzeichen (+ oder -), einen numerischen Werten (0-9), einen Dezimalpunkt, oder einen Exponenten, so gibt es den Wert zurück bis zu diesem Punkt und ignoriert dieses Zeichen, sowie alle nachfolgenden. Anführende und abschließende Leerzeichen sind erlaubt.</p> + +<p>Wenn der Wert eine Zeichenkette ist und die ersten Zeichen nicht in eine Zahl konvertiert werden können, gibt <code>parseFloat</code> den Wert {{jsxref("NaN")}} zurück.</p> + +<p>Für arithmetische Zwecke ist <code>NaN</code> keine Zahl für jede Basis eines Zahlensystems. Man kann die {{jsxref("isNaN")}}-Funktion aufrufen um festzustellen, ob <code>NaN</code> das Ergebnis von <code>parseFloat</code> ist. Wenn <code>NaN</code> Operand einer arithmetischen Operation ist, dann ist das Ergebnis ebenfalls <code>NaN</code>.</p> + +<p><code>parseFloat</code> kann ebenfalls den Wert <code>Infinity</code> parsen und zurückgeben. Man kann die {{jsxref("isFinite")}}-Funktion benutzen um festzustellen, ob das Ergebnis eine endliche Zahl ist (nicht <code>Infinity</code>, <code>-Infinity</code>, oder <code>NaN</code>).</p> + +<p><code>parseFloat</code> kann zudem Objekte parsen, wenn diese eine <code>toString</code>- oder <code>valueOf</code>-Methode haben. Das Ergebnis ist dasselbe, als wenn <code>parseFloat</code> mit dem Ergebnis einer dieser beiden Methoden ausgerufen wurde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="parseFloat_Rückgabe_einer_Zahl"><code>parseFloat</code> Rückgabe einer Zahl</h3> + +<p>Die folgenden Beispiele geben alle <strong>3.14 </strong>zurück</p> + +<pre class="brush:js">parseFloat(3.14); +parseFloat("3.14"); +parseFloat("314e-2"); +parseFloat("0.0314E+2"); +parseFloat("3.14mehr nicht-Ziffer-Zeichen"); + +var foo = Object.create(null); +foo.toString = function () { return "3.14"; }; +parseFloat(foo); + +var foo = Object.create(null); +foo.valueOf = function () { return "3.14"; }; +parseFloat(foo); +</pre> + +<h3 id="parseFloat_Rückgabe_von_NaN"><code>parseFloat</code> Rückgabe von <code>NaN</code></h3> + +<p>Das folgende Beispiel gibt <code>NaN</code> zurück</p> + +<pre class="brush: js">parseFloat("FF2"); +</pre> + +<h3 id="Eine_striktere_parse-Funktion">Eine striktere parse-Funktion</h3> + +<p>Unter bestimmten Umständen ist es hilfreich, einen strikteren Weg zu haben, um Fließkomma-Werte zu parsen. Reguläre Ausdrücke können hierbei helfen:</p> + +<pre class="brush: js">var filterFloat = function (value) { + if(/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/ + .test(value)) + return Number(value); + return NaN; +} + +console.log(filterFloat('421')); // 421 +console.log(filterFloat('-421')); // -421 +console.log(filterFloat('+421')); // 421 +console.log(filterFloat('Infinity')); // Infinity +console.log(filterFloat('1.61803398875')); // 1.61803398875 +console.log(filterFloat('421e+0')); // NaN +console.log(filterFloat('421hop')); // NaN +console.log(filterFloat('hop1.61803398875')); // NaN + +</pre> + +<p>Hinweis: Dies ist lediglich ein Beispiel, es akzeptiert keine zulässigen Zahlen wie <code>1.</code> oder <code>.5</code>.</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>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.2.3', 'parseFloat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-parsefloat-string', 'parseFloat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-parsefloat-string', 'parseFloat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatiblität">Browserkompatiblität</h2> + +<div class="hidden">Die Kompatibilitätstabelle auf dieser Seite wird aus strukturierten Daten erzeugt. Falls Sie zu diesen Daten etwas beitragen möchten, öffen Sie bitte <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> und senden uns einen Pull-Request.</div> + +<p>{{Compat("javascript.builtins.parseFloat")}}</p> + +<h2 id="See_Also" name="See_Also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> + <li>{{jsxref("Number.parseFloat()")}}</li> + <li>{{jsxref("Number.parseInt()")}}</li> + <li>{{jsxref("Number.toFixed()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/parseint/index.html b/files/de/web/javascript/reference/global_objects/parseint/index.html new file mode 100644 index 0000000000..39641b060a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/parseint/index.html @@ -0,0 +1,195 @@ +--- +title: parseInt() +slug: Web/JavaScript/Reference/Global_Objects/parseInt +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/parseInt +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die <strong><code>parseInt()</code></strong> Methode liest ein String-Argument ein und gibt eine ganze Zahl im angegebenen Zahlensystem zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-parseint.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">parseInt(<em>string</em>, <em>radix</em>);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>string</code></dt> + <dd>Umzuwandelnder Wert. Wenn <code>string</code> kein String ist, wird er zu einem String konvertiert (durch die abstrakte Operation <code><a href="http://www.ecma-international.org/ecma-262/6.0/#sec-tostring">ToString</a></code>). Führende Leerzeichen im String werden ignoriert.</dd> +</dl> + +<dl> + <dt><code>radix</code></dt> + <dd>Eine ganze Zahl zwischen 2 und 36, die die Basis eines mathematischen Zahlensystems ist, in der der String geschrieben ist. 10 steht für das gebräuchliche Dezimalsystem.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine ganze Zahl des übergebenen Strings. Wenn das erste Zeichen nicht zu einer Zahl konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>parseInt</code> Funktion konvertiert das erste Argument zu einem String, analysiert diesen und gibt eine ganze Zahl oder <code>NaN</code> zurück. Wenn nicht <code>NaN</code> zurückgegeben wird, ist der Wert des ersten Arguments eine gültige ganze Zahl im entsprechenden Zahlensystem. Zum Beispiel wird im 10er-Zahlensystem von einer Dezimalzahl ausgegangen, im 8er-System von einer Oktalzahl, im 16er-System von einer Hexadezimalzahl und so weiter. Für die Basis eines Zahlensystems größer als <code>10</code> sind Buchstaben des Alphabets Repräsentanten für Zahlen größer als <code>9</code>. Zum Beispiel werden für Hexadezimalezahlen (Basis 16) die Buchstaben <code>A</code> bis <code>F</code> eingesetzt.</p> + +<p>Wenn <code>parseInt</code> ein Zeichen findet, welches keine Ziffer im spezifizierten Zahlensystem ist wird dieses und alle folgenden Zeichen ignoriert. <code>parseInt</code> schneidet Nachkommstellen ab. Führende und nachgestellte Leerzeichen sind erlaubt.</p> + +<p>Weil einige Zahlen mit einem <code>e</code> Zeichen in ihrer String-Repräsentation (z. B. <strong><code>6.022e23</code></strong>), führt der Einsatz von <code>parseInt</code> zum Abschneiden von nummerischer Wert und unerwarteten Ergebnissen, wenn große oder kleine Zahlen verwendet werden. <code>parseInt</code> sollte nicht als Ersatz für {{jsxref("Math.floor()")}} eingesetzt werden.</p> + +<p>Wenn <var>radix</var> <code>undefined</code> oder 0 ist (oder fehlt), nimmt JavaScript folgendes an:</p> + +<ul> + <li>Wenn <code>string</code> mit <code>"0x"</code> oder <code>"0X"</code> beginnt, wird das Hexadezimalsystem verwendet.</li> + <li>Wenn <code>string</code> mit <code>"0"</code> beginnt, wird das Oktal- oder Dezimalsystem verwendet (Implementierungsabhängig). ECMAScript 5 spezifiziert das Dezimalsystem, jedoch unterstützen das nicht alle Browser. <strong>Deswegen sollte der Parameter <code>radix</code> immer angegeben werden</strong></li> + <li>Wenn <code>string</code> mit einem anderen Zeichen beginnt, wird das Dezimalsystem verwendet.</li> +</ul> + +<p>Wenn das erste Zeichen nicht zu einer Zahl konvertiert werden kann, gibt <code>parseInt</code> <code>NaN</code> zurück.</p> + +<p>Für arithmetische Zwecke ist <code>NaN</code> in keinem Zahlensystem eine Zahl. Man kann die Funktion {{jsxref("isNaN", "isNaN()")}} aufrufen, um zu prüfen, ob das Ergebnis von <code>parseInt</code> <code>NaN</code> ist. Wenn <code>NaN</code> in einer arithmetischen Operation eingesetzt wird, ist das Ergebnis auch immer <code>NaN</code>.</p> + +<p>Um Zahlen in String-Repräsentationen in verschiedenen Zahlensystemen zu konvertieren nutze folgendes:<br> + <code>intValue.toString(radix)</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_parseInt">Einsatz von <code>parseInt</code></h3> + +<p>Alle folgenden Beispiele geben <strong><code>15</code> </strong>zurück:</p> + +<pre class="brush: js">parseInt(" 0xF", 16); +parseInt(" F", 16); +parseInt("17", 8); +parseInt(021, 8); +parseInt("015", 10); +parseInt(15.99, 10); +parseInt("15,123", 10); +parseInt("FXX123", 16); +parseInt("1111", 2); +parseInt("15*3", 10); +parseInt("15e2", 10); +parseInt("15px", 10); +parseInt("12", 13); +</pre> + +<p>Alle folgenden Beispiele geben <code><strong>NaN</strong></code> zurück:</p> + +<pre class="brush: js">parseInt("Hello", 8); // Not a number at all +parseInt("546", 2); // Digits are not valid for binary representations +</pre> + +<p>Alle folgenden Beispiele geben <code><strong>-15</strong></code> zurück:</p> + +<pre class="brush: js">parseInt("-F", 16); +parseInt("-0F", 16); +parseInt("-0XF", 16); +parseInt(-15.1, 10); +parseInt(" -17", 8); +parseInt(" -15", 10); +parseInt("-1111", 2); +parseInt("-15e1", 10); +parseInt("-12", 13); +</pre> + +<p>Die folgenden Beispiele geben <code><strong>4</strong></code> zurück:</p> + +<pre class="brush: js">parseInt(4.7, 10); +parseInt(4.7 * 1e22, 10); // Sehr große Zahl wird zu 4 +parseInt(0.00000000000434, 10); // Sehr kleine Zahl wird zu 4</pre> + +<p>Das folgende Beispiel gibt <strong><code>224</code></strong> zurück:</p> + +<pre class="brush: js">parseInt("0e0", 16); +</pre> + +<h2 id="Oktal-Interpretationen_ohne_radix">Oktal-Interpretationen ohne radix</h2> + +<p>Obwohl ECMAScript 3 es nicht empfahl und ECMAScript 5 es verbietet, interpretieren viele Implementierungen einen mit <code>"0"</code> beginnende String als Oktalzahl. Das folgende Beispiel hat ein Ergebnis im Oktal- oder Dezimalsystem. <strong>Das Zahlensystem sollte immer angegeben werden, um solche Verwirrungen zu vermeiden.</strong></p> + +<pre class="brush: js">parseInt("0e0"); // 0 +parseInt("08"); // 0, '8' ist keine oktale Ziffer. +</pre> + +<h3 id="ECMAScript_5_entfernt_oktale_Interpretation">ECMAScript 5 entfernt oktale Interpretation</h3> + +<p>Die ECMAScript 5 Spezifikation der <code>parseInt</code> Funktion erlaubt es nicht mehr einen mit <code>0</code> beginnenden String als Oktalzahl zu interpretieren. ECMAScript 5 Stand:</p> + +<p>Die <code>parseInt</code> Funktion produziert eine ganze Zahl, indem der Inhalt vom string Argument interpretiert wird, abhängig vom in radix angegebenen Zahlensystem. Führende Whitespaces werden ignoriert. Wenn radix <code>undefined</code> oder <code>0</code> ist, wird von <code>10</code> ausgegangen, außer die Zahl beginnt mit den Zeichen <code>0x</code> oder <code>0X</code>, dann wird <code>16</code> für radix angenommen.</p> + +<p>Das unterscheidet sich von der ECMAScript 3 Spezifikation, welche Oktalinterpretationen nicht empfiehlt, sie aber erlaubt.</p> + +<p>Weil viele Implementierungen dieses Verhalten seit 2013 nicht geändert haben und auch ältere Browser unterstützt werden müssen, <strong>sollte immer das radix-Argument gesetzt werden.</strong></p> + +<h2 id="Eine_strenge_parse-Funktion">Eine strenge parse-Funktion</h2> + +<p>Es ist manchmal nützliche eine strenge Funktion für die Umwandlung von ganzen Zahlen zu verwenden. Reguläre Ausdrücke können helfen:</p> + +<pre class="brush: js">filterInt = function (value) { + if(/^(\-|\+)?([0-9]+|Infinity)$/.test(value)) + return Number(value); + return NaN; +} + +console.log(filterInt('421')); // 421 +console.log(filterInt('-421')); // -421 +console.log(filterInt('+421')); // 421 +console.log(filterInt('Infinity')); // Infinity +console.log(filterInt('421e+0')); // NaN +console.log(filterInt('421hop')); // NaN +console.log(filterInt('hop1.61803398875')); // NaN +console.log(filterInt('1.61803398875')); // 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">Komment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.2.2', 'parseInt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-parseint-string-radix', 'parseInt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-parseint-string-radix', 'parseInt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.parseInt")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("parseFloat", "parseFloat()")}}</li> + <li>{{jsxref("Number.parseFloat()")}}</li> + <li>{{jsxref("Number.parseInt()")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> + <li>{{jsxref("Number.toString()")}}</li> + <li>{{jsxref("Object.valueOf")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/promise/all/index.html b/files/de/web/javascript/reference/global_objects/promise/all/index.html new file mode 100644 index 0000000000..9753db7994 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/promise/all/index.html @@ -0,0 +1,137 @@ +--- +title: Promise.all() +slug: Web/JavaScript/Reference/Global_Objects/Promise/all +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Promise +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>Promise.all(iterable)</strong></code> Methode gibt einen {{jsxref("Promise")}} zurück, welcher erfüllt(<em>resolved)</em> wird, wenn alle Promises in dem <em>iterable </em>- Argument erfüllt wurden oder wenn das <em>iterable</em> - Argument keine Promises enthält. Eine Ablehnung (<em>reject</em>) erfolgt mit dem Grund des ersten Promises, das abgelehnt wurde, oder mit dem Error der von dem ersten Argument, wenn das innerhalb eines try/catch/throw blocks gefangen wurde.</p> + +<p>Es wird typischerweise für mehrere asynchrone Aufgaben die parallel laufen und die Promises als Ergebnisse haben, so das eines warten kann, bis alle anderen Aufgaben abgeschlossen sind.</p> + +<div>{{EmbedInteractiveExample("pages/js/promise-all.html")}}</div> + +<p class="hidden">Die Quellen für diese interaktive Demo sind in einem GitHub Repository gespeichert. Wenn Du etwas zum interaktiven Demo Projekt beitragen willst, klone das Repository <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und schicke uns einen pull request.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Promise.all(<var>iterable</var>);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>iterable</dt> + <dd>Ein <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol">iterierbares</a> Objekt, z.B. ein {{jsxref("Array")}} oder ein {{jsxref("String")}}.</dd> +</dl> + +<h3 id="Rückgabe-Wert">Rückgabe-Wert</h3> + +<ul> + <li>Ein <strong>bereits eingelöstes</strong> {{jsxref("Promise")}}, wenn das eingegebene <em>iterable</em> - Argument leer ist.</li> + <li>Ein <strong>asynchron eingelöstes</strong> {{jsxref("Promise")}}, wenn das eingegebene <em>iterable</em> - Argument keine Promises enthält. Achtung, Google Chrome 58 gibt in diesem Fall ein <strong>bereits eingelöstes</strong> Promise zurück.</li> + <li>Ein <strong>ausstehendes</strong> (<em>pending</em>) {{jsxref("Promise")}} in allen anderen Fällen. Dieses zurückgegebene Promise wird dann <strong>asynchron</strong> erfüllt/abgelehnt (sobald der <em>stack</em> leer ist), wenn alle Promises des gegebenen <em>iterable</em> erfüllt wurden, oder wenn irgendeiner der Promises abgelehnt wird. Die Rückgabewerte entsprechen dann der Reihenfolge der Promises, unabhängig von der Reihenfolge der Erfüllung.</li> +</ul> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode dient dem Bündeln von mehreren Promises.</p> + +<p>Erfüllt: <br> + Wenn alle Promises erfolgreich erfüllt werden, oder keine Promises sind, wird <code>Promise.all</code> mit einem Array, welches die Rückgabewerte der einzelnen Promises (aber auch die nicht-Promise Werte) enthält, erfüllt. Wenn ein leeres Array übergeben wird, wird <code>Promise.all</code> (synchron) sofort erfüllt. </p> + +<p>Abgelehnt:<br> + Wenn eines der übergebenen Promises abgelehnt wird, wird <code>Promise.all</code> asynchron mit dem Wert des fehlgeschlagenen Promise abgelehnt, ganz egal, ob die anderen Promises erfolgreich waren oder nicht.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Erfolgreich">Erfolgreich:</h3> + +<pre class="brush: js">var p1 = Promise.resolve(3); +var p2 = 1337; +var p3 = new Promise((resolve, reject) => { + setTimeout(resolve, 100, 'foo'); +}); + +Promise.all([p1, p2, p3]) +.then(values => { + console.log(values); // [3, 1337, "foo"] +}); +</pre> + +<h3 id="Sofortige_Ablehnung">Sofortige Ablehnung:</h3> + +<pre class="brush: js">var p1 = new Promise((resolve, reject) => { + setTimeout(resolve, 1000, 'one'); +}); +var p2 = new Promise((resolve, reject) => { + setTimeout(resolve, 2000, 'two'); +}); +var p3 = new Promise((resolve, reject) => { + setTimeout(resolve, 3000, 'three'); +}); +var p4 = new Promise((resolve, reject) => { + setTimeout(resolve, 4000, 'four'); +}); +var p5 = new Promise((resolve, reject) => { + reject('reject'); +}); + +Promise.all([p1, p2, p3, p4, p5]).then(values => { + console.log(values); +}, reason => { + console.log(reason) +}); + +//From console: +//"reject" + +//You can also use .catch +Promise.all([p1, p2, p3, p4, p5]).then(values => { + console.log(values); +}).catch(reason => { + console.log(reason) +}); + +//From console: +//"reject" +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td><a href="https://github.com/domenic/promises-unwrapping">domenic/promises-unwrapping</a></td> + <td>Draft</td> + <td>Standardization work is taking place here.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-promise.all', 'Promise.all')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition in an ECMA standard.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatiblität">Browserkompatiblität</h2> + +<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Promise.all")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Promise.race()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/promise/finally/index.html b/files/de/web/javascript/reference/global_objects/promise/finally/index.html new file mode 100644 index 0000000000..588d00d43f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/promise/finally/index.html @@ -0,0 +1,93 @@ +--- +title: Promise.prototype.finally() +slug: Web/JavaScript/Reference/Global_Objects/Promise/finally +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/finally +--- +<div>{{JSRef}}</div> + +<p>finally () gibt ein {{jsxref ("Promise")}} zurück. Wenn das Promise erfüllt oder abgelehnt wird, wird die angegebene callback-Funktion ausgeführt. Dies stellt eine Möglichkeit für Code bereit, der ausgeführt werden muss, unabhängig davon, ob das Promise erfolgreich erfüllt wurde oder nicht. Auf diese Weise können Sie vermeiden, dass derselbe Code für die beiden Handlern des Promise {{jsxref ("Promise.then", "then ()")}} und {{jsxref ("Promise.catch", "catch ()")}} geschrieben werden muss.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>p.finally(onFinally)</var>; + +p.finally(function() { + // settled (fulfilled or rejected) +}); +</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>onFinally</code></dt> + <dd>A {{jsxref("Function")}} called when the <code>Promise</code> is settled.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Returns a {{jsxref("Promise")}} whose <code>finally</code> handler is set to the specified function, <code>onFinally</code>.</p> + +<h2 id="Description">Description</h2> + +<p>The <code>finally()</code> method can be useful if you want to do some processing or cleanup once the promise is settled, regardless of its outcome.</p> + +<p>The <code>finally()</code> method is very similar to calling <code>.then(onFinally, onFinally)</code> however there are couple of differences:</p> + +<ul> + <li>When creating a function inline, you can pass it once, instead of being forced to either declare it twice, or create a variable for it</li> + <li>A <code>finally</code> callback will not receive any argument, since there's no reliable means of determining if the promise was fulfilled or rejected. This use case is for precisely when you <em>do not care</em> about the rejection reason, or the fulfillment value, and so there's no need to provide it.</li> + <li>Unlike <code>Promise.resolve(2).then(() => {}, () => {})</code> (which will be resolved with <code>undefined</code>), <code>Promise.resolve(2).finally(() => {})</code> will be resolved with <code>2</code>.</li> + <li>Similarly, unlike <code>Promise.reject(3).then(() => {}, () => {})</code> (which will be fulfilled with <code>undefined</code>), <code>Promise.reject(3).finally(() => {})</code> will be rejected with <code>3</code>.</li> +</ul> + +<div class="note"> +<p><strong>Note:</strong> A <code>throw</code> (or returning a rejected promise) in the <code>finally</code> callback will reject the new promise with the rejection reason specified when calling <code>throw()</code>.</p> +</div> + +<h2 id="Examples">Examples</h2> + +<pre class="brush: js">let isLoading = true; + +fetch(myRequest).then(function(response) { + var contentType = response.headers.get("content-type"); + if(contentType && contentType.includes("application/json")) { + return response.json(); + } + throw new TypeError("Oops, we haven't got JSON!"); + }) + .then(function(json) { /* process your JSON further */ }) + .catch(function(error) { console.log(error); }) + .finally(function() { isLoading = false; }); + +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td><a href="https://github.com/tc39/proposal-promise-finally">TC39 proposal</a></td> + <td>Stage 4</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Promise.finally")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Promise.prototype.then()")}}</li> + <li>{{jsxref("Promise.prototype.catch()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/promise/index.html b/files/de/web/javascript/reference/global_objects/promise/index.html new file mode 100644 index 0000000000..9e9756ac65 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/promise/index.html @@ -0,0 +1,244 @@ +--- +title: Promise +slug: Web/JavaScript/Reference/Global_Objects/Promise +translation_of: Web/JavaScript/Reference/Global_Objects/Promise +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>Promise</code></strong> Objekt stellt eine Repräsentation einer eventuellen Ausführung (oder eines Fehlschlags) einer asynchronen Operation und den daraus resultierenden Ergebnissen dar.</p> + +<p>Um mehr darüber zu erfahren wie promises funktionieren und wie diese verwendet werden sollte zuerst <a href="/de-DE/docs/Web/JavaScript/Guide/Using_promises">Promises benutzen</a> gelesen werden.</p> + +<dl> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Das <strong><code>Promise-Objekt (dt./deutsch Ein Versprechens-Objekt, das später eingelöst wird)</code></strong>wird für asynchrone Berechnungen verwendet.</p> + +<p>Ein <code>Promise</code> kann sich in einem von drei Zuständen befinden:</p> + +<ul> + <li><em>pending</em> (schwebend): initialer Status, weder fulfilled noch rejected.</li> + <li><em>fulfilled</em> (erfüllt): heisst das die Operation erfolgreich abgeschlossen wurde.</li> + <li><em>rejected</em> (zurück gewiesen): heisst das die Operation gescheitert ist.</li> +</ul> + +<p>Ein weiterer Begriff beschreibt den Zustand <em>settled (erledigt aber nicht zwingend erfolgreich)</em>: Der Promise ist entweder <em>fulfilled</em> oder <em>rejected</em>, aber nicht <em>pending</em>.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate">new Promise(<em>executor</em>); +new Promise(function(resolve, reject) { ... });</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>executor (Ausführer)</dt> + <dd>Funktion mit den zwei Argumenten <code>resolve</code> und <code>reject</code>. Das erste Argument führt den Promise aus, das zweite verwirft ihn. Die Funktionen können ausgeführt werden, sobald die Operation durchgeführt wurde.</dd> +</dl> + +<h2 id="Beschreibung_2">Beschreibung</h2> + +<p>Das <code><strong>Promise</strong></code>-Interface repräsentiert einen Proxy für einen Wert, der nicht zwingend bekannt ist, wenn der Promise erstellt wird. Das erlaubt die Assoziation zwischen <em>Handler</em> und dem Gelingen oder Fehlschlagen einer asynchronen Aktion. Mit diesem Mechanismus können asynchrone Methoden in gleicher Weise Werte zurück geben wie synchrone Methoden: Anstelle des endgültigen Wertes wird ein <em>Promise</em> zurückgegeben, dass es zu einem Zeitpunkt in der Zukunft einen Wert geben wird.</p> + +<p>Ein Promise mit dem Status <em>pending</em> kann entweder zu <em>fulfilled</em> mit Wert oder zu einem <em>rejected</em> mit Grund werden. Wenn einer dieser Fälle eintritt, werden die assoziierten <em>Handler</em>, die über die <em>then</em>-Methode gequeued wurde, aufgerufen. Ist ein Promise bereits in fullfilled oder rejected und wird erst dann ein entsprechender <em>Handler</em> hinzugefügt, dann wird dieser Handler aufgerufen. Es gibt somit keine <em>Race Conditions</em> zwischen der Ausführung der asynchronen Aktion und dem Hinzufügen des <em>Handlers</em>.</p> + +<p>Da die Methoden<code> Promise.prototype.then</code> und <code>Promise.prototype.catch</code> Promises zurückgeben, können sie aneinander gereiht werden (Komposition).</p> + +<p><img alt="" src="https://mdn.mozillademos.org/files/8633/promises.png" style="height: 297px; width: 801px;"></p> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt><code>Promise.length</code></dt> + <dd><em>Length</em>-Attribut mit dem Wert 1 (Anzahl der Konstruktorargumente).</dd> + <dt>{{jsxref("Promise.prototype")}}</dt> + <dd>Repräsentiert den Prototyp für den <code>Promise</code>-Konstruktor.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("Promise.all", "Promise.all(iterable)")}}</dt> + <dd>Gibt einen <code>Promise</code> zurück, der aufgelöst wird, sobald alle Promises in dem <code>iterable</code>-Argument aufgelöst wurden.</dd> + <dt>{{jsxref("Promise.race", "Promise.race(iterable)")}}</dt> + <dd>Gibt einen <code>Promise</code> zurück, der aufgelöst oder verworfen wird, sobald einer der Promises in dem <code>iterable</code>-Argument aufgelöst oder verworfen wurde, und den Wert oder den Grund dieses Promise enthält.</dd> +</dl> + +<dl> + <dt>{{jsxref("Promise.reject", "Promise.reject(reason)")}}</dt> + <dd>Gibt einen <code>Promise</code> zurück, der mit dem angegeben Grund (<code>reason</code>) verworfen wird.</dd> +</dl> + +<dl> + <dt>{{jsxref("Promise.resolve", "Promise.resolve(value)")}}</dt> + <dd>Gibt einen <code>Promise</code> zurück, der mit <code>value</code> aufgelöst wird. Falls der Wert ein <em>thenable</em> ist (Objekt besitzt eine <code>then</code>-Methode), folgt der zurückgegebene <code>Promise</code> dem <em>thenable</em> und übernimmt den Status. Andernfalls wird der zurückgegebene <code>Promise</code> auf <em>fulfilled</em> gesetzt.</dd> +</dl> + +<h2 id="Promise-Prototyp"><code>Promise</code>-Prototyp</h2> + +<h3 id="Eigenschaften">Eigenschaften</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Eigenschaften')}}</p> + +<h3 id="Methoden_2">Methoden</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Methoden')}}</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einen_Promise_erstellen">Einen Promise erstellen</h3> + +<pre class="brush: html notranslate" style="display: none;"><button id="btn">Make a promise!</button> +<div id="log"></div> +</pre> + +<p>Dieses kleine Beispiel zeigt den Mechanismus eines <code>Promise</code>. Die Methode <code>testPromise() </code>wird jedes Mal aufgerufen, wenn der {{HTMLElement("button")}} geklickt wurde. Es wird ein Promise erstellt, der mithilfe von <code>window.setTimeout</code> nach einer zufällig gewählten Zeit (1-3 s) zu <code>'result'</code> aufgelöst wird.</p> + +<p>Die Ausführung der Promises wird mit einem <em>fulfill</em>-Callback unter Verwendung von <code>p1.then</code> gelogt. Durch ein paar Logeinträge wird gezeigt, wie der synchrone Teil der Methode von der asynchronen Vollendung des Promises abgekoppelt ist.</p> + +<pre class="brush: js notranslate">var promiseCount = 0; +function testPromise() { + var thisPromiseCount = ++promiseCount; + + var log = document.getElementById('log'); + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Started (<small>Sync code started</small>)<br/>'); + + // Wir erstellen einen neuen Promise: wir versprechen den String 'result' (Wartezeit max. 3s) + var p1 = new Promise( + // Resolver-Funktion kann den Promise sowohl auflösen als auch verwerfen + // reject the promise + function(resolve, reject) { + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Promise started (<small>Async code started</small>)<br/>'); + // nur ein Beispiel, wie Asynchronität erstellt werden kann + window.setTimeout( + function() { + // We fulfill the promise ! + resolve(thisPromiseCount) + }, Math.random() * 2000 + 1000); + }); + + // wir bestimmen, was zu tun ist, wenn der Promise fulfilled + p1.then( + // Loggen der Nachricht und des Wertes + function(val) { + log.insertAdjacentHTML('beforeend', val + + ') Promise fulfilled (<small>Async code terminated</small>)<br/>'); + }); + + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Promise made (<small>Sync code terminated</small>)<br/>'); +} +</pre> + +<pre class="brush:js notranslate" style="display: none;">if ("Promise" in window) { + btn = document.getElementById("btn"); + btn.addEventListener("click",testPromise); +} +else { + log = document.getElementById('log'); + log.innerHTML = "Live example not available as your browser doesn't support the Promise interface."; +} +</pre> + +<p>Dieses Beispiel wird ausgeführt, wenn der Button geklickt wird. Man benötigt einen Browser, der <em>Promise</em> unterstützt. Durch mehrmaliges Klicken in kurzer Zeit kann beobachtet werden, wie die einzelnen Promises nacheinander <em>fulfilled</em> werden.</p> + +<p>{{EmbedLiveSample("Creating_a_Promise", "500", "200")}}</p> + +<h3 id="Laden_eines_Bildes_mit_XHR">Laden eines Bildes mit XHR</h3> + +<p>Ein weiteres, einfaches Beispiel für die Verwendung von Promises und <code><a href="/en-US/docs/Web/API/XMLHttpRequest">XMLHTTPRequest</a>,</code> um ein Bild zu laden, ist in dem MDN GitHub <a href="https://github.com/mdn/js-examples/blob/master/promises-test/index.html">promise-test</a> Repository. <a href="https://mdn.github.io/js-examples/promises-test/">Hier </a>kannst du es in Aktion sehen. Jeder Schritt ist kommentiert und erlaubt die den Promises und der XHR-Architektur nachzuvollziehen.</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><a href="https://github.com/domenic/promises-unwrapping">domenic/promises-unwrapping</a></td> + <td>Draft</td> + <td>Standardisierung findet hier statt.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-promise-objects', 'Promise')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition als ein ECMA-Standard.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatiblität">Browserkompatiblität</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic Support</td> + <td>32</td> + <td>{{CompatGeckoDesktop(24.0)}} als <code>Future</code><br> + {{CompatGeckoDesktop(25.0)}} als <code>Promise</code> hinter einem Flag[1]<br> + {{CompatGeckoDesktop(29.0)}} per Default</td> + <td>{{CompatNo}}</td> + <td>19</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic Support</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile(24.0)}} als <code>Future</code><br> + {{CompatGeckoMobile(25.0)}} als <code>Promise</code> hinter einem Flag[1]<br> + {{CompatGeckoMobile(29.0)}} per Default</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>iOS 8</td> + <td>32</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Gecko 24 hat eine experimentelle Implementierung von <em>Promises</em> unter dem vorherigen Namen <em>Future</em>. In Gecko 25 wurde sie in ihren endgültigen Namen umbenannt, wird aber per Default durch das Flag <code>dom.promise.enable</code> unterdrückt. <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918806">Bug 918806</a> aktiviert Promises per Default in Gecko 29.</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="http://promisesaplus.com/">Promises/A+ specification</a></li> + <li><a href="http://www.html5rocks.com/en/tutorials/es6/promises/">Jake Archibald: JavaScript Promises: There and Back Again</a></li> + <li><a href="http://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript">Domenic Denicola: Callbacks, Promises, and Coroutines – Asynchronous Programming Patter in JavaScript</a></li> + <li><a href="http://www.mattgreer.org/articles/promises-in-wicked-detail/">Matt Greer: JavaScript Promises ... In Wicked Detail</a></li> + <li><a href="https://www.promisejs.org/">Forbes Lindesay: promisejs.org</a></li> + <li>Fussnote1: bitte die englischen Begriffe in dieser Übersetzung stehen lassen, da sonst der Zusammenhang zu englischen Dokumentation völlig verloren geht. Worte wie 'Promise' sollte man sich merken, um sie auch in englisch zu verstehen.</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/promise/race/index.html b/files/de/web/javascript/reference/global_objects/promise/race/index.html new file mode 100644 index 0000000000..78c4d9edf2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/promise/race/index.html @@ -0,0 +1,184 @@ +--- +title: Promise.race() +slug: Web/JavaScript/Reference/Global_Objects/Promise/race +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Promise +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/race +--- +<div>{{JSRef}}</div> + +<p><code><strong>Promise.race(iterable)</strong></code> gibt ein erfolgreiches oder fehlgeschlagenes Promise zurück, sobald eines der Promises in dem <code>iterable</code> erfolgreich war oder fehlgeschlagen ist, entsprechend mit dem <code>value</code> oder dem <code>reason</code> dieses Promises.</p> + +<div>{{EmbedInteractiveExample("pages/js/promise-race.html")}}</div> + +<p class="hidden">Der Code für das interaktive Demo ist in einem GitHub Repository zu finden. Sollten Sie bei diesem interaktiven Demo Projekt mitmachen wollen, dann klonen Sie <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und senden uns einen Pull Request.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>Promise.race(iterable)</var>;</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>iterable</dt> + <dd>Ein iterierbares Objekt, wie zum Beispiel {{jsxref("Array")}}. Siehe auch <a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterable</a>.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine {{jsxref("Promise")}} im Status <strong>pending</strong>, die <strong>asynchron</strong> (sobald der Stack leer ist) einen erfolgreichen oder fehlerhaften Status annimmt, sobald die erste Promise erfolgreich, bzw. fehlerhaft ist und entsprechend diesen Wert zurückliefert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>race</code> Funktion gibt eine <code>Promise</code> zurück, die sich genauso verhält, wie die Promise aus <code>iterable</code>, die als erstes einen erfolgreichen oder fehlerhaften Status annimmt und entsprechend diesen Wert zurückliefert.</p> + +<p>Wenn das übergebene <code>iterable</code> leer ist, wird die Promise für immer im Status <strong>pending</strong> verharren.</p> + +<p>Wenn <code>iterable</code> einen oder mehrere Werte enthält, die keine Promise sind bzw. Promises die bereits einen erfolgreichen oder fehlerhaften Status angenommen haben, dann wird die zurückgegebene Promise von <code>Promise.race</code> entsprechend den ersten dieser Werte aus <code>iterable</code> annehmen.</p> + +<h2 id="Beispiele"> Beispiele</h2> + +<h3 id="Asynchronität_von_Promise.race"><font face="consolas, Liberation Mono, courier, monospace">Asynchronität von <code>Promise.race</code></font></h3> + +<p>Das folgende Beispiel demonstriert the Asynchronität von <code>Promise.race:</code></p> + +<pre class="brush: js">// wir übergeben als Argument ein Array von Promises, die bereits einen +// erfolgreichen Status angenommen haben, um Promise.race sofort auszulösen +var resolvedPromisesArray = [Promise.resolve(33), Promise.resolve(44)]; + +var p = Promise.race(resolvedPromisesArray); +// sofortiges Loggen des Wertes aus p +console.log(p); + +// mit setTimeout wird der Code erst nachdem der Stack leer ist ausgeführt +setTimeout(function(){ + console.log('der Stack ist jetzt leer'); + console.log(p); +}); + +// Logs, in der Reihenfolge: +// Promise { <state>: "pending" } +// der Stack ist jetzt leer +// Promise { <state>: "fulfilled", <value>: 33 }</pre> + +<p>Ein leeres <code>iterable</code> führt zu einer Promise, die für immer im Status <strong>pending</strong> bleibt:</p> + +<pre class="brush: js">var foreverPendingPromise = Promise.race([]); +console.log(foreverPendingPromise); +setTimeout(function(){ + console.log('der Stack ist jetzt leer'); + console.log(foreverPendingPromise); +}); + +// Logs, in der Reihenfolge: +// Promise { <state>: "pending" } +// der Stack ist jetzt leer +// Promise { <state>: "pending" } +</pre> + +<p>Wenn <code>iterable</code> einen oder mehrere Werte enthält, die keine Promise sind bzw. Promises die bereits einen erfolgreichen oder fehlerhaften Status angenommen haben, dann wird <code>Promise.race</code> entsprechend den ersten dieser Werte aus <code>iterable</code> annehmen:</p> + +<pre class="brush: js">var foreverPendingPromise = Promise.race([]); +var alreadyResolvedProm = Promise.resolve(666); + +var arr = [foreverPendingPromise, alreadyResolvedProm, "keine Promise"]; +var arr2 = [foreverPendingPromise, "keine Promise", Promise.resolve(666)]; +var p = Promise.race(arr); +var p2 = Promise.race(arr2); + +console.log(p); +console.log(p2); +setTimeout(function(){ + console.log('der Stack ist jetzt leer'); + console.log(p); + console.log(p2); +}); + +// Logs, in der Reihenfolge: +// Promise { <state>: "pending" } +// Promise { <state>: "pending" } +// der Stack ist jetzt leer +// Promise { <state>: "fulfilled", <value>: 666 } +// Promise { <state>: "fulfilled", <value>: "keine Promise" } +</pre> + +<h3 id="Benutzung_von_Promise.race_–_Beispiele_mit_setTimeout">Benutzung von <code>Promise.race</code> – Beispiele mit <a href="/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout"><code>setTimeout</code></a></h3> + +<pre class="brush: js">var p1 = new Promise(function(resolve, reject) { + setTimeout(resolve, 500, 'eins'); +}); +var p2 = new Promise(function(resolve, reject) { + setTimeout(resolve, 100, 'zwei'); +}); + +Promise.race([p1, p2]).then(function(value) { + console.log(value); // "zwei" + // beide erfolgreich, aber p2 ist schneller +}); + +var p3 = new Promise(function(resolve, reject) { + setTimeout(resolve, 100, 'drei'); +}); +var p4 = new Promise(function(resolve, reject) { + setTimeout(reject, 500, 'vier'); +}); + +Promise.race([p3, p4]).then(function(value) { + console.log(value); // "drei" + // p3 ist schneller, also insgesamt erfolgreich +}, function(reason) { + // nicht aufgerufen +}); + +var p5 = new Promise(function(resolve, reject) { + setTimeout(resolve, 500, 'fünf'); +}); +var p6 = new Promise(function(resolve, reject) { + setTimeout(reject, 100, 'sechs'); +}); + +Promise.race([p5, p6]).then(function(value) { + // nicht aufgerufen +}, function(reason) { + console.log(reason); // "sechs" + // p6 ist schneller, also insgesamt fehlerhaft +}); +</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-promise.race', 'Promise.race')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition eines ECMA Standards.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-promise.race', 'Promise.race')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">The Kompatibilitätstabelle auf dieser Seite wurde aus strukturierten Daten generiert. Wenn Sie Daten beisteuert möchten, schauen Sie sich gerne <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> an und senden uns einen Pull Request.</p> + +<p>{{Compat("javascript.builtins.Promise.race")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Promise.all()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/promise/reject/index.html b/files/de/web/javascript/reference/global_objects/promise/reject/index.html new file mode 100644 index 0000000000..1b90305142 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/promise/reject/index.html @@ -0,0 +1,74 @@ +--- +title: Promise.reject() +slug: Web/JavaScript/Reference/Global_Objects/Promise/reject +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/reject +--- +<div>{{JSRef}}</div> + +<div>Die <code><strong>Promise.reject(reason)</strong></code> Methode gibt ein <code>Promise</code> Objekt zurück, das mit dem angegebenen Grund <code><strong>reason</strong></code> abgelehnt wurde.</div> + +<p> </p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>Promise.reject(reason)</var>;</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>reason</dt> + <dd>Der Grund warum diese <code>Promise</code> abgelehnt wurde.</dd> +</dl> + +<h3 id="Rückgabewerte">Rückgabewerte</h3> + +<p>Ein {{jsxref("Promise")}}, das mit dem angegeben Grund abgelehnt wurde</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die statische <code>Promise.reject</code> Funktion gibt ein <code>Promise</code> zurück, das abgelehnt wurde. Für Debugging zwecke, sowie gezielte Fehlerverarbeitung ist es empfehlenswert, als <code>reason</code> eine <code>instanceof </code>{{jsxref("Error")}}. zu verwenden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_der_Promise.reject()_Methode">Verwendung der Promise.reject() Methode</h3> + +<pre class="brush: js">Promise.reject(new Error('fail')).then(function(error) { + // nicht aufgerufen +}, function(error) { + console.log(error); // Stacktrace +});</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-promise.reject', 'Promise.reject')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition in an ECMA standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-promise.reject', 'Promise.reject')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p class="hidden">To contribute to this compatibility data, please write a pull request against this file: <a href="https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json">https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json</a>.</p> + +<p>{{Compat("javascript/promise","Promise.reject")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li><a href="https://github.com/petkaantonov/bluebird#error-handling">Selective error catching using the BlueBird Promise library</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/promise/then/index.html b/files/de/web/javascript/reference/global_objects/promise/then/index.html new file mode 100644 index 0000000000..3578cfcb62 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/promise/then/index.html @@ -0,0 +1,149 @@ +--- +title: Promise.prototype.then() +slug: Web/JavaScript/Reference/Global_Objects/Promise/then +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/then +--- +<div>{{JSRef}}</div> + +<div>Die <strong>then()</strong>-Methode gibt ein <code>Promise</code>-Objekt zurück. Sie benötigt zwei Argumente, jeweils eine Callback-Funktion für den Erfolg und den Fehlschlag des <code>Promise</code>.</div> + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>p.then(onFulfilled, onRejected)</var>; + +p.then(function(value) { + // fulfillment + }, function(reason) { + // rejection +}); +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>onFulfilled</dt> + <dd>Eine {{jsxref("Function")}}, welche aufgerufen wird, wenn der <code>Promise</code> erfüllt wurde. Die Funktion hat ein Argument, den Rückgabewert <code>value</code>.</dd> + <dt>onRejected {{optional_inline}}</dt> + <dd>Eine {{jsxref("Function")}}, welche aufgerufen wird, wenn der <code>Promise</code> fehlschlägt. Die Funktion hat ein Argument, den Grund für den Fehlschlag: <code>reason</code>. Ist keine Funktion definiert, so wird sie intern durch die "Thrower" Funktion ersetzt (Dieser gibt einen Fehler als Argument zurück)</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>then</code>- und {{jsxref("Promise.prototype.catch()")}}-Methoden, können, da sie Promises zurückgeben<font face="Consolas, Liberation Mono, Courier, monospace">, verkettetet werden </font>— ein Vorgehen, das <em>composition</em> genannt wird.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzen_der_then-Methode">Benutzen der <code>then</code>-Methode</h3> + +<pre class="brush: js">var p1 = new Promise(function(resolve, reject) { + resolve("Success!"); + // or + // reject ("Error!"); +}); + +p1.then(function(value) { + console.log(value); // Success! +}, function(reason) { + console.log(reason); // Error! +}); +</pre> + +<h3 id="Verketten">Verketten</h3> + +<p>Da die <code>then</code>-Methode einen <code>Promise</code> zurückliefert, können <code>then</code>-Aufrufe leicht verkettet werden.</p> + +<pre class="brush: js">var p2 = new Promise(function(resolve, reject) { + resolve(1); +}); + +p2.then(function(value) { + console.log(value); // 1 + return value + 1; +}).then(function(value) { + console.log(value); // 2 +}); + +p2.then(function(value) { + console.log(value); // 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('ES2015', '#sec-promise.prototype.then', 'Promise.prototype.then')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition in einem ECMAScript-Standard.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>32</td> + <td>{{CompatGeckoDesktop(29.0)}} [1]</td> + <td>{{CompatNo}}</td> + <td>19</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile(29.0)}} [1]</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + <td>32</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Gecko 24 besitzt, unter dem Namen Future, eine experimentielle Implementation von Promise. In Gecko 25 wurde der Name final festgelegt aber standardmäßig durch die Einstellung <code>dom.promise.enabled </code>deaktiviert. Durch <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918806">Bug 918806</a> wurden Promises in Gecko 29 standardmäßig aktiviert.</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Promise.prototype.catch()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/rangeerror/index.html b/files/de/web/javascript/reference/global_objects/rangeerror/index.html new file mode 100644 index 0000000000..d66cd10c55 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/rangeerror/index.html @@ -0,0 +1,174 @@ +--- +title: RangeError +slug: Web/JavaScript/Reference/Global_Objects/RangeError +tags: + - Error + - JavaScript + - NeedsTranslation + - Object + - RangeError + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects/RangeError +--- +<div>{{JSRef}}</div> + +<p>The <code><strong>RangeError</strong></code> object indicates an error when a value is not in the set or range of allowed values.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new RangeError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Optional. Human-readable description of the error</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Optional. The name of the file containing the code that caused the exception</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Optional. The line number of the code that caused the exception</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>A <code>RangeError</code> is thrown when trying to pass a number as an argument to a function that does not allow a range that includes that number. This can be encountered when attempting to create an array of an illegal length with the {{jsxref("Array")}} constructor, or when passing bad values to the numeric methods {{jsxref("Number.toExponential()")}}, {{jsxref("Number.toFixed()")}} or {{jsxref("Number.toPrecision()")}}.</p> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt>{{jsxref("RangeError.prototype")}}</dt> + <dd>Allows the addition of properties to an <code>RangeError</code> object.</dd> +</dl> + +<h2 id="Methods">Methods</h2> + +<p>The global <code>RangeError</code> contains no methods of its own, however, it does inherit some methods through the prototype chain.</p> + +<h2 id="RangeError_instances"><code>RangeError</code> instances</h2> + +<h3 id="Properties_2">Properties</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError/prototype', 'Properties')}}</div> + +<h3 id="Methods_2">Methods</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError/prototype', 'Methods')}}</div> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_RangeError">Using <code>RangeError</code></h3> + +<pre class="brush: js">var check = function(num) { + if (num < MIN || num > MAX) { + throw new RangeError('Parameter must be between ' + MIN + ' and ' + MAX); + } +}; + +try { + check(500); +} +catch (e) { + if (e instanceof RangeError) { + // Handle range error + } +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.2', 'RangeError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-rangeerror', 'RangeError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-rangeerror', 'RangeError')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("RangeError.prototype")}}</li> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Number.toExponential()")}}</li> + <li>{{jsxref("Number.toFixed()")}}</li> + <li>{{jsxref("Number.toPrecision()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/rangeerror/prototype/index.html b/files/de/web/javascript/reference/global_objects/rangeerror/prototype/index.html new file mode 100644 index 0000000000..6dc92432bf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/rangeerror/prototype/index.html @@ -0,0 +1,128 @@ +--- +title: RangeError.prototype +slug: Web/JavaScript/Reference/Global_Objects/RangeError/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/RangeError +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>RangeError.prototype</strong></code> Eigenschaft repräsentiert den Prototypen des {{jsxref("RangeError")}} Konstruktoren.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Alle {{jsxref("RangeError")}} Instanzen erben vom <code>RangeError.prototype</code>. Man kann den Prototypen nutzen um Eigenschaften oder Methoden allen Instanzen hinzuzufügen.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>RangeError.prototype.constructor</code></dt> + <dd>Spezifiziert die Funktion welche den Prototypen einer Instanz erschaffen hat.</dd> + <dt>{{jsxref("Error.prototype.message", "RangeError.prototype.message")}}</dt> + <dd>Fehlermeldung. Obwohl ECMA-262 angibt, dass {{jsxref("RangeError")}} seine eigene <code>message </code>Eigenschaft versorgen sollte, erbt es in <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> die {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "RangeError.prototype.name")}}</dt> + <dd>Fehlername. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "RangeError.prototype.fileName")}}</dt> + <dd>Der Dateipfad verursacht diesen Fehler. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "RangeError.prototype.lineNumber")}}</dt> + <dd>Die Zeile in der Datei, bei der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "RangeError.prototype.columnNumber")}}</dt> + <dd>Die Spaltennummer der Zeile , bei der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "RangeError.prototype.stack")}}</dt> + <dd>Stack - Ablaufverfolgung. Geerbt von {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p> Obwohl das {{jsxref("RangeError")}} Prototypobjekt keine eigenen Methoden beinhaltet, beerben {{jsxref("RangeError")}} Instanzen einige Methoden durch die Prototypenkette.</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">Beschreibung</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initialdefinition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Merkmal</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Merkmal</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/reflect/apply/index.html b/files/de/web/javascript/reference/global_objects/reflect/apply/index.html new file mode 100644 index 0000000000..bc16c4d4d8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/reflect/apply/index.html @@ -0,0 +1,98 @@ +--- +title: Reflect.apply() +slug: Web/JavaScript/Reference/Global_Objects/Reflect/apply +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/apply +--- +<div>{{JSRef}}</div> + +<div>Die statische Methode <code><strong>Reflect</strong></code><strong><code>.apply()</code></strong> ruft eine Zielfunktion mit den spezifizierten Parametern auf.</div> + +<div> </div> + +<div>{{EmbedInteractiveExample("pages/js/reflect-apply.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Reflect.apply(target, thisParameter, listeDerArgumente) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>target</dt> + <dd>Die Funktion, die aufgerufen werden soll.</dd> + <dt>thisParameter</dt> + <dd>Der Wert von <code>this</code> der für den Aufruf bereitgestellt wird.</dd> + <dt>listeDerArgumente</dt> + <dd>Ein Array ähnliches Objekt welches die Parameter spezifiziert, mit denen die Zielfunktion aufgerufen wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das Resultat des Aufruft, der Zielfunktion mit dem mitgegebenen <code>this</code> und den mitgegebenen Parametern.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<p>Es wird ein {{jsxref("TypeError")}} geworfen, wenn die Zielfunktion nicht aufrufbar ist.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>In ES5, ruft man typischerweise {{jsxref("Function.prototype.apply()")}} auf, um eine Funktion aufzurufen, der man einen bestimmten <code>this</code> mitgeben und die Parameter als Array (oder einem <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">array-like object</a>) definieren möchte.</p> + +<pre class="brush: js">Function.prototype.apply.call(Math.floor, undefined, [1.75]);</pre> + +<p>Durch <code>Reflect.apply</code> wird dieses Vorhaben kürzer und ist leichter zu verstehen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_Reflect.apply()">Verwendung von <code>Reflect.apply()</code></h3> + +<pre class="brush: js">Reflect.apply(Math.floor, undefined, [1.75]); +// 1; + +Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]); +// "hello" + +Reflect.apply(RegExp.prototype.exec, /ab/, ['confabulation']).index; +// 4 + +Reflect.apply(''.charAt, 'ponies', [3]); +// "i" +</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-reflect.apply', 'Reflect.apply')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Ursprüngliche Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.apply', 'Reflect.apply')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_kompabilität">Browser kompabilität</h2> + + + +<p>{{Compat("javascript.builtins.Reflect.apply")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li>{{jsxref("Function.prototype.apply()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/reflect/construct/index.html b/files/de/web/javascript/reference/global_objects/reflect/construct/index.html new file mode 100644 index 0000000000..29da55d15b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/reflect/construct/index.html @@ -0,0 +1,157 @@ +--- +title: Reflect.construct() +slug: Web/JavaScript/Reference/Global_Objects/Reflect/construct +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/construct +--- +<div>{{JSRef}}</div> + +<div>Die statische Methode <code><strong>Reflect</strong></code><strong><code>.construct()</code></strong> verhält sich wie der <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a>, allerdings in Form einer Funktion.</div> + +<div>Sie ist das Equivalent zu <code>new target(...args)</code>. Es existiert zudem die Option, einen anderen Prototyp zu definieren.</div> + +<div> </div> + +<div>{{EmbedInteractiveExample("pages/js/reflect-construct.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Reflect.construct(target, listeDerArgumente[, newTarget]) +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>target</dt> + <dd>Die Funktion, die aufgerufen werden soll.</dd> + <dt>listeDerArgumente</dt> + <dd>Ein Array ähnliches Objekt welches die Parameter spezifiziert, mit denen die Zielfunktion aufgerufen wird.</dd> + <dt><code>newTarget</code> {{optional_inline}}</dt> + <dd>Der Construktor dessen Typ genutzt werden soll. Siehe auch den <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a></code> Operator. Wenn <code>newTarget</code> nicht existiert, ist es <code>target</code>.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine neue Instanz des <code>target</code> (oder <code>newTarget</code>, wenn vorhanden), Initialisiert durch das <code>target</code> als Konstruktor mit den gegebenen Parametern.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<p>Es wird ein {{jsxref("TypeError")}} geworfen, Wenn <code>target</code> or <code>newTarget</code> keine Konstruktoren sind.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>Reflect.construct</code> erlaubt es dir, einen Konstruktor mit einer variablen Anzahl von Parametern aufzurufen. (Was auch möglich ist, bai Verwendung des <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a> in Kombination mit dem <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new operator</a>).</p> + +<pre class="brush: js">var obj = new Foo(...args); +var obj = Reflect.construct(Foo, args); +</pre> + +<p> </p> + +<h3 id="Reflect.construct()_vs_Object.create()"><code>Reflect.construct()</code> vs <code>Object.create()</code></h3> + +<p>Befor wir mit der Einführung von <code>Reflect</code> beginnen. Objekte können durch von <code>Object.create()</code> mithilfe einer beliebigen Kombination aus Konstruktor und Prototyp erstellt werden.</p> + +<pre class="brush: js">function OneClass() { + this.name = 'one'; +} + +function OtherClass() { + this.name = 'other'; +} + +// Calling this: +var obj1 = Reflect.construct(OneClass, args, OtherClass); + +// ...has the same result as this: +var obj2 = Object.create(OtherClass.prototype); +OneClass.apply(obj2, args); + +console.log(obj1.name); // 'one' +console.log(obj2.name); // 'one' + +console.log(obj1 instanceof OneClass); // false +console.log(obj2 instanceof OneClass); // false + +console.log(obj1 instanceof OtherClass); // true +console.log(obj2 instanceof OtherClass); // true +</pre> + +<p>Obwohl das Endergebnis das gleiche ist, gibt es einen wichtigen Unterschied im Prozess.</p> + +<p>Wenn <code>Object.create()</code> und <code>Function.prototype.apply()</code> verwendet werden, zeigt der <code>new.target</code> Operator innerhalb der als Konstruktor verwendeten Funktion auf <code>undefined</code>, da das <code>newTarget</code> nicht zum Erstellen des Objekts verwendet wird.</p> + +<p>Wenn Sie dagegen <code>Reflect.construct()</code> aufrufen, zeigt der <code>new.target</code> Operator auf den <code>newTarget</code> Parameter, sofern angegeben und auf <code>target</code>, falls nicht.</p> + +<pre class="brush: js">function OneClass() { + console.log('OneClass'); + console.log(new.target); +} +function OtherClass() { + console.log('OtherClass'); + console.log(new.target); +} + +var obj1 = Reflect.construct(OneClass, args); +// Output: +// OneClass +// function OneClass { ... } + +var obj2 = Reflect.construct(OneClass, args, OtherClass); +// Output: +// OneClass +// function OtherClass { ... } + +var obj3 = Object.create(OtherClass.prototype); +OneClass.apply(obj2, args); +// Output: +// OneClass +// undefined</pre> + +<p> </p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_Reflect.construct()">Verwendung <code>Reflect.construct()</code></h3> + +<pre class="brush: js">var d = Reflect.construct(Date, [1776, 6, 4]); +d instanceof Date; // true +d.getFullYear(); // 1776 +</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-reflect.construct', 'Reflect.construct')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Ursprüngliche Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect.construct', 'Reflect.construct')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_kompabilität">Browser kompabilität</h2> + + + +<p>{{Compat("javascript.builtins.Reflect.construct")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Reflect")}}</li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a></code></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/reflect/index.html b/files/de/web/javascript/reference/global_objects/reflect/index.html new file mode 100644 index 0000000000..3ba358f140 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/reflect/index.html @@ -0,0 +1,88 @@ +--- +title: Reflect +slug: Web/JavaScript/Reference/Global_Objects/Reflect +translation_of: Web/JavaScript/Reference/Global_Objects/Reflect +--- +<div>{{JSRef}}</div> + +<div>Reflect ist ein Standardobjekt, das Methoden für abfangfähige JavaScript-Operationen bereitstellt.</div> + +<div>Die Methoden entsprechen denen des <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler">proxy handlers</a>.</div> + +<div><code>Reflect</code> ist kein Funktionsobjekt und verfügt daher über keinen Konstruktor.</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Im Gegensatz zu den meisten globalen Objekten hat <code>Reflect</code> keinen Konstruktor. Sie können es nicht mit einem <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a> verwenden, oder <code>Reflect</code> als Funktion aufrufen.</p> + +<p>Alle Eigenschaften und Methoden von <code>Reflect</code> sind statisch (wie bei {{jsxref("Math")}}).</p> + +<h2 id="Methoden">Methoden</h2> + +<p>Das <code>Reflect</code>-Objekt stellt die folgenden statischen Funktionen bereit, die dieselben Namen haben wie die Methoden des <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler">proxy handler</a>. Einige dieser Methoden sind exakt die selben wie bei entsprechenden Methoden des {{jsxref("Object")}}.</p> + +<dl> + <dt>{{jsxref("Reflect.apply()")}}</dt> + <dd>Ruft eine Zielfunktion mit Argumenten auf, die Argumente werden im Parameter args angegeben. Siehe auch {{jsxref("Function.prototype.apply()")}}.</dd> + <dt>{{jsxref("Reflect.construct()")}}</dt> + <dd> Der <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a> als Funktion. Equivalent zu <code>new target(...args)</code>. Bietet die optionale Möglichkeit, einen anderen Prototyp anzugeben.</dd> + <dt>{{jsxref("Reflect.defineProperty()")}}</dt> + <dd>Ähnlich zu {{jsxref("Object.defineProperty()")}}. Gibt einen {{jsxref("Boolean")}} zurück.</dd> + <dt>{{jsxref("Reflect.deleteProperty()")}}</dt> + <dd>Der <a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete"><code>delete</code> operator</a> als Funktion. Ähnlich zu dem Aufruf <code>delete target[name]</code>.</dd> + <dt>{{jsxref("Reflect.get()")}}</dt> + <dd>Eine Funktion, die den Wert von Eigenschaften/Properties zurückgibt.</dd> + <dt>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</dt> + <dd>Ähnlich zu {{jsxref("Object.getOwnPropertyDescriptor()")}}. Gibt einen Eigenschaftsdeskriptor der angegebenen Eigenschaft, oder {{jsxref("undefined")}} zurück.</dd> + <dt>{{jsxref("Reflect.getPrototypeOf()")}}</dt> + <dd>Gleich wie {{jsxref("Object.getPrototypeOf()")}}.</dd> + <dt>{{jsxref("Reflect.has()")}}</dt> + <dd>Der <a href="/en-US/docs/Web/JavaScript/Reference/Operators/in"><code>in</code> operator</a> als Funktion. Gibt einen booleschen Wert zurück, der angibt, ob eine eigene oder geerbte Eigenschaft vorhanden ist.</dd> + <dt>{{jsxref("Reflect.isExtensible()")}}</dt> + <dd>Gleich wie {{jsxref("Object.isExtensible()")}}.</dd> + <dt>{{jsxref("Reflect.ownKeys()")}}</dt> + <dd>Gibt ein Array der eigenen (nicht geerbten) Eigenschaftsschlüssel des Zielobjekts zurück.</dd> + <dt>{{jsxref("Reflect.preventExtensions()")}}</dt> + <dd>Ähnlich zu {{jsxref("Object.preventExtensions()")}}. Gibt einen {{jsxref("Boolean")}} zurück.</dd> + <dt>{{jsxref("Reflect.set()")}}</dt> + <dd>Eine Funktion, die den Eigenschaften/Properties Werte zuweist. Gibt einen {{jsxref("Boolean")}} zurück, der <code>true</code> ist, wenn die Zuweisung erfolgreich verlief.</dd> + <dt>{{jsxref("Reflect.setPrototypeOf()")}}</dt> + <dd> + <p>Eine Funktion, die den Prototyp eines Objekts festlegt<span style="font-size: 1rem; letter-spacing: -0.00278rem;">.</span></p> + </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('ES2015', '#sec-reflect-object', 'Reflect')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Ursprüngliche Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-reflect-object', 'Reflect')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Reflect.enumerate wurde entfernt.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_kompatiblität">Browser kompatiblität</h2> + + + +<p>{{Compat("javascript.builtins.Reflect")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>Das globale {{jsxref("Proxy")}} Objekt.</li> + <li>Das {{jsxref("Proxy.handler", "handler")}} Objekt.</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/regexp/flags/index.html b/files/de/web/javascript/reference/global_objects/regexp/flags/index.html new file mode 100644 index 0000000000..65956f3c3b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/regexp/flags/index.html @@ -0,0 +1,83 @@ +--- +title: RegExp.prototype.flags +slug: Web/JavaScript/Reference/Global_Objects/RegExp/flags +tags: + - ECMAScript 2015 + - Eigenschaft + - JavaScript + - Prototyp + - Referenz + - RegExp + - Regular Expressions + - Reguläre Expressionen +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/flags +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>flags</code></strong> Eigenschaft gibt einen String mit den Flags des RegExp-Objektes zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-flags.html")}}</div> + +<p class="hidden">Der Code für dieses interaktive Beispiel ist in einem GitHub Repository gespeichert. Wenn du etwas zum Interaktiven-Beispiel-Project beitragen möchtest, klone bitte <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und sende uns Pull-Requests.</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Flags in der <code>flags</code> Eigenschaft sind alphabetisch sortiert (von links nach rechts, z.B. <code>"gimuy"</code>).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Die_flags_benutzen">Die <code>flags</code> benutzen</h3> + +<pre class="brush: js">/foo/ig.flags; // "gi" +/bar/myu.flags; // "muy" +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (RegExp.prototype.flags === undefined) { + Object.defineProperty(RegExp.prototype, 'flags', { + configurable: true, + get: function() { + return this.toString().match(/[gimuy]*$/)[0]; + } + }); +} +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-get-regexp.prototype.flags', 'RegExp.prototype.flags')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initielle Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.flags', 'RegExp.prototype.flags')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatiblität">Browser-Kompatiblität</h2> + +<div> +<div class="hidden">Die Kompatiblitäts-Tabelle auf dieser Seite ist generiert von strukturierter Daten. Wenn du etwas dazu beitragen möchtest, solltest du dir <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> anschauen und uns Pull-Requests schicken.</div> + +<p> {{Compat("javascript.builtins.RegExp.flags")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("RegExp.prototype.source")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/regexp/index.html b/files/de/web/javascript/reference/global_objects/regexp/index.html new file mode 100644 index 0000000000..9639ba265f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/regexp/index.html @@ -0,0 +1,560 @@ +--- +title: RegExp +slug: Web/JavaScript/Reference/Global_Objects/RegExp +tags: + - JavaScript + - Klasse + - Referenz + - RegExp + - Reguläre Ausdrücke +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +--- +<p>{{JSRef}}</p> + +<p>Der <code><strong>RegExp</strong> constructor</code> erstellt ein Objekt mit regulären Werten, um diese dann als Muster an einem Text anzuwenden.</p> + +<p>Für eine Einführung über reguläre Ausdrücke, lies das <a href="/en-US/docs/JavaScript/Guide/Regular_Expressions">Kapitel Regular Expressions im JavaScript Guide</a> (englisch).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><code>/<em>muster</em>/<em>flags</em></code> + +<code>RegExp(<em>muster</em> <em>[, flags]</em>)</code> +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>muster</code></dt> + <dd>Text des regulären Ausdrucks.</dd> + <dt><code>flags</code></dt> + <dd> + <p>Optional, flags kann eine Zeichenkette mit einer beliebige Kombination folgender Werte sein:</p> + + <dl> + <dt><code>g</code></dt> + <dd>globale Suche (nach einem Treffer fortsetzen)</dd> + <dt><code>i</code></dt> + <dd>Groß-/Kleinschreibung ignorieren</dd> + <dt><code>m</code></dt> + <dd>multiline; behandelt den Suchkontext als Mehrfachzeilen, d.h. Anfang- und Endeanker (^ und $) entsprechen dem Anfang bzw. Ende <em>jeder einzelnen</em> Zeile (begrenzt durch \n oder \r), nicht nur dem Anfang und Ende der gesamten zu durchsuchenden Zeichenkette.</dd> + <dt><code>y</code> {{Fx_minversion_inline(3)}} {{non-standard_inline}}</dt> + <dd>sticky; matches only from the index indicated by the <code>lastIndex</code> property of this regular expression in the target string (and does not attempt to match from any later indexes). This allows the match-only-at-start capabilities of the character "^" to effectively be used at any location in a string by changing the value of the <code>lastIndex</code> property.</dd> + </dl> + </dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Es bestehen zwei Möglichkeiten, ein RegExp-Objekt zu erzeugen: Eine literale Notation und ein Konstruktor. In der literaren Version werden im Gegensatz zu der Konstruktorversion keine Anführungszeichen verwendet, um Zeichenketten zu kennzeichnen. Dementsprechend erzeugen beide der folgenden Zeilen den gleichen regulären Ausdruck:</p> + +<pre class="brush: js notranslate">/ab+c/i; +new RegExp("ab+c", "i"); +</pre> + +<p>Die literale Notation stellt eine Kompilierung des regulären Ausdrucks während der Auswertung des Ausdrucks bereit. Nutzen Sie die literale Notation, wenn der reguläre Ausdruck unverändert bleiben wird. Wenn Sie zum Beispiel die literale Notation für die Erzeugung eines regulären Ausdruck verwenden, um ihn in einer Schleife zu anzuwenden, wird der reguläre Ausdruck nicht in jedem Schleifendurchlauf rekompiliert.</p> + +<p>Der Konstruktor des RegExp-Objekts, z.B. <code>new RegExp("ab+c")</code>, stellt eine Laufzeitkompilierung des regulären Ausdrucks bereit. Nutzen Sie die Konstruktor-Funktion, wenn sich das reguläre Suchmuster ändern wird oder Sie das Muster nicht kennen und es aus einer anderen Quelle wie z.B. einer Benutzereingabe beziehen.</p> + +<p>Bei Verwendung der Konstruktor-Funktion sind die normalen Zeichenfolgenmaskierungsregeln (Voranstellen eines Rückwärtsschrägstrichs (\) vor Sonderzeichen innerhalb von Zeichenketten) einzuhalten. Zum Beispiel sind folgende Zeilen äquivalent:</p> + +<pre class="brush: js notranslate">var re = /\w+/; +var re = new RegExp("\\w+"); +</pre> + +<h2 id="Bedeutung_spezieller_Zeichen_in_regulären_Ausdrücken">Bedeutung spezieller Zeichen in regulären Ausdrücken</h2> + +<ul> + <li><a href="#Zeichenklassen">Zeichenklassen</a></li> + <li><a href="#Zeichenauswahl">Zeichenauswahl</a></li> + <li><a href="#Bereichsgrenzen">Bereichsgrenzen</a></li> + <li><a href="#Gruppierung-und-Rueckwaertsreferenz">Gruppierung und Rückwärtsreferenzen</a></li> + <li><a href="#Quantoren">Quantoren</a></li> +</ul> + +<table class="fullwidth-table"> + <tbody> + <tr id="character-classes"> + <th colspan="2"><a name="Zeichenklassen">Zeichenklassen</a></th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>.</code></td> + <td> + <p>(Punkt, Satzendezeichen) stimmt mit jedem Einzelzeichen <em>außer</em> den Zeilenvorschub- und Wagenrücklaufzeichen (<code>\n</code> <code>\r</code> <code>\u2028</code> oder <code>\u2029</code>) überein.</p> + + <p>Zu beachten ist, dass das <code>m</code> <em>multiline flag</em> nicht das Punktverhalten verändert. Um ein Musterentsprechung über mehrere Zeilen hinweg zu erreichen, kann die leere negative Zeichenauswahl <code>[^]</code> verwendet werden, sie stimmt mit jedem Zeichen einschließlich Zeilenumbrüchen überein.</p> + + <p><code>/.y/</code> passt z.B. auf "my" und "ay", nicht aber auf "yes" in "yes make my day".</p> + </td> + </tr> + <tr> + <td><code>\d</code></td> + <td> + <p>Stimmt mit einer arabischen Ziffer überein. Äquivalent zu <code>[0-9]</code>.</p> + + <p><code>/\d/</code> or <code>/[0-9]/</code> passt z.B. auf '2' in "B2 ist die Zimmernummer."</p> + </td> + </tr> + <tr> + <td><code>\D</code></td> + <td> + <p>Stimmt mit jedem Zeichen überein, das keine arabische Ziffer ist. Äquivalent zu <code>[^0-9]</code>.</p> + + <p><code>/\D/</code> or <code>/[^0-9]/</code> passt z.B. auf 'B' in "B2 ist die Zimmernummer."</p> + </td> + </tr> + <tr> + <td><code>\w</code></td> + <td> + <p>Stimmt mit einem alphanumerischen Zeichen (Wortzeichen) einschließlich dem Unterstrich überein. Äquivalent zu <code>[A-Za-z0-9_]</code>.</p> + + <p><code>/\w/</code> passt zum Beispiel auf 'A' in "Apfel", '5' in "€5,28," und '3' in "3D."</p> + </td> + </tr> + <tr> + <td><code>\W</code></td> + <td> + <p>Stimmt mit jedem Zeichen überein, das kein alphanumerisches Zeichen (Wortzeichen) ist. Äquivalent zu <code>[^A-Za-z0-9_]</code>.</p> + + <p><code>/\W/</code> or <code>/[^A-Za-z0-9_]/</code> passt z.B. auf '%' in "50%."</p> + </td> + </tr> + <tr> + <td><code>\s</code></td> + <td> + <p>Stimmt mit einem einzelnen Leerraumzeichen überein (Leerzeichen, Tabulator, Seitenvorschub, Zeilenvorschub und weitere Unicode-Zeichen). Äquivalent zu <code>[ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004 \u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f \u3000]</code>.</p> + + <p><code>/\s\w*/</code> passt z.B. auf ' bar' in "foo bar."</p> + </td> + </tr> + <tr> + <td><code>\S</code></td> + <td> + <p>Stimmt mit einem einzelnen Zeichen überein, das kein Leerraumzeichen ist. (Nicht-Leerraumzeichen).<br> + Äquivalent zu <code>[^\s]</code> und zu <code>[^ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004 \u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f \u3000]</code>.</p> + + <p><code>/\S\w*/</code> passt z.B. auf 'foo' in "foo bar."</p> + </td> + </tr> + <tr> + <td><code>\t</code></td> + <td>Stimmt mit einem Tabulatorzeichen überein.</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>Stimmt mit einem Wagenrücklaufzeichen überein.</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>Stimmt mit einem Zeilenvorschub überein.</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>Stimmt mit einem vertikalen Tabulatorzeichen überein.</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>Stimmt mit einem Seitenvorschub überein.</td> + </tr> + <tr> + <td><code>[\b]</code></td> + <td> + <p>Stimmt mit einem Rücklöschzeichen (Backspace) überein. (Nicht zu verwechseln mit <code>\b</code>)</p> + </td> + </tr> + <tr> + <td><code>\0</code></td> + <td>Stimmt mit einem NUL-Zeichen überein. (Keine weiteren Ziffern dürfen folgen!)</td> + </tr> + <tr> + <td><code>\c<em>X</em></code></td> + <td> + <p>Wobei <code><em>X</em></code> ein Buchstabe von A - Z ist. Stimmt mit einem Steuerzeichen überein.</p> + + <p><code>/\cM/</code> passt z.B. auf Steuerung-M in einer Zeichenkette.</p> + </td> + </tr> + <tr> + <td><code>\x<em>hh</em></code></td> + <td> + <p>Stimmt mit einem Zeichen mit dem Code <code><em>hh</em></code> (zwei hexadezimale Ziffern) überein.</p> + + <p>/foo\x20bar/ passt z.B. auf 'o b' in "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\u<em>hhhh</em></code></td> + <td>Stimmt mit einem Zeichen mit dem Unicode <code><em>hhhh</em></code> (vier hexadezimale Ziffern) überein.</td> + </tr> + <tr> + <td><code>\</code></td> + <td> + <p>Bei einem Zeichen, das normalerweise als Literal behandelt wird, signalisiert ein vorangestellter Rückschrägstrich, dass es als Spezialzeichen und nicht als Literal zu interpretieren ist.</p> + + <p>Z.B. passt <code>/b/</code> auf das Zeichen <code>'b'</code>. Durch Voranstellen des Rückschrägstriches vor das "b", also <code>/\b/</code>, bekommt das Zeichen eine besondere Bedeutung und passt auf eine Wordgrenze.</p> + + <p><em>oder</em></p> + + <p>Bei einem Zeichen, das normalerweise als Zeichen mit spezieller Bedeutung interpretiert wird, signalisiert ein vorangestellter Rückschrägstrich, dass es ohne besondere Bedeutung als Literal interpretiert werden soll.</p> + + <p>Zum Beispiel ist * Quantor-Spezialzeichen, das eine Übereinstimmung mit null oder mehreren Vorkommen des vorausgehenden Zeichens bedeutet; z.B. bedeutet <code>/a*/</code> eine Übereinstimmung von null oder mehr "a"s. Um dem "<code>*"</code> als Literal zu entsprechen, wird ein Rückschrägstrich vorangestellt; z.B. passt <code>/a\*/</code> auf 'a*'.</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="character-sets"> + <th colspan="2"> + <p><a name="Zeichenauswahl">Zeichenauswahl</a></p> + </th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>[xyz]</code></td> + <td> + <p>Zeichenauswahl, stimmt mit einem Beliebigen der eingeschlossenen Zeichen überein. Mittels eines Bindestriches kann ein Bereich von Zeichen angegeben werden.</p> + + <p><code>[abcd]</code> ist gleichbedeutend mit<code>[a-d]</code> und passt auf 'b' in "brisket" und 'c' in "chop".</p> + </td> + </tr> + <tr> + <td><code>[^xyz]</code></td> + <td> + <p>Eine negative bzw. komplementäre Zeichenauswahl. Das bedeutet eine Übereinstimmung mit jedem Zeichen, das <em>nicht</em> in den eckigen Klammern eingeschlossen ist. Mittels eines Bindestriches kann ein Bereich von Zeichen angegeben werden.</p> + + <p>Zum Beispiel ist <code>[^abc]</code> gleichbedeutend mit<code> [^a-c]</code>. Beides passt auf 'o' in "bacon" und 'h' in "chop."</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="boundaries"> + <th colspan="2"><a name="Bereichsgrenzen">Bereichsgrenzen</a></th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>^</code></td> + <td> + <p>Stimmt mit dem Anfang eines Subjekts und, wenn das <em>multiline flag</em> gesetzt ist, auch mit der Stelle unmittelbar nach einem Zeilenumbruchzeichen überein.</p> + + <p><code>/^E/</code> passt z.B. nicht auf 'E' in "ein E" aber auf das erste 'E' in "Ein E."</p> + </td> + </tr> + <tr> + <td><code>$</code></td> + <td> + <p>Stimmt mit dem Ende eines Subjekts und, wenn das <em>multiline flag</em> gesetzt ist, auch mit der Stelle unmittelbar vor einem Zeilenumbruchzeichen überein.</p> + + <p><code>/t$/</code> passt z.B. auf das 't' in "Brot", nicht aber in "Brote".</p> + </td> + </tr> + <tr> + <td><code>\b</code></td> + <td> + <p>Stimmt mit einer null-breiten Wortgrenze wie zwischen einem Buchstaben und einem Leerzeichen überein. (Nicht zu verwechseln mit der Zeichenklasse <code>[\b]</code>)</p> + + <p><code>/\bno/</code> passt z.B. auf 'no' in "at noon"; <code>/ly\b/</code> passt auf 'ly' in "possibly yesterday."</p> + </td> + </tr> + <tr> + <td><code>\B</code></td> + <td> + <p>Stimmt mit einer null-breiten Nichtwortgrenze wie zwischen zwei Buchstaben oder zwischen zwei Leerzeichen überein.</p> + + <p><code>/\Bon/</code> passt z.B. auf 'on' in "at noon" und <code>/ye\B/</code> passt auf 'ye' in "possibly yesterday."</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="grouping-back-references"> + <th colspan="2"><a name="Gruppierung-und-Rueckwaertsreferenz">Gruppierung und Rückwärtsreferenz</a></th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>(<em>x</em>)</code></td> + <td> + <p>Stimmt mit <code><em>x</em></code> überein und speichert die Übereinstimmung. Dies wird auch <em>capturing parentheses</em> (engl., aufzeichnende Klammern) genannt.</p> + + <p><code>/(foo)/</code> passt z.B. auf 'foo' in "foo bar" und speichert die Übereinstimmung. Aufgezeichnete Teilzeichenketten können aus den Elementen <code>[1], ..., [n]</code> des Ergebnisfelds (Array) oder den Eigenschaften <code>$1, ..., $9</code> des vordefinierten <code>RegExp</code>-Objekts ausgelesen werden.</p> + + <p>Aufzeichnende Gruppierungen führen zu Performanzeinbußen. Wenn die übereinstimmenden Teilzeichenketten nicht wiederverwendet werden müssen, sind nicht aufzeichnende Klammern zu bevorzugen (siehe weiter unten).</p> + </td> + </tr> + <tr> + <td><code>\<em>n</em></code></td> + <td> + <p>Wobei <code><em>n</em></code> eine positive Ganzzahl ist. Ein Rückbezug auf die zuletzt gefundene Teilzeichenkette, die der Übereinstimmung mit der n-ten runden Klammer im regulären Ausdruck entspricht (öffnende Klammern gezählt).</p> + + <p><code>/apple(,)\sorange\1/</code> passt z.B. auf 'apple, orange,' in "apple, orange, cherry, peach." und zeichnet das Komma auf. Ein umfassenderes Beispiel folgt im Anschluss an diese Tabelle.</p> + </td> + </tr> + <tr> + <td><code>(?:<em>x</em>)</code></td> + <td>Stimmt mit <code><em>x</em></code> überein, speichert die Übereinstimmung aber nicht, auch <em>non-capturing parentheses</em> genannt. Auf die übereinstimmende Teilzeichenkette kann nicht mittels der Elemente <code>[1], ..., [n]</code> des Arrays oder der vordefinierten Eigenschaften <code>$1, ..., $9 </code>des <code>RegExp</code>-Objekts zugegriffen werden .</td> + </tr> + </tbody> + <tbody> + <tr id="quantifiers"> + <th colspan="2"><a name="Quantoren">Quantoren</a></th> + </tr> + <tr> + <th>Zeichen</th> + <th>Bedeutung</th> + </tr> + <tr> + <td><code>*</code></td> + <td> + <p>Stimmt mit dem null- oder mehrmaligen Vorkommen des voranstehenden Zeichen überein.</p> + + <p><code>/bo*/</code> passt z.B. auf 'boooo' in "A ghost booooed" und 'b' in "A bird warbled", aber auf nichts in "A goat grunted".</p> + </td> + </tr> + <tr> + <td><code>+</code></td> + <td> + <p>Stimmt mit dem ein- oder mehrmaligen Vorkommen des voranstehenden Zeichen überein. Äquivalent zu <code>{1,}</code></p> + + <p><code>/ca+/</code> passt z.B. auf 'ca' in "candy" und 'caaa' in "caaandy" aber auf nichts in "cindy".</p> + </td> + </tr> + <tr> + <td><code>*?</code><br> + <code>+?</code></td> + <td> + <p>Passt wie <code>*</code> und<code>+</code> weiter oben, aber der Ausdruck ist nicht gierig, d.h. er passt auf die kürzestmögliche Übereinstimmung.</p> + + <p><code>/_.*?_/</code> passt z.B. auf "_foo_" in "_foo_ _bar_" aber nicht auf "_foo_ _bar_" wie der Ausdruck ohne dem <code>?</code> hinterm <code>*</code>.</p> + </td> + </tr> + <tr> + <td><code>?</code></td> + <td> + <p>Stimmt mit dem null- oder einmaligen Vorkommen des voranstehenden Zeichens überein.</p> + + <p><code>/e?le?/</code> passt z.B. auf das 'el' in "angel" und auf das 'le' in "angle."</p> + + <p>If used immediately after any of the quantifiers <code>*</code>, <code>+</code>, <code>?</code>, or <code>{}</code>, makes the quantifier non-greedy (matching the minimum number of times), as opposed to the default, which is greedy (matching the maximum number of times).</p> + + <p>Das Fragezeichen wird auch in lookahead assertions verwendet, welche unter <code>(?=)</code>, <code>(?!)</code>, sowie <code>(?:)</code> in dieser Tabelle beschrieben sind.</p> + </td> + </tr> + <tr> + <td><code><em>x</em>(?=<em>y</em>)</code></td> + <td>Passt nur auf <code><em>x</em></code>, wenn <code><em>y</em></code> darauf folgt. Zum Beispiel passt <code>/Jack(?=Sprat)/</code> nur auf 'Jack', wenn danach 'Sprat' folgt. <code>/Jack(?=Sprat|Frost)/</code> passt nur auf 'Jack', wenn 'Sprat' oder 'Frost' folgt. Allerdings ist weder 'Sprat' noch 'Frost' Teil der Übereinstimmungsresultate.</td> + </tr> + <tr> + <td><code><em>x</em>(?!<em>y</em>)</code></td> + <td> + <p>Passt nur auf <code><em>x</em></code>, wenn darauf nicht <code><em>y</em></code> folgt. <code>/\d+(?!\.)/</code> z.B. stimmt nur mit einer Zahl überein, sofern kein Dezimalpunkt folgt.</p> + + <p><code>/\d+(?!\.)/.exec("3.141")</code> passt auf 141, aber nicht auf 3.</p> + </td> + </tr> + <tr> + <td><code><em>x</em>|<em>y</em></code></td> + <td> + <p>Passt entweder auf <code><em>x</em></code> oder <code><em>y</em></code>.</p> + + <p><code>/green|red/</code> passt z.B. auf 'green' in "green apple" und auf 'red' in "red apple."</p> + </td> + </tr> + <tr> + <td><code>{<em>n</em>}</code></td> + <td> + <p>Wobei <code><em>n</em></code> eine positive Ganzzahl ist. Stimmt mit genau <code><em>n</em></code> Vorkommen des vorausgehenden Zeichens oder Teilausdrucks überein.</p> + + <p><code>/a{2}/</code> passt z.B. auf beide 'a' in "caandy" und die ersten beiden 'a' in "caaandy", nicht aber auf das 'a' in "candy".</p> + </td> + </tr> + <tr> + <td><code>{<em>n</em>,}</code></td> + <td> + <p>Wobei <code><em>n</em></code> eine positive Ganzzahl ist. Stimmt mit mindestens <code><em>n</em></code> Vorkommen des vorausgehenden Zeichens oder Teilausdrucks überein.</p> + + <p><code>/a{2,}/</code> passt z.B. auf alle 'a' in "caandy" und in "caaaaaaandy.", nicht aber auf das 'a' in "candy".</p> + </td> + </tr> + <tr> + <td><code>{<em>n</em>,<em>m</em>}</code></td> + <td> + <p>Wobei <code><em>n</em></code> und <code><em>m</em></code> positive Ganzzahlen sind. Stimmt mit mindestens <code><em>n</em></code> und höchstens <code><em>m</em></code> Vorkommen des vorausgehenden Zeichens oder Teilausdrucks überein.</p> + + <p><code>/a{1,3}/</code> passt z.B. auf nichts in "cndy", das 'a' in "candy," die beiden 'a' in "caandy," und die ersten drei 'a' in "caaaaaaandy". Es ist zu beachten, dass bei der Übereinstimmung in "caaaaaaandy" der Treffer "aaa" ist, obwohl in der Originalzeichenkette mehr 'a' vorhanden wären.</p> + </td> + </tr> + </tbody> +</table> + +<h3 id="Fußnoten">Fußnoten</h3> + +<ol> + <li>{{endnote("equivalent_s")}}Equivalent to: + <p><code>[\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]</code></p> + </li> + <li>{{endnote("equivalent_S")}}Equivalent to: + <p><code>[^\t\n\v\f\r \u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000]</code></p> + </li> +</ol> + +<h3 id="Eigenschaften">Eigenschaften</h3> + +<dl> + <dt><a href="/en-US/docs/JavaScript/Reference/Global_Objects/RegExp/prototype" title="JavaScript/Reference/Global_Objects/RegExp/prototype">prototype</a></dt> + <dd>Erlaubt das Hinzufügen von Eigenschaften zu allen Objekten</dd> +</dl> + +<div>{{jsOverrides("Function", "Properties", "prototype")}}</div> + +<h3 id="Methoden">Methoden</h3> + +<p>Das globale <code>RegExp</code> Objekt hat keine eigenen Methoden. Es erbt allerdings manche Methoden durch die Prototypenkette.{{jsOverrides("Function", "Methods", "prototype")}}</p> + +<h2 id="RegExp-Instanzen"><code>RegExp</code>-Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('en/JavaScript/Reference/Global_Objects/RegExp/prototype','Properties')}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<div>{{page('en/JavaScript/Reference/Global_Objects/RegExp/prototype','Methods')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Beispiel_Anwendung_regulären_Ausdrucks_zur_Datenformatänderung">Beispiel: Anwendung regulären Ausdrucks zur Datenformatänderung</h3> + +<p>Das folgende Script nutzt die <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/String/replace" title="JavaScript/Reference/Global_Objects/String/replace">replace</a></code> Methode und nutzt die vererbte <a href="/en-US/docs/JavaScript/Reference/Global_Objects/String" title="JavaScript/Reference/Global_Objects/String">String</a> Instanz <code>(re)</code> um als Rückgabewert eine Übereinstimmung des Namens <code>(str) </code>in dem Format <em>erster, letzter </em>und im Format <em>letzter</em>, <em>erster </em>zu finden. In dem zu ersetzenden Text nutzt das Script $1 und $2 um das Ergebnis der übereinstimmenden Treffer in der Klammer als Muster des regulären Ausdrucks.</p> + +<pre class="brush: js notranslate">var re = /(\w+)\s(\w+)/; +var str = "John Smith"; +var newstr = str.replace(re, "$2, $1"); +print(newstr);</pre> + +<p>Das ergibt: "Smith, John".</p> + +<h3 id="Beispiel_Anwendung_eines_regulären_Ausdrucks_auf_mehrzeilige_Texte">Beispiel: Anwendung eines regulären Ausdrucks auf mehrzeilige Texte</h3> + +<pre class="brush: js notranslate">var s = "Please yes\nmake my day!"; +s.match(/yes.*day/); +// Returns null +s.match(/yes[^]*day/); +// Returns 'yes\nmake my day' +</pre> + +<h3 id="Beispiel_Anwendung_eines_regulären_Ausdrucks_mit_dem_sticky_flag">Beispiel: Anwendung eines regulären Ausdrucks mit dem "sticky" flag</h3> + +<p>Dieses Beispiel zeigt, wie man die feste Kennzeichung (<code>sticky flag</code>) an reguläre Ausdrücke nutzt, um Übereinstimmungen von individuelle Treffer von mehrzeigen Eingaben zu erhalten.</p> + +<pre class="brush: js notranslate">var text = "First line\nSecond line"; +var regex = /(\S+) line\n?/y; + +var match = regex.exec(text); +print(match[1]); // prints "First" +print(regex.lastIndex); // prints 11 + +var match2 = regex.exec(text); +print(match2[1]); // prints "Second" +print(regex.lastIndex); // prints "22" + +var match3 = regex.exec(text); +print(match3 === null); // prints "true"</pre> + +<p>One can test at run-time whether the sticky flag is supported, using <code>try { … } catch { … }</code>. For this, either an <code>eval(…)</code> expression or the <code>RegExp(<var>regex-string</var>, <var>flags-string</var>)</code> syntax must be used (since the <code>/<var>regex</var>/<var>flags</var></code> notation is processed at compile-time, so throws an exception before the <code>catch</code> block is encountered). For example:</p> + +<pre class="brush: js notranslate">var supports_sticky; +try { RegExp('','y'); supports_sticky = true; } +catch(e) { supports_sticky = false; } +alert(supports_sticky); // alerts "true"</pre> + +<h3 id="Beispiel_Regulärer_Ausdruck_und_Unicode-Zeichen">Beispiel: Regulärer Ausdruck und Unicode-Zeichen</h3> + +<p>Wie oben erwähnt treffen Übereinstimmugnen mit <code>\w</code> or <code>\W</code> nur ASCII basierende Zeichen; als Beispiel: 'a' bis 'z', 'A' bis 'Z', 0 bis 9 und '_'. Um Übereinstimmungen für Zeichensätze anderer Sprachen wie Kyrillisch oder Hebräisch zu erzielen, nutze <code>\uhhhh</code>., während "hhhh" den Unicode-Wert des Zeichensatzes in Hexadezimal angibt. Dieses Beispiel demonstriert wie man Unicode-Zeichen aus einem Wort erhält:</p> + +<pre class="brush: js notranslate">var text = "Образец text на русском языке"; +var regex = /[\u0400-\u04FF]+/g; + +var match = regex.exec(text); +print(match[0]); // prints "Образец" +print(regex.lastIndex); // prints "7" + +var match2 = regex.exec(text); +print(match2[0]); // prints "на" [did not print "text"] +print(regex.lastIndex); // prints "15" + +// and so on</pre> + +<p>Hier ist eine externe Quelle um alle Unicode Blöcke für verschiedene Scripte zu erhalten: <a href="http://kourge.net/projects/regexp-unicode-block" title="http://kourge.net/projects/regexp-unicode-block">Regexp-unicode-block</a></p> + +<h3 id="Weitere_nennenswerte_Beispiele">Weitere nennenswerte Beispiele</h3> + +<h5 id="Extrahieren_eines_Subdomain-Namens_aus_einer_URL">Extrahieren eines Subdomain-Namens aus einer URL</h5> + +<pre class="brush: js notranslate" style="font-size: 14px;">var url = "http://xxx.domain.com"; +print(/[^.]+/.exec(url)[0].substr(7)); // prints "xxx"</pre> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Phone</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/en-US/docs/JavaScript/Guide/Regular_Expressions" title="JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="/en-US/docs/JavaScript/Guide" title="JavaScript/Guide">JavaScript Guide</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/regexp/input/index.html b/files/de/web/javascript/reference/global_objects/regexp/input/index.html new file mode 100644 index 0000000000..d173458705 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/regexp/input/index.html @@ -0,0 +1,105 @@ +--- +title: RegExp.input ($_) +slug: Web/JavaScript/Reference/Global_Objects/RegExp/input +tags: + - JavaScript + - Property + - Reference + - RegExp + - Regular Expressions +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/input +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die nicht-standarde input Propertie ist eine statische Propertie regularer Expressionen, welche die Zeichenkette, der eine reguläre Expression entgegengestellt wird, enthält. <code>RegExp.$_</code> ist ein Alias für diese Propertie.</p> + +<h2 id="Syntaxis">Syntaxis</h2> + +<pre class="syntaxbox"><code><var>RegExp</var>.input +RegExp.$_</code> +</pre> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>input</code>-Propertie ist statisch, ist nicht eine Propertie eines einzigen Obiectes einer regulären Expression. Stattdessen nutzt man es immer als <code>RegExp.input</code> oder</p> + +<p>Der Wert der <code>input</code>-Propertie wird verändert, wenn die gesuchte Zeichenkette in der regulären Expression verändert wird und diese Zeichenkette passt.</p> + +<h2 id="Beispiele"><code>Beispiele</code></h2> + +<h3 id="Verwendung_von_input_und__"><code>Verwendung von <code>input</code> und <code>$_</code></code></h3> + +<pre class="brush: js"><code>var re = /hi/g; +re.test("hi there!"); +RegExp.input; // "hi there!" +re.test("foo"); // neuer Test, unpassend +RegExp.$_; // "hi there!" +re.test("hi world!"); // neuer Test, passend +RegExp.$_; // "hi world!" +</code></pre> + +<h2 id="Specificationen"><code>Specificationen</code></h2> + +<p><code>Non-standard. Nicht Teil von irgendeiner laufenden Specification.</code></p> + +<h2 id="Browsercompatibilität"><code>Browsercompatibilität</code></h2> + +<div><code>{{CompatibilityTable}}</code></div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th><code>Feature</code></th> + <th><code>Chrome</code></th> + <th><code>Firefox (Gecko)</code></th> + <th><code>Internet Explorer</code></th> + <th><code>Opera</code></th> + <th><code>Safari</code></th> + </tr> + <tr> + <td><code>Basisunterstützung</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th><code>Feature</code></th> + <th><code>Android</code></th> + <th><code>Chrome for Android</code></th> + <th><code>Firefox Mobile (Gecko)</code></th> + <th><code>IE Mobile</code></th> + <th><code>Opera Mobile</code></th> + <th><code>Safari Mobile</code></th> + </tr> + <tr> + <td><code>Basisunterstützung</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + <td><code>{{CompatVersionUnknown}}</code></td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch"><code>Siehe auch</code></h2> + +<ul> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.lastMatch", "RegExp.lastMatch ($&)")}}</code></li> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.lastParen", "RegExp.lastParen ($+)")}}</code></li> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.leftContext", "RegExp.leftContext ($`)")}}</code></li> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.rightContext", "RegExp.rightContext ($')")}}</code></li> + <li><code>{{non-standard_inline}} {{jsxref("RegExp.n", "RegExp.$1-$9")}}</code></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/regexp/test/index.html b/files/de/web/javascript/reference/global_objects/regexp/test/index.html new file mode 100644 index 0000000000..e908792657 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/regexp/test/index.html @@ -0,0 +1,127 @@ +--- +title: RegExp.prototype.test() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/test +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>test()</code></strong> Methode führt eine Suche nach einer Übereinstimmung zwischen einer regular expression und einem String durch. Sie gibt <code>true</code> oder <code>false</code> zurück.</p> + +<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-test.html", "taller")}}</div> + +<p class="hidden">Der Quellcode dieses interaktiven Beispiels befindet sich in einer GitHub repository. Wenn Sie sich an diesem Projekt beteiligen möchten, clonen Sie bitte <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> und senden Sie uns einen pull request.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><code><var>regexObj</var>.test(<var>str</var>)</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code><var>str</var></code></dt> + <dd>Der String, mit dem die regular expression verglichen wird.</dd> +</dl> + +<h3 id="Rückgabewerte">Rückgabewerte</h3> + +<p><code>true</code> wird zurückgegeben, wenn es eine Übereinstimmung zwischen der regular expression und dem String gibt <code><var>str</var></code>. Anderenfalls wird <code>false</code> zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Verwenden Sie <code>test()</code>, wenn Sie wissen möchten, ob ein Muster auf einen String zutrifft. <code>test()</code> gibt einen boolschen Wert zurück, wohingegen die {{jsxref("String.prototype.search()")}} Methode den Index der Übereinstimmung, oder wenn keine Übereinstimmung gefunden wird, <code>-1</code> zurück gibt.</p> + +<p>Um mehr Informationen zu erhalten, können Sie alternativ die langsammere {{jsxref("RegExp.prototype.exec()", "exec()")}} Methode verwenden. (Sie ähnelt {{jsxref("String.prototype.match()")}} Methode.)</p> + +<p>As with <code>exec()</code> (or in combination with it), <code>test()</code> called multiple times on the same global regular expression instance will advance past the previous match.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="test_anwenden">test() anwenden</h3> + +<p>Ein einfaches Beispiel, um zu testen, ob <code>"hello"</code> am Anfang eines Strings enthalten ist. Die Ausgabe ist ein boole'scher Wert. </p> + +<pre class="brush: js notranslate">const str = 'hello world!'; +const result = /^hello/.test(str); + +console.log(result); // true +</pre> + +<p>Das folgende Beispiel logt eine Nachricht, die vom Erfolg des Tests abhängt:</p> + +<pre class="brush: js notranslate">function testInput(re, str) { + let midstring; + if (re.test(str)) { + midstring = 'contains'; + } else { + midstring = 'does not contain'; + } + console.log(`${str} ${midstring} ${re.source}`); +} +</pre> + +<h3 id="Anwendung_von_test_mit_dem_Kennzeichen_global">Anwendung von test() mit dem Kennzeichen "global"</h3> + +<p>When a regex has the <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Advanced_searching_with_flags_2">global flag</a> set, <code>test()</code> will advance the {{jsxref("RegExp.lastIndex", "lastIndex")}} of the regex. ({{jsxref("RegExp.prototype.exec()")}} also advances the <code>lastIndex</code> property.)</p> + +<p>Further calls to <code>test(<var>str</var>)</code> will resume searching <code><var>str</var></code> starting from <code>lastIndex</code>. The <code>lastIndex</code> property will continue to increase each time <code>test()</code> returns <code>true</code>. </p> + +<div class="blockIndicator note"> +<p><strong>Note:</strong> As long as <code>test()</code> returns <code>true</code>, <code>lastIndex</code> will <em>not</em> reset—even when testing a different string!</p> +</div> + +<p>When <code>test()</code> returns <code>false</code>, the calling regex's <code>lastIndex</code> property will reset to <code>0</code>.</p> + +<p>The following example demonstrates this behaviour:</p> + +<pre class="brush: js notranslate">const regex = /foo/g; // the "global" flag is set + +// regex.lastIndex is at 0 +regex.test('foo') // true + +// regex.lastIndex is now at 3 +regex.test('foo') // false + +// regex.lastIndex is at 0 +regex.test('barfoo') // true + +// regex.lastIndex is at 6 +regex.test('foobar') //false + +// regex.lastIndex is at 0 +// (...and so on) +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spezifikation</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-regexp.prototype.test', 'RegExp.test')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_-Kompatibilität">Browser -Kompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.RegExp.test")}}</p> + +<h2 id="Firefox-specific_notes">Firefox-specific notes</h2> + +<p>Prior to Firefox 8, <code>test()</code> was implemented incorrectly. When called without parameters, it would match against the value of the previous input (<code>RegExp.input</code> property) instead of against the string <code>"undefined"</code>.</p> + +<p>This is fixed. Now, <code>/undefined/.test()</code> correctly results in <code>true</code>, instead of throwing an error.</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>Das Kapitel <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> im <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("RegExp")}}</li> + <li>{{jsxref("RegExp.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/set/add/index.html b/files/de/web/javascript/reference/global_objects/set/add/index.html new file mode 100644 index 0000000000..1df111c1c5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/set/add/index.html @@ -0,0 +1,69 @@ +--- +title: Set.prototype.add() +slug: Web/JavaScript/Reference/Global_Objects/Set/add +translation_of: Web/JavaScript/Reference/Global_Objects/Set/add +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>add()</code></strong> Methode fügt ein neues Element mit dem angegebenen Wert an das Ende eines <code>Set</code> Objekts hinzu.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-add.html")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><var>mySet</var>.add(<var>value</var>);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code><var>value</var></code></dt> + <dd>Der hinzufügende Wert zu dem <code>Set</code> Objekt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Das <code>Set</code> Objekt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwenden_der_add_Methode">Verwenden der add() Methode</h3> + +<pre class="brush: js notranslate">var mySet = new Set(); + +mySet.add(1); +mySet.add(5).add('some text'); // chainable + +console.log(mySet); +// Set [1, 5, "some text"] +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spezifikation</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.add', 'Set.prototype.add')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Set.add")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> + <li>{{jsxref("Set.prototype.has()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/set/delete/index.html b/files/de/web/javascript/reference/global_objects/set/delete/index.html new file mode 100644 index 0000000000..f0f4cf5f3e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/set/delete/index.html @@ -0,0 +1,84 @@ +--- +title: Set.prototype.delete() +slug: Web/JavaScript/Reference/Global_Objects/Set/delete +translation_of: Web/JavaScript/Reference/Global_Objects/Set/delete +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>delete()</code></strong> Methode entfernt das angegebene Element aus einem <code>Set</code> Objekt.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-delete.html")}}</div> + +<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><var>mySet</var>.delete(<var>value</var>);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code><var>value</var></code></dt> + <dd>Der zu entfernende Wert aus <code><var>mySet</var></code>.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Rückgabewert ist <code>true</code> wenn <code><var>value</var></code> erfolgreich aus <code><var>mySet entfernt wurde</var></code>; ansonsten<code>false</code>.</p> + +<h2 id="Beispiel">Beispiel</h2> + +<h3 id="Verwenden_der_delete_Methode">Verwenden der delete() Methode</h3> + +<pre class="brush: js notranslate">const mySet = new Set(); +mySet.add('foo'); + +mySet.delete('bar'); // Returns false. No "bar" element found to be deleted. +mySet.delete('foo'); // Returns true. Successfully removed. + +mySet.has('foo'); // Returns false. The "foo" element is no longer present. +</pre> + +<p>Ein Beispiel, wie ein Objekt aus einem Set entfernt werden kann.</p> + +<pre class="brush: js notranslate">const setObj = new Set(); // Create a New Set. + +setObj.add({x: 10, y: 20}); // Add object in the set. + +setObj.add({x: 20, y: 30}); // Add object in the set. + +// Delete any point with `x > 10`. +setObj.forEach(function(point){ + if (point.x > 10){ + setObj.delete(point) + } +}) +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Set.delete")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.clear()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/set/has/index.html b/files/de/web/javascript/reference/global_objects/set/has/index.html new file mode 100644 index 0000000000..6374d80bc6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/set/has/index.html @@ -0,0 +1,131 @@ +--- +title: Set.prototype.has() +slug: Web/JavaScript/Reference/Global_Objects/Set/has +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/has +--- +<div>{{JSRef}}</div> + +<p>Die Methode <code><strong>has()</strong></code> prüft, ob ein <code>Set</code>-Objekt ein Element mit dem angegebenen Wert enthält und gibt entsprechend <code>true</code> oder <code>false</code> zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.has(value);</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>value</dt> + <dd>Der zu suchende Wert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<dl> + <dt>Boolean</dt> + <dd>Gibt <code>true</code> zurück, falls ein Element mit dem angegebenen Wert innerhalb des <code>Set</code>-Objektes existiert, ansonsten wird <code>false</code> zurückgegeben.</dd> +</dl> + +<h2 id="Beispiel">Beispiel</h2> + +<h3 id="has()_verwenden"><code>has()</code> verwenden</h3> + +<p>Das folgende Beispiel verwendet <code>has()</code>, um zu prüfen, ob bestimmte Werte in einem <code>Set</code> enthalten sind oder nicht.</p> + +<pre class="brush: js">var mySet = new Set(); +mySet.add('foo'); + +mySet.has('foo'); // returns true +mySet.has('bar'); // returns false +</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-set.prototype.has', 'Set.prototype.has')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.has', 'Set.prototype.has')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.add()")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/set/index.html b/files/de/web/javascript/reference/global_objects/set/index.html new file mode 100644 index 0000000000..27a3b1ad3d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/set/index.html @@ -0,0 +1,264 @@ +--- +title: Set +slug: Web/JavaScript/Reference/Global_Objects/Set +tags: + - ECMAScript6 + - Global Objects + - JavaScript + - Referenz + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set +--- +<div>{{JSRef}}</div> + +<p>Ein <strong><code>Set</code></strong>-Objekt speichert <em>eindeutige</em> Werte jedes beliebigen Typs, egal ob es sich dabei um {{Glossary("Primitive", "primitive Werte")}} oder Objektreferenzen handelt.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-constructor.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate">new Set([iterable]);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt>iterable</dt> + <dd>Ein <a href="/de/docs/Web/JavaScript/Reference/Statements/for...of">iterierbares Objekt</a>, dessen Elemente zum neuen <code>Set</code> hinzugefügt werden sollen.<br> + Ist dieser Parameter nicht angegeben oder <code>null</code>, wird ein leeres <code>Set</code> erzeugt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neues <code>Set</code> Objekt.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>Set</code> Objekte sind Sammlungen von Werten. Man kann über die Elemente iterieren; sie werden in der Reihenfolge ihres Hinzufügens gespeichert. Jeder Wert ist <strong>nur einmal vorhanden</strong>; er ist im <code>Set</code> eindeutig.</p> + +<h3 id="Gleichheit">Gleichheit</h3> + +<p>Da jeder Wert innerhalb eines <code>Set</code>s eindeutig sein muss, werden alle Werte auf Gleichheit überprüft. In einer früheren Version der ECMAScript Spezifikation verhielt sich der Algorithmus dafür anders als der für den <code>===</code> Operator. Insbesondere waren für <code>Set</code>s <code>+0</code> und <code>-0</code> verschiedene Werte (obwohl sie streng gleich sind). In der ECMAScript 2015 Spezifikation wurde das geändert, so dass <code>+0</code> und <code>-0</code> jetzt jeweils als gleicher Wert gelten. Siehe auch den Eintrag "Key equality for -0 and 0" in der Übersicht zur <a href="#browserkompatibilität">Browserkompatibilität</a>.</p> + +<p>{{jsxref("NaN")}} und {{jsxref("undefined")}} können ebenfalls in einem Set gespeichert werden. Dabei werden alle <code>NaN</code> Werte gleichgesetzt, d.h. <code>NaN</code> gilt gleich <code>NaN</code> (auch wenn <code>NaN !== NaN</code>).</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>Set.length</code></dt> + <dd>Der Wert der Eigenschaft <code>length</code> ist immer 0.<br> + Die Anzahl der Elemente eines Sets befindet sich in {{jsxref("Set.prototype.size")}}.</dd> + <dt>{{jsxref("Set.@@species", "get Set[@@species]")}}</dt> + <dd>Die Konstruktorfunktion, um abgeleitete Objekte zu erzeugen.</dd> + <dt>{{jsxref("Set.prototype")}}</dt> + <dd>Prototyp für den <code>Set</code> Konstruktor. Ermöglicht das Hinzufügen von Eigenschaften zu allen <code>Set</code> Objekten.</dd> +</dl> + +<h2 id="Set_Instanzen"><code>Set</code> Instanzen</h2> + +<p>Alle <code>Set</code> Instanzen erben von {{jsxref("Set.prototype")}}.</p> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Properties')}}</p> + +<h3 id="Methoden">Methoden</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Set/prototype','Methods')}}</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwenden_eines_Set_Objekts">Verwenden eines <code>Set</code> Objekts</h3> + +<pre class="brush: js notranslate">var mySet = new Set(); + +mySet.add(1); +mySet.add(5); +mySet.add("some text"); +var o = {a: 1, b: 2}; +mySet.add(o); + +mySet.has(1); // true +mySet.has(3); // false, 3 has not been added to the set +mySet.has(5); // true +mySet.has(Math.sqrt(25)); // true +mySet.has("Some Text".toLowerCase()); // true +mySet.has(o); // true + +mySet.size; // 4 + +mySet.delete(5); // removes 5 from the set +mySet.has(5); // false, 5 has been removed + +mySet.size; // 3, we just removed one value +</pre> + +<h3 id="Iterieren_über_ein_Set">Iterieren über ein <code>Set</code></h3> + +<pre class="brush: js notranslate">// iterate over items in set +// logs the items in the order: 1, "some text" +for (let item of mySet) console.log(item); + +// logs the items in the order: 1, "some text" +for (let item of mySet.keys()) console.log(item); + +// logs the items in the order: 1, "some text" +for (let item of mySet.values()) console.log(item); + +// logs the items in the order: 1, "some text" +//(key and value are the same here) +for (let [key, value] of mySet.entries()) console.log(key); + +// convert set to plain Array +var myArr = Array.from(mySet); // [1, "some text"] + +// the following will also work if run in an HTML document +mySet.add(document.body); +mySet.has(document.querySelector("body")); // true + +// converting between Set and Array +mySet2 = new Set([1,2,3,4]); +mySet2.size; // 4 +[...mySet2]; // [1,2,3,4] + +// intersect can be simulated via +var intersection = new Set([...set1].filter(x => set2.has(x))); + +// difference can be simulated via +var difference = new Set([...set1].filter(x => !set2.has(x))); + +// Iterate set entries with forEach +mySet.forEach(function(value) { + console.log(value); +}); + +// 1 +// 2 +// 3 +// 4</pre> + +<h3 id="Gebräuchliche_Set_Operationen_implementieren">Gebräuchliche <code>Set</code> Operationen implementieren</h3> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js"><span class="keyword token">function</span> <span class="function token">isSuperset</span><span class="punctuation token">(</span><span class="parameter token"><span class="keyword token">set</span><span class="punctuation token">,</span> subset</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> subset<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">if</span> <span class="punctuation token">(</span><span class="operator token">!</span><span class="keyword token">set</span><span class="punctuation token">.</span><span class="function token">has</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">return</span> <span class="boolean token">false</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> <span class="boolean token">true</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="keyword token">function</span> <span class="function token">union</span><span class="punctuation token">(</span><span class="parameter token">setA<span class="punctuation token">,</span> setB</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> _union <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>setA<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + _union<span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> _union<span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="keyword token">function</span> <span class="function token">intersection</span><span class="punctuation token">(</span><span class="parameter token">setA<span class="punctuation token">,</span> setB</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> _intersection <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">if</span> <span class="punctuation token">(</span>setA<span class="punctuation token">.</span><span class="function token">has</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + _intersection<span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> _intersection<span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="keyword token">function</span> <span class="function token">symmetricDifference</span><span class="punctuation token">(</span><span class="parameter token">setA<span class="punctuation token">,</span> setB</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> _difference <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>setA<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">if</span> <span class="punctuation token">(</span>_difference<span class="punctuation token">.</span><span class="function token">has</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + _difference<span class="punctuation token">.</span><span class="function token">delete</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> <span class="keyword token">else</span> <span class="punctuation token">{</span> + _difference<span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> _difference<span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="keyword token">function</span> <span class="function token">difference</span><span class="punctuation token">(</span><span class="parameter token">setA<span class="punctuation token">,</span> setB</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> _difference <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>setA<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + _difference<span class="punctuation token">.</span><span class="function token">delete</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> _difference<span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="comment token">//Examples</span> +<span class="keyword token">var</span> setA <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">1</span><span class="punctuation token">,</span> <span class="number token">2</span><span class="punctuation token">,</span> <span class="number token">3</span><span class="punctuation token">,</span> <span class="number token">4</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">,</span> + setB <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">2</span><span class="punctuation token">,</span> <span class="number token">3</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">,</span> + setC <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">3</span><span class="punctuation token">,</span> <span class="number token">4</span><span class="punctuation token">,</span> <span class="number token">5</span><span class="punctuation token">,</span> <span class="number token">6</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + +<span class="function token">isSuperset</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => true</span> +<span class="function token">union</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => Set [1, 2, 3, 4, 5, 6]</span> +<span class="function token">intersection</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => Set [3, 4]</span> +<span class="function token">symmetricDifference</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => Set [1, 2, 5, 6]</span> +<span class="function token">difference</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => Set [1, 2]</span></code></pre> + +<h3 id="Array_und_Set"><code>Array</code> und <code>Set</code></h3> + +<pre class="brush: js notranslate">var myArray = ["value1", "value2", "value3"]; + +// Use the regular Set constructor to transform an Array into a Set +var mySet = new Set(myArray); + +mySet.has("value1"); // returns true + +// Use the spread operator to transform a set into an Array. +console.log([...mySet]); // Will show you exactly the same Array as myArray</pre> + +<h3 id="Duplikate_entfernen_aus_einem_Array">Duplikate entfernen aus einem <code>Array</code></h3> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js"><span class="comment token">// Use to remove duplicate elements from the array </span> + +<span class="keyword token">const</span> numbers <span class="operator token">=</span> <span class="punctuation token">[</span><span class="number token">2</span><span class="punctuation token">,</span><span class="number token">3</span><span class="punctuation token">,</span><span class="number token">4</span><span class="punctuation token">,</span><span class="number token">4</span><span class="punctuation token">,</span><span class="number token">2</span><span class="punctuation token">,</span><span class="number token">3</span><span class="punctuation token">,</span><span class="number token">3</span><span class="punctuation token">,</span><span class="number token">4</span><span class="punctuation token">,</span><span class="number token">4</span><span class="punctuation token">,</span><span class="number token">5</span><span class="punctuation token">,</span><span class="number token">5</span><span class="punctuation token">,</span><span class="number token">6</span><span class="punctuation token">,</span><span class="number token">6</span><span class="punctuation token">,</span><span class="number token">7</span><span class="punctuation token">,</span><span class="number token">5</span><span class="punctuation token">,</span><span class="number token">32</span><span class="punctuation token">,</span><span class="number token">3</span><span class="punctuation token">,</span><span class="number token">4</span><span class="punctuation token">,</span><span class="number token">5</span><span class="punctuation token">]</span> + +console<span class="punctuation token">.</span><span class="function token">log</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="operator token">...</span>new <span class="class-name token">Set</span><span class="punctuation token">(</span>numbers<span class="punctuation token">)</span><span class="punctuation token">]</span><span class="punctuation token">)</span> + +<span class="comment token">// [2, 3, 4, 5, 6, 7, 32]</span></code></pre> + +<h3 id="String_und_Set"><code>String</code> und <code>Set</code></h3> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js"><span class="keyword token">var</span> text <span class="operator token">=</span> <span class="string token">'India'</span><span class="punctuation token">;</span> + +<span class="keyword token">var</span> mySet <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>text<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// Set ['I', 'n', 'd', 'i', 'a']</span> +mySet<span class="punctuation token">.</span>size<span class="punctuation token">;</span> <span class="comment token">// 5</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('ES6', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität"><a id="browserkompatibilität" name="browserkompatibilität"></a>Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.Set")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/charat/index.html b/files/de/web/javascript/reference/global_objects/string/charat/index.html new file mode 100644 index 0000000000..815eb59bba --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/charat/index.html @@ -0,0 +1,305 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charAt +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>charAt()</code></strong>-Methode gibt das Zeichen an einer bestimmten Stelle eines Strings wieder.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.charAt(<var>index</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>index</code></dt> + <dd>Eine Zahl zwischen 0 und <code>str.length-1</code>. Ist kein <code>index</code> gegeben, ist dieser automatisch 0.</dd> +</dl> + +<h3 id="Wiedergegebener_Wert">Wiedergegebener Wert</h3> + +<p>Ein String, der das Zeichen an der angegebenen <code>index</code>-Stelle wiedergibt. Wenn <code>index</code> außerhalb der Reichweite liegt, wird ein leerer String zurückgegeben.<br> + </p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Zeichen in einem String werden von links nach rechts indexiert. Der Index des ersten Zeichens ist 0, der Index des letzten Zeichens eines Strings namens <code>stringName</code> ist<code> stringName.length - 1</code>.</p> + +<p>Wenn kein Index bereitgestellt wird, ist dieser standardmäßig 0.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Wiedergabe_von_Zeichen_an_verschiedenen_Stellen_eines_Strings">Wiedergabe von Zeichen an verschiedenen Stellen eines Strings</h3> + +<p>Das folgende Beispiel gibt Zeichen an verschiedenen Orten im String "<code>Brave new world</code>" wieder:</p> + +<pre class="brush: js">var anyString = 'Brave new world'; +console.log("Das Zeichen bei Index 0 ist '" + anyString.charAt() + "'"); +// kein Index definiert, 0 als Standard genutzt + +console.log("Das Zeichen bei Index 0 ist '" + anyString.charAt(0) + "'"); +console.log("Das Zeichen bei Index 1 ist '" + anyString.charAt(1) + "'"); +console.log("Das Zeichen bei Index 2 ist '" + anyString.charAt(2) + "'"); +console.log("Das Zeichen bei Index 3 ist '" + anyString.charAt(3) + "'"); +console.log("Das Zeichen bei Index 4 ist '" + anyString.charAt(4) + "'"); +console.log("Das Zeichen bei Index 999 ist '" + anyString.charAt(999) + "'"); +</pre> + +<p>Diese Zeilen geben folgendes wieder:</p> + +<pre class="brush: js">Das Zeichen bei Index 0 ist 'B' +Das Zeichen bei Index 0 ist 'B' +Das Zeichen bei Index 1 ist 'r' +Das Zeichen bei Index 2 ist 'a' +Das Zeichen bei Index 3 ist 'v' +Das Zeichen bei Index 4 ist 'e' +Das Zeichen bei Index 999 ist '' +</pre> + +<h3 id="Erhalten_von_vollständigen_Zeichen">Erhalten von vollständigen Zeichen</h3> + +<p>Der folgende Code versichert, dass der Gebrauch eines String-Loops immer das vollständige Zeichen wiedergibt - auch wenn der String Zeichen enthält, die nicht auf der mehrsprachigen Basisebene (MBE) vorhanden sind.</p> + +<pre class="brush: js">var str = 'A \uD87E\uDC04 Z'; // direkter Einsatz von nicht MBE-Zeichen auch möglich +for (var i = 0, chr; i < str.length; i++) { + if ((chr = getWholeChar(str, i)) === false) { + continue; + } + // Übernehme diese Zeile zu Beginn jedes Loops, + // gib den kompletten String und Iterator an + // und gebe eine Variable wieder, die das individuelle Zeichen wiederspiegelt. + + console.log(chr); +} + +function getWholeChar(str, i) { + var code = str.charCodeAt(i); + + if (Number.isNaN(code)) { + return ''; // Position not found + } + if (code < 0xD800 || code > 0xDFFF) { + return str.charAt(i); + } + + // High surrogate (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i + 1)) { + throw 'High surrogate without following low surrogate'; + } + var next = str.charCodeAt(i + 1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'High surrogate without following low surrogate'; + } + return str.charAt(i) + str.charAt(i + 1); + } + // Low surrogate (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'Low surrogate without preceding high surrogate'; + } + var prev = str.charCodeAt(i - 1); + + // (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'Low surrogate without preceding high surrogate'; + } + // We can pass over low surrogates now as the second component + // in a pair which we have already processed + return false; +} +</pre> + +<p>In einer ECMAScript 2016-Umgebung, welche destruktive Benennung erlaubt, ist eine bündigere und zu gewissem Grad flexiblere Alternative möglich, da es automatisch eine Erhöhung der entsprechenden Variable vornimmt (wenn das Zeichen<br> + ein Ersatzpaar ist).</p> + +<pre class="brush: js">var str = 'A\uD87E\uDC04Z'; // direkter Einsatz von nicht MBE-Zeichen auch möglich +for (var i = 0, chr; i < str.length; i++) { + [chr, i] = getWholeCharAndI(str, i); + // Adapt this line at the top of each loop, passing in the whole string and + // the current iteration and returning an array with the individual character + // and 'i' value (only changed if a surrogate pair) + // Übernehme diese Zeile zu Beginn jedes Loops, + // gib den kompletten String und Iterator an + // und gebe einen Array wieder, der die individuellen Zeichen und 'i'-Wert wiederspiegelt + // (nur geändert, wenn Ersatzpaar). + + console.log(chr); +} + +function getWholeCharAndI(str, i) { + var code = str.charCodeAt(i); + + if (Number.isNaN(code)) { + return ''; // Position nicht gefunden + } + if (code < 0xD800 || code > 0xDFFF) { + return [str.charAt(i), i]; // Normales Zeichen, 'i' bleibt gleich + } + + // High surrogate (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i + 1)) { + throw 'High surrogate without following low surrogate'; + } + var next = str.charCodeAt(i + 1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'High surrogate without following low surrogate'; + } + return [str.charAt(i) + str.charAt(i + 1), i + 1]; + } + // Low surrogate (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'Low surrogate without preceding high surrogate'; + } + var prev = str.charCodeAt(i - 1); + + // (could change last hex to 0xDB7F to treat high private surrogates + // as single characters) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'Low surrogate without preceding high surrogate'; + } + // Return the next character instead (and increment) + return [str.charAt(i + 1), i + 1]; +} +</pre> + +<h3 id="Korrigiere_charAt()_um_Zeichen_der_nicht_mehrsprachigen_Basisebene_(MBE)_zu_unterstützen">Korrigiere <code>charAt()</code>, um Zeichen der nicht mehrsprachigen Basisebene (MBE) zu unterstützen</h3> + +<p><br> + Das obige Beispiel dürfte häufiger für diejenigen hilfreich sein, die nicht MBE-Zeichen unterstützen möchten (da man nicht wissen muss, wo nicht MBE-Zeichen vorkommen). Falls man wünscht (durch Angabe eines Indexwerts) die Ersatzpaare innerhalb eines Strings als Einzelcharakter zu behandeln, kann man folgendes nutzen:</p> + +<pre class="brush: js">function fixedCharAt(str, idx) { + var ret = ''; + str += ''; + var end = str.length; + + var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + while ((surrogatePairs.exec(str)) != null) { + var li = surrogatePairs.lastIndex; + if (li - 2 < idx) { + idx++; + } else { + break; + } + } + + if (idx >= end || idx < 0) { + return ''; + } + + ret += str.charAt(idx); + + if (/[\uD800-\uDBFF]/.test(ret) && /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))) { + // Gehe eins weiter, da eins der Zeichen Teil eines Ersatzpaares ist + ret += str.charAt(idx + 1); + } + return ret; +} +</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>erste Definition</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Standardunterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome für Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td> Standardunterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/concat/index.html b/files/de/web/javascript/reference/global_objects/string/concat/index.html new file mode 100644 index 0000000000..548135330f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/concat/index.html @@ -0,0 +1,140 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/String/concat +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>concat()</code></strong> Methode vereint den Text von einem oder mehreren Strings und gibt einen neuen String zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.concat(<var>string2</var>[, <var>string3</var>, ..., <var>stringN</var>])</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>string2...string<em>N</em></code></dt> + <dd>Strings die zu einem neuen String vereint werden sollen.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer String, der die Texte der Strings hintereinander enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>concat()</code> Funktion kombiniert die Texte von einem oder mehreren Strings und gibt einen neuen String zurück. Das ändern des Textes eines Strings hat keine Auswirkungen auf die anderen Strings.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_concat()">Einsatz von <code>concat()</code></h3> + +<p>Das folgende Beispiel kombiniert Strings in einen neuen String.</p> + +<pre class="brush: js">var hello = 'Hello, '; +console.log(hello.concat('Kevin', ' have a nice day.')); + +/* Hello, Kevin have a nice day. */ +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Es wird ausdrücklich empfohlen {{jsxref("Operators/Assignment_Operators", "Zuweisungsoperatoren", "", 1)}} (<code>+</code>, <code>+=</code>) statt der <code>concat()</code> Methode zu benutzen. Sie hierfür diesen <a href="http://jsperf.com/concat-vs-plus-vs-join">Performancetest</a>.</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.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.concat()")}}</li> + <li>{{jsxref("Operators/Assignment_Operators", "Assignment operators", "", 1)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/endswith/index.html b/files/de/web/javascript/reference/global_objects/string/endswith/index.html new file mode 100644 index 0000000000..73f37a9692 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/endswith/index.html @@ -0,0 +1,148 @@ +--- +title: String.prototype.endsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/endsWith +tags: + - JavaScript + - Méthode + - Prototyp + - Referenz + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>endsWith()</code></strong> bestimmt, ob ein String das Ende eines anderen Strings ist, und liefert entsprechend true oder false zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.endsWith(<var>suchString</var>[, <var>position</var>])</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>suchString</code></dt> + <dd>Der String, nach dem am Ende von str gesucht wird.</dd> + <dt><code>position</code></dt> + <dd>Optional. Durchsucht str, als wäre es nur <strong>position</strong> Zeichen lang. Standardmäßig wird die Länge von str benutzt, wird automatisch auf die Länge von str gebracht, falls diese überschritten wird.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><code>Falls suchString das Ende von str ist, wird </code><strong><code>true</code></strong> zurückgeliefert, andernfalls wird <strong><code>false</code></strong> zurückgeliefert.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode bestimmt, ob ein String das Ende eines anderen Strings ist. Die Methode unterscheidet zwischen Groß- und Kleinschreibung.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_endsWith()">Benutzung von <code>endsWith()</code></h3> + +<pre class="brush: js">var str = 'To be, or not to be, that is the question.'; + +console.log(str.endsWith('question.')); // true +console.log(str.endsWith('to be')); // false +console.log(str.endsWith('to be', 19)); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Methode wurde der ECMAScript6-Spezifikation hinzugefügt und könnte noch nicht in allen JavaScript-Implementierungen verfügbar sein. Mithilfe des folgenden Code-Stücks kann die Methode auch bei fehlender Implementierung genutzt werden:</p> + +<pre class="brush: js">if (!String.prototype.endsWith) { + String.prototype.endsWith = function(searchString, position) { + var subjectString = this.toString(); + if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) { + position = subjectString.length; + } + position -= searchString.length; + var lastIndex = subjectString.indexOf(searchString, position); + return lastIndex !== -1 && lastIndex === position; + }; +} +</pre> + +<h2 id="Spezifikation">Spezifikation</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Edge</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatChrome("41")}}</td> + <td>{{CompatGeckoDesktop("17")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("9")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("36")}}</td> + <td>{{CompatGeckoMobile("17")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/de/web/javascript/reference/global_objects/string/fromcharcode/index.html new file mode 100644 index 0000000000..1ddc144e28 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/fromcharcode/index.html @@ -0,0 +1,134 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +--- +<div>{{JSRef}}</div> + +<p>Die statische Methode <strong><code>String.fromCharCode()</code></strong> gibt einen String zurück, der mit der angegebenen Folge von Unicode-Zeichen erstellt wurde.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Eine Folge von Zahlen als Unicode-Werte. Der Wertebreich liegt zwischen 0 und 65535 (0xFFFF). Zahlen, welche größer als 0xFFFF sind werden gekürzt.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein String, der die den Unicode-Werten zugeordneten Zeichen enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode gibt einen String zurück und kein {{jsxref("String")}} Objekt.</p> + +<p>Da <code>fromCharCode()</code> eine statische Methode von {{jsxref("String")}} ist, wird sie immer als <code>String.fromCharCode() </code>angewandt und nicht als Methode eines {{jsxref("String")}} Objekts, das erstellt wurde.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_fromCharCode()">Verwendung von <code>fromCharCode()</code></h3> + +<pre>String.fromCharCode(65, 66, 67); // gibt "ABC" zurück +String.fromCharCode(0x2014); // gibt "—" zurück +String.fromCharCode(0x12014); // gibt auch "—" zurück. Die Ziffer 1 wird weggekürzt und ignoriert.</pre> + +<h2 id="Verwendung_mit_höheren_Werten">Verwendung mit höheren Werten</h2> + +<p>Die meisten Unicode-Werte können mit einer 16-bit-Nummer dargestellt werden (wie in den Anfängen der JavaScript-Standardisierung erwartet) und <code>fromCharCode()</code> kann verwendet werden, um ein einzelnes Zeichen für die meisten gängigen Werde (d.h. UCS-2 Werte, die ein Subset von UTF-16 mit den am häufigsten vorkommenden Zeichen bilden) darzustellen. Um jedoch ALLE gültigen Unicode-Werte (bis zu 21 bits) darzustellen, ist <code>fromCharCode()</code> allein nicht ausreichend. Da die höheren Code Point Zeichen zwei "Ersatznummern" (mit niedrigerem Wert) verwenden, um ein einzelnes Zeichen darzustellen, kann {{jsxref("String.fromCodePoint()")}} (Teil des ES2015 Standards) verwendet werden, um ein solches Paar und damit auch diese Zeichen mit höheren Werten darzustellen.</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>Erstdefinition. Implementiert in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/includes/index.html b/files/de/web/javascript/reference/global_objects/string/includes/index.html new file mode 100644 index 0000000000..ee3aa6564c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/includes/index.html @@ -0,0 +1,131 @@ +--- +title: String.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/String/includes +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/includes +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>includes()-</strong></code>Methode gibt an, ob ein String innerhalb eines anderen Strings gefunden wird und gibt dabei <code>true</code> oder <code>false</code> wieder.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.includes(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>searchString</code></dt> + <dd>Ein String, der innerhalb eines anderen Strings gesucht wird.</dd> + <dt><code>position</code></dt> + <dd>Optional. Die Position innerhalb des besuchten Strings durch <code>searchString</code>; Standard ist 0.</dd> +</dl> + +<h3 id="Wertwiedergabe">Wertwiedergabe</h3> + +<p><strong><code>true</code></strong>, wenn der String den gesuchten String enthält, andernfalls <strong><code>false</code></strong>.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode lässt dich feststellen, ob ein String einen anderen String beinhaltet.</p> + +<h3 id="Achtung_auf_Groß-_Kleinschreibung">Achtung auf Groß-, Kleinschreibung</h3> + +<p>Bei der <code>includes()</code>-Methode muss auf Groß- und Kleinschreibung geachtet werden.<br> + Zum Beispiel gibt die folgende Darstellung <code>false</code> aus:</p> + +<pre class="brush: js">'Blue Whale'.includes('blue'); // gibt false wieder +</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Einsatz_von_includes">Einsatz von <code>includes()</code></h3> + +<pre class="brush: js">var str = 'Sein oder nicht sein, das ist hier die Frage.'; + +console.log(str.includes('Sein')); // true +console.log(str.includes('Frage')); // true +console.log(str.includes('nicht da')); // false +console.log(str.includes('Sein', 1)); // false +console.log(str.includes('SEIN')); // false +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Methode wurde den ECMAScript 6 Spezifikationen hinzugefügt und könnte nicht in allen JavaScript-Umgebunden vorhanden sein. Jedoch kann man diesen Polyfill nutzen:</p> + +<pre class="brush: js">if (!String.prototype.includes) { + String.prototype.includes = function(search, start) { + 'use strict'; + if (typeof start !== 'number') { + start = 0; + } + + if (start + search.length > this.length) { + return false; + } else { + return this.indexOf(search, start) !== -1; + } + }; +} + +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikationen</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>erste Definition</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilitä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.String.includes")}}</p> + +<h2 id="String.prototype.contains">String.prototype.contains</h2> + +<p>In Firefox 18 - 39 hieß diese Methode <code>contains()</code>. Es wurde zu <code>includes()</code> ({{bug(1102219)}}) wegen folgender Gründe umbenannt:<br> + <br> + Es wurde gemeldet, dass manche Webseiten, die MooTools 1.2 nutzen mit Firefox 17 nicht mehr funktionieren. Diese Version von MooTools kontrolliert, ob <code>String.prototype.contains()</code> existiert und, wenn nicht, fügt es seine eigene Funktion hinzu.<br> + Mit der Einführung dieser Funktion in Firefox 17 wurde das Verhalten dieser Kontrolle geändert, sodass auf MooTools <code>String.prototype.contains()</code> basierender Code funktionsunfähig wurde.<br> + Aufgrund dessen wurde die Implementierung in Firefox 17 <a href="https://hg.mozilla.org/releases/mozilla-aurora/rev/086db97198a8">abgeschaltet </a>und <code>String.prototype.contains()</code> war in Firefox 18 nutzbar. Ermöglicht wurde dies durch die <a href="http://mootools.net/blog/2013/02/19/mootools-1-2-6-released">Veröffentlichung von MooTools Version 1.2.6.</a></p> + +<p>MooTools 1.3 erzwingt die Nutzung der eigenen Version von <code>String.prototype.contains()</code>, demnach sollten Webseiten, die abhängig davon sind, weiterhin funktionieren. Beachte jedoch, dass sich die <a href="http://mootools.net/core/docs/1.3.2/Types/String#String-method:-contains">MooTools 1.3 Signatur </a>von der ECMAScript 6 Signatur für diese Methode unterscheidet.</p> + +<p>Später änderte <a href="https://github.com/mootools/mootools-core/blob/master/Docs/Types/String.md#note">MooTools 1.5+ die Signatur, um sie dem ES2015 Standard anzupassen.</a></p> + +<p><br> + In Firefox 48 wurde <code>String.prototype.contains()</code> entfernt. Nutze lediglich <code>String.prototype.includes()</code>.</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.includes()")}} {{experimental_inline}}</li> + <li>{{jsxref("TypedArray.prototype.includes()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.endsWith()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/index.html b/files/de/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..35faef0223 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,310 @@ +--- +title: String +slug: Web/JavaScript/Reference/Global_Objects/String +tags: + - ECMAScript 2015 + - JavaScript + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<div>{{JSRef}}</div> + +<p>Das globale <strong><code>String</code></strong>-Objekt ist ein Konstruktor für Strings, auch Zeichenketten genannt.</p> + +<h2 id="Syntax">Syntax</h2> + +<p>String-Literale haben folgende Formen:</p> + +<pre class="syntaxbox">'string-text' +"string-text" +"中文 español deutsch English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ்"</pre> + +<p>Strings können auch direkt mit dem globalen <code>String</code>-Objekt erzeugt werden:</p> + +<pre class="syntaxbox">String(thing)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>thing</code></dt> + <dd>Alles, was in einen String umgewandelt werden kann.</dd> +</dl> + +<h3 id="Template-Literale">Template-Literale</h3> + +<p>Ab ECMAScript 2015 können String-Literale auch durch sogenannte <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/template_strings">Template-Literale</a> verkörpert werden:</p> + +<pre class="syntaxbox">`hallo welt` +`hallo! + welt!` +`hallo ${wer}` +escape `<a>${wer}</a>`</pre> + +<dl> +</dl> + +<h3 id="Escape-Notation">Escape-Notation</h3> + +<p>Neben gewöhnlichen, druckbaren Zeichen gibt es Sonderzeichen, die mittels Escape-Notation kodiert werden können:</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Code</th> + <th scope="col">Ausgabe</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>\0</code></td> + <td>das NULL-Zeichen</td> + </tr> + <tr> + <td><code>\'</code></td> + <td>einfaches Anführungszeichen</td> + </tr> + <tr> + <td><code>\"</code></td> + <td>doppeltes Anführungszeichen</td> + </tr> + <tr> + <td><code>\\</code></td> + <td>Rückwärtsschrägstrich (backslash)</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>Zeilenumbruch (new line)</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>Zeilenanfang (carriage return)</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>vertikaler Tabulator</td> + </tr> + <tr> + <td><code>\t</code></td> + <td>Tabulator</td> + </tr> + <tr> + <td><code>\b</code></td> + <td>Backspace</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>Seitenvorschub (form feed)</td> + </tr> + <tr> + <td><code>\uXXXX</code></td> + <td>Unicode-Codepoint</td> + </tr> + <tr> + <td><code>\u{X}</code> ... <code>\u{XXXXXX}</code></td> + <td>Unicode-Codepoint {{experimental_inline}}</td> + </tr> + <tr> + <td><code>\xXX</code></td> + <td>Latin-1-Zeichen</td> + </tr> + </tbody> +</table> + +<div class="note"> +<p>Im Gegensatz zu einigen anderen Sprachen unterscheidet JavaScript nicht zwischen mit einfachen und doppelten Anführungszeichen versehenen Strings; deswegen funktionieren die obigen Escape-Sequenzen in Strings, die entweder mit einfachen oder doppelten Anführungszeichen erstellt wurden.</p> +</div> + +<dl> +</dl> + +<h3 id="Lange_String-Literale">Lange String-Literale</h3> + +<p>Manchmal enthält der Programm-Code Strings, die sehr lang sind. Anstatt endlose Zeilen zu bewirken, die vielleicht am Rand des Editors umbrechen, kann ein String ausdrücklich in mehrere Zeilen im Quell-Code eingepasst werden, ohne seinen Inhalt zu beeinflussen. Es gibt zwei Arten, um das zu tun.</p> + +<p>Es kann der <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition_()">+</a>-Operator benutzt werden, um auf folgende Weise mehrere Strings aneinanderzuhängen:</p> + +<pre class="brush: js">let langerString = "Dies ist ein sehr langer String, der über " + + "mehrere Zeilen verteilt werden muss, weil " + + "sonst der Code unleserlich ist."; +</pre> + +<p>Oder der Rückwärtsschrägstrich ("\") wird am Ende jeder Zeile benutzt, um anzugeben, dass der String in der nächsten Zeile weitergeht. Es sollte sichergestellt werden, dass nach dem Rückwärtsschrägstrich (backslash) kein Leer- oder ein anderes Zeichen (außer ein Zeilenumbruch) steht oder als Einrückung dient; sonst funktioniert es nicht. Diese Form sieht wie folgt aus:</p> + +<pre class="brush: js">let langerString = "Dies ist ein sehr langer String, der über \ +mehrere Zeilen verteilt werden muss, weil \ +sonst der Code unleserlich ist."; +</pre> + +<p>Beide Arten erzeugen identische Strings.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Strings sind nützlich, um Daten in Textform zu speichern. Manche der meist benutzten String-Operationen sind es, die {{jsxref("String.length", "length")}} abzufragen, Strings mittels <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators">+ und += String-Operatoren</a> zu verbinden, mit der {{jsxref("String.prototype.indexOf()", "indexOf()")}} -Methode die Existenz oder Position von Sub-Strings festzustellen oder Sub-Strings mit der {{jsxref("String.prototype.substring()", "substring()")}}-Methode zu extrahieren.</p> + +<h3 id="Zeichenabfrage">Zeichenabfrage</h3> + +<p>Es gibt zwei Möglichkeiten auf ein einzelnes Zeichen in einem String zuzugreifen. Die erste ist die {{jsxref("String.prototype.charAt()", "charAt()")}}-Methode:</p> + +<pre class="brush: js">return 'Katze'.charAt(1); // gibt "a" zurück +</pre> + +<p>Die andere Möglichkeit (eingeführt in ECMAScript 5) ist, den String als ein Array-ähnliches Objekt zu behandlen, in dem einzelne Zeichen zu einem numerischen Index gehören:</p> + +<pre class="brush: js">return 'Katze'[1]; // gibt "a" zurück +</pre> + +<p>Bei einen Zeichenzugriff mittels Klammernotation ist es nicht möglich, einen Wert zu löschen oder zuzuweisen. Die entsprechenden Eigenschaften sind weder überschreibbar noch konfigurierbar. (Siehe {{jsxref("Object.defineProperty()")}} für mehr Informationen.)</p> + +<h3 id="Strings_vergleichen">Strings vergleichen</h3> + +<p>C-Entwicklern steht die <code>strcmp()</code>-Funktion zur Verfügung, um Strings zu vergleichen. In JavaScript können die <a href="https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Vergleichsoperatoren">kleiner-als- und größer-als-Operatoren</a> benutzt werden:</p> + +<pre class="brush: js">var a = 'a'; +var b = 'b'; +if (a < b) { // true + console.log(a + ' ist geringer als ' + b); +} else if (a > b) { + console.log(a + ' ist größer als ' + b); +} else { + console.log(a + ' und ' + b + ' sind gleich.'); +} +</pre> + +<p>Ein ähnliches Ergebnis kann durch die {{jsxref("String.prototype.localeCompare()", "localeCompare()")}}-Methode erzielt werden, die von <code>String</code>-Instanzen übernommen wird.</p> + +<h3 id="Unterscheidung_von_String-Primitives_und_String-Objekten">Unterscheidung von String-Primitives und <code>String</code>-Objekten</h3> + +<p>Es ist zu betonen, dass JavaScript zwischen <code>String</code>-Objekten und primitiven String-Werten unterscheidet. (Das selbe gilt für {{jsxref("Boolean")}} und {{jsxref("Global_Objects/Number", "Numbers")}}.)</p> + +<p>String-Literale (definiert mit doppelten oder einfachen Anführungszeichen) und Strings, die von<code> String</code>-Aufrufen in einem Nicht-Konstruktor-Kontext (z. B. ohne das {{jsxref("Operators/new", "new")}}-Schlüsselwort zu benutzen) zurückgegeben werden, sind String-Primitives. JavaScript wandelt automatisch Primitives zu <code>String</code>-Objekten um, so dass es möglich ist <code>String</code>-Objekt-Methoden für String-Primitives zu nutzen. In Kontexten, in denen eine Methode auf ein String-Primitive bezogen aufgerufen oder eine Eigenschaft eines solchen abgefragt wird, sorgt JavaScript dafür, dass das String-Primitive wie ein Objekt behandelt wird.</p> + +<pre class="brush: js">var s_prim = 'foo'; +var s_obj = new String(s_prim); + +console.log(typeof s_prim); // Loggt "string" +console.log(typeof s_obj); // Loggt "object" +</pre> + +<p>String-Primitives und <code>String</code>-Objekte führen auch bei der Nutzung von {{jsxref("Global_Objects/eval", "eval()")}} zu unterschiedlichen Ergebnissen. An <code>eval</code> übergebene Primitives werden als Quell-Code behandelt; bei <code>String</code>-Objekten wird wie bei allen anderen Objekten das Objekt zurückgegeben. Zum Beispiel:</p> + +<pre class="brush: js">var s1 = '2 + 2'; // erzeugt ein String-Primitive +var s2 = new String('2 + 2'); // erzeugt ein String-Objekt +console.log(eval(s1)); // gibt die Zahl 4 zurück +console.log(eval(s2)); // gibt den String "2 + 2" zurück +</pre> + +<p>Aus diesen Gründen kann Code aufhören zu funktionieren, wenn er <code>String</code>-Objekte bemerkt, obwohl ein String-Primitive erwartet wird. Trotzdem brauchen sich Autoren normalerweise nicht um diesen Unterschied zu kümmern.</p> + +<p>Ein <code>String</code>-Objekt kann mit der {{jsxref("String.prototype.valueOf()", "valueOf()")}}-Methode immer zu seiner Primitive-Entsprechung konvertiert werden.</p> + +<pre class="brush: js">console.log(eval(s2.valueOf())); // gibt die Zahl 4 zurück +</pre> + +<div class="note"><strong>Bemerkung:</strong> Für ein weiteres mögliches Herantreten an Strings in JavaScript sollte der Artikel über <a href="/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — eine C-ähnliche Representation von Strings basierend auf typisierten Arrays</a> gelesen werden.</div> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("String.prototype")}}</dt> + <dd>Ermöglicht das Hinzufügen von Eigenschaften zu einem <code>String</code>-Objekt.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("String.fromCharCode()")}}</dt> + <dd>Gibt einen String zurück, der auf Basis der angegebenen Folge von Unicode-Werten erstellt wurde.</dd> + <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt> + <dd>Gibt einen String zurück, der auf Basis der angegebenen Folge von Code-Points erstellt wurde.</dd> + <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt> + <dd>Gibt einen String zurück, der auf Basis eines Raw-Template-Strings erstellt wurde.</dd> +</dl> + +<h2 id="Generische_String-Methoden">Generische <code>String</code>-Methoden</h2> + +<div class="warning"> +<p><strong>Generische String-Methoden sind nicht Teil des Standards und werden in naher Zukunft entfernt</strong>.</p> +</div> + +<p>Die <code>String</code>-Instanzmethoden stehen nach JavaScript 1.6 (<strong>nicht</strong> Teil des ECMAScript-Standards) auch in Firefox beim <code>String</code>-Objekt zur Verfügung, um <code>String</code>-Methoden auf ein beliebiges Objekt anzuwenden:</p> + +<pre class="brush: js">var num = 15; +console.log(String.replace(num, /5/, '2')); +</pre> + +<p>Über die Auflösung von generischen String-Methoden: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Deprecated_string_generics">Warning: String.x is deprecated; use String.prototype.x instead</a>.</p> + +<p>{{jsxref("Global_Objects/Array", "Generics", "#Array_generic_methods", 1)}} stehen auch bei {{jsxref("Array")}}-Methoden zur Verfügung.</p> + +<h2 id="String-Instanzen"><code>String</code>-Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Properties')}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<h4 id="Nicht_HTML-bezogene_Methoden">Nicht HTML-bezogene Methoden</h4> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Methods_unrelated_to_HTML')}}</div> + +<h4 id="HTML-Wrapper-Methoden">HTML-Wrapper-Methoden</h4> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'HTML_wrapper_methods')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="String-Konvertierung">String-Konvertierung</h3> + +<p>Es ist möglich, <code>String</code> als eine "sicherere" {{jsxref("String.prototype.toString()", "toString()")}}-Alternative zu benutzen, auch, wenn es gewöhnlich weiterhin das zugrundeliegende <code>toString()</code> aufruft. Es funktioniert auch für {{jsxref("null")}}, {{jsxref("undefined")}} und {{jsxref("Symbol", "symbols")}}. Zum Beispiel:</p> + +<pre class="brush: js">var ausgabeStrings = []; +for (var i = 0, n = eingabeWerte.length; i < n; ++i) { + ausgabeStrings.push(String(eingabeWerte[i])); +} +</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">Anmerkung</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Anfängliche Definition</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string-objects', 'String')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string-objects', 'String')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + +<p>{{Compat("javascript.builtins.String.String")}}</p> + +<h2 id="Siehe_außerdem">Siehe außerdem</h2> + +<ul> + <li>{{domxref("DOMString")}}</li> + <li><a href="/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — eine C-ähnliche Representation von Strings basierend auf typisierten Arrays</a></li> + <li><a href="/en-US/docs/Web/API/DOMString/Binary">Binäre Strings</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/indexof/index.html b/files/de/web/javascript/reference/global_objects/string/indexof/index.html new file mode 100644 index 0000000000..dc36abfae8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/indexof/index.html @@ -0,0 +1,200 @@ +--- +title: String.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/indexOf +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>indexOf()</code></strong> Methode gibt den Index der Zeichenkette innerhalb des aufrufenden {{jsxref("Global_Objects/String", "String")}} Objekts des ersten Vorkommnis des angegebenen Wertes beginnend bei <code>fromIndex</code> zurück. Gibt -1 zurück, wenn der Wert nicht gefunden wurde.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.indexOf(<var>searchValue</var>[, <var>fromIndex</var>]</code>)</pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>searchValue</code></dt> + <dd>Ein String der den zu suchenden Wert repräsentiert.</dd> + <dt><code>fromIndex</code> {{optional_inline}}</dt> + <dd>Der Index, von dem angefangen wird vorwärts im String zu suchen. Der Standardwert ist 0, so dass der ganze String durchsucht wird. Wenn <code>fromIndex < 0</code> ist, wird der ganze String durchsucht. Wenn <code>fromIndex >= str.length</code> ist, wird der String nicht durchsucht und -1 wird zurückgegeben. Die Ausnahme ist, wenn für <code>searchValue</code> ein leeren String eingesetzt wird, dann wird <code>str.length</code> zurückgegeben.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Den Index des ersten Vorkommens des gesuchten Wertes; <strong>-1</strong> wenn der Wert nicht gefunden wurde.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die Zeichen in einem String sind von links nach rechts nummeriert. Der Index des ersten Zeichens ist 0, und der Index des letzten Zeichens eines Strings mit Namen <code>stringName</code><code> </code>ist <code>stringName.length - 1</code>.</p> + +<pre class="brush: js">'Blue Whale'.indexOf('Blue'); // returns 0 +'Blue Whale'.indexOf('Blute'); // returns -1 +'Blue Whale'.indexOf('Whale', 0); // returns 5 +'Blue Whale'.indexOf('Whale', 5); // returns 5 +'Blue Whale'.indexOf('', 9); // returns 9 +'Blue Whale'.indexOf('', 10); // returns 10 +'Blue Whale'.indexOf('', 11); // returns 10 +</pre> + +<h3 id="Case-sensitivity" name="Case-sensitivity">Groß- und Kleinschreibung</h3> + +<p>Die <code>indexOf()</code> Methode unterscheidet zwischen Groß- und Kleinschreibung. Zum Beispiel gibt die folgende Zeile -1 zurück:</p> + +<pre class="brush: js">'Blue Whale'.indexOf('blue'); // returns -1 +</pre> + +<h3 id="Vorkommnisse_prüfen">Vorkommnisse prüfen</h3> + +<p>Zu beachten ist, dass '0' nicht zu <code>true</code> und '-1' nicht zu <code>false</code> ausgewertet wird. Deswegen ist der korrekte weg zum überprüfen, ob ein String in einem anderen String existiert, der folgende:</p> + +<pre class="brush: js">'Blue Whale'.indexOf('Blue') != -1; // true +'Blue Whale'.indexOf('Bloe') != -1; // false +</pre> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_indexOf_and_lastIndexOf" name="Example:_Using_indexOf_and_lastIndexOf">Einsatz von <code>indexOf()</code> <code>und lastIndexOf()</code></h3> + +<p>Die folgenden Beispiele benutzen <code>indexOf()</code> und {{jsxref("String.prototype.lastIndexOf()", "lastIndexOf()")}}, um Werte im String <code>"Brave new world"</code> zu finden.</p> + +<pre class="brush: js">var anyString = 'Brave new world'; + +console.log('The index of the first w from the beginning is ' + anyString.indexOf('w')); +// Displays 8 +console.log('The index of the first w from the end is ' + anyString.lastIndexOf('w')); +// Displays 10 + +console.log('The index of "new" from the beginning is ' + anyString.indexOf('new')); +// Displays 6 +console.log('The index of "new" from the end is ' + anyString.lastIndexOf('new')); +// Displays 6 +</pre> + +<h3 id="Case-sensitivity" name="Case-sensitivity"><code>indexOf()</code> und Groß- und Kleinschreibung</h3> + +<p>Das folgende Beispiel definiert zwei Strings. Die Variablen enthalten den selben String, außer dass der zweite String Großbuchstaben enthält. Die erste {{domxref("console.log()")}} Methode zeigt 19. Da die <code>indexOf()</code> Methode Groß- und Kleinschreibung unterscheidet, wird der String<code>"cheddar"</code> im String <code>myCapString</code> nicht gefunden. Deshalb gibt die zweite <code>console.log()</code> Methode -1 zurück.</p> + +<pre class="brush: js">var myString = 'brie, pepper jack, cheddar'; +var myCapString = 'Brie, Pepper Jack, Cheddar'; + +console.log('myString.indexOf("cheddar") is ' + myString.indexOf('cheddar')); +// Displays 19 +console.log('myCapString.indexOf("cheddar") is ' + myCapString.indexOf('cheddar')); +// Displays -1 +</pre> + +<h3 id="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string" name="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string">Einsatz von <code>indexOf()</code>, um das Vorkommen eines Buchstaben in einem String zu zählen</h3> + +<p>Das folgende Beispiel setzt <code>count</code> auf die Anzahl der Vorkommnisse des Buchstaben <code>e</code> in dem String <code>str</code>:</p> + +<pre class="brush: js">var str = 'To be, or not to be, that is the question.'; +var count = 0; +var pos = str.indexOf('e'); + +while (pos != -1) { + count++; + pos = str.indexOf('e', pos + 1); +} + +console.log(count); // displays 4 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/lastindexof/index.html b/files/de/web/javascript/reference/global_objects/string/lastindexof/index.html new file mode 100644 index 0000000000..b6c6f3a548 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/lastindexof/index.html @@ -0,0 +1,148 @@ +--- +title: String.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Zusammenfassung</h2> + +<p>Die <strong><code>lastIndexOf()</code></strong> Methode gibt den Index des letzten Vorkommnisses des angegebenen Wertes innerhalb des aufrufenden {{jsxref("Global_Objects/String", "Strings")}} Objekts zurück, oder -1, wenn der Wert nicht gefunden wurde. Der aufrufende String wird rückwärts durchsucht, beginnend beim <code>fromIndex</code>. </p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.lastIndexOf(<var>searchValue</var>[, <var>fromIndex</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>searchValue</code></dt> + <dd>Ein String mit dem Wert, nach dem gesucht werden soll.</dd> + <dt><code>fromIndex</code></dt> + <dd>Optional. Die Position im aufrufenden String, ab der gesucht rückwärts werden soll. The Position wird gezählt von links nach rechts. Gesucht wird von dieser Position ab nach links. Diese kann jeden Integerwert annehmen. Der Standartwert ist <code>str.length</code>. Wenn der Wert negativ ist, wird 0 verwendet. Wenn <code>fromIndex > str.length</code>, wird <code>str.length </code>statt <code>fromIndex</code> benutzt.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Zeichen in einem String werden von links nach rechts gezählt. Der Index des ersten Zeichens ist 0, der Index des letzten Zeichens ist <code>stringName.length - 1</code>.</p> + +<pre class="brush: js">'canal'.lastIndexOf('a'); // returns 3 +'canal'.lastIndexOf('a', 2); // returns 1 +'canal'.lastIndexOf('a', 0); // returns -1 +'canal'.lastIndexOf('x'); // returns -1 +</pre> + +<h3 id="Case-sensitivity" name="Case-sensitivity">Groß- und Kleinschreibung</h3> + +<p>Die <code>lastIndexOf() </code>Methode unterscheidet zwischen Groß- und Kleinschreibung. Der folgende Ausdruck gibt zum Beispiel <code>-1</code> zurück.</p> + +<pre class="brush: js">'Blue Whale, Killer Whale'.lastIndexOf('blue'); // returns -1 +</pre> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_indexOf_and_lastIndexOf" name="Example:_Using_indexOf_and_lastIndexOf">Beispiel: Benutzung von <code>indexOf()</code> und <code>lastIndexOf()</code></h3> + +<p>Das folgende Beispiel verwendet {{jsxref("String.prototype.indexOf()", "indexOf()")}} und <code>lastIndexOf(),</code> um Werte im String <code>"Brave new world" zu finden</code>.</p> + +<pre class="brush: js">var anyString = 'Brave new world'; + +console.log('The index of the first w from the beginning is ' + anyString.indexOf('w')); +// Displays 8 +console.log('The index of the first w from the end is ' + anyString.lastIndexOf('w')); +// Displays 10 + +console.log('The index of "new" from the beginning is ' + anyString.indexOf('new')); +// Displays 6 +console.log('The index of "new" from the end is ' + anyString.lastIndexOf('new')); +// Displays 6 +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Links</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/length/index.html b/files/de/web/javascript/reference/global_objects/string/length/index.html new file mode 100644 index 0000000000..555d22094a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/length/index.html @@ -0,0 +1,87 @@ +--- +title: String.length +slug: Web/JavaScript/Reference/Global_Objects/String/length +tags: + - JavaScript + - Property + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/length +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>length</code></strong> Eigenschaft repräsentiert die Länge eines Strings.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.length</code></pre> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die <strong><code>length</code></strong> Eigenschaft gibt die Anzahl der Codeteile des Strings zurück. Javascript verwendet {{interwiki("wikipedia", "UTF-16")}}. , also einen 16-Bit Code zur Kodierung der meisten Zeichen, aber zur Darstellung weniger verbreiteter Zeichen werden 2 Codes benötigt. Es ist also durchaus möglich, dass der zurückgegebene Wert nicht der Anzahl der Zeichen in einem String entspricht.</p> + +<p>ECMAScript 2016 (ed. 7) Spezifikation definiert eine maximale Länge von <code>2<sup>53</sup> - 1 </code>Elementen.<br> + Vor dieser Spezifikation war keine maximale Länge an Elementen definiert.</p> + +<p class="syntaxbox">Ein leerer String hat die Länge 0.</p> + +<p>Die statische String-Eigenschaft gibt den Wert 1 zurück.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Basic_usage" name="Example:_Basic_usage">Grundlegende Nutzung</h3> + +<pre class="brush: js">var str = 'Mozilla'; +var leerstr = ''; + +console.log('Mozilla ist ' + str.length + ' Zeichen lang'); +/* "Mozilla ist 7 Zeichen lang" */ + +console.log('Der leere String hat eine Länge von ' + leerstr.length + 'Zeichen'); +/* "Der leere String hat eine Länge von 0 Zeichen" */ +</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 Deinition. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</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.String.length")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li><a class="external" href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">JavaScript <code>String.length</code> and Internationalizing Web Applications</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/match/index.html b/files/de/web/javascript/reference/global_objects/string/match/index.html new file mode 100644 index 0000000000..27bfac9c75 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/match/index.html @@ -0,0 +1,140 @@ +--- +title: String.prototype.match() +slug: Web/JavaScript/Reference/Global_Objects/String/match +tags: + - JavaScript + - Method + - Property + - Reference + - Regular Expression + - String + - match + - Übereinstimmung +translation_of: Web/JavaScript/Reference/Global_Objects/String/match +--- +<div>{{JSRef}}</div> + +<p><strong><code>match()</code></strong> gibt zurück, wo ein regulärer Ausdruck in einem String enthalten ist. </p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.match(<var>regexp</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Ein regulärer Ausdruck. Falls <code>regexp</code> kein Objekt vom Typ {{jsxref("RegExp")}} ist wird es mit Hilfe von <code>new RegExp(obj)</code> konvertiert. Falls dieser Parameter nicht übergeben wird, wird ein {{jsxref("Array")}} mit einem leeren {{jsxref("String")}} zurückgegben: [""].</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Es wird ein {{jsxref("Array")}} zurückgegeben, das als erstes Element den gesamten übereinstimmenden String enthält, gefolgt von allen weiteren Treffern, die in Klammern angegeben wurden. Falls keine Übereinstimmungen gefunden wurden, wird {{jsxref("null")}} zurückgegeben.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Falls der reguläre Ausdruck nicht den Modifikator <code>g</code> enthält, verhält sich <strong><code>match()</code> </strong>wie {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}. Im zurückgegebenen {{jsxref("Array")}} sind zusätzlich die propertys <code>input</code> und <code>index</code> enthalten. <code>input</code> ist gleich dem zu durchsuchenden String, <code>index</code> enthält den Index der Übereinstimmung.</p> + +<p>Falls der <code>g</code> Modifikator im regulären Ausdruck enthalten ist, wird ein {{jsxref("Array")}} mit allen übereinstimmenden Substrings zurückgegeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_match">Verwendung von <code>match()</code></h3> + +<p>Im folgenden Beispiel wird <strong><code>match()</code></strong> verwendet um <code>'Kapitel'</code> und anschließend eine oder mehrere Zahlen, gefolgt von einem Punkt und einer Zahl, 0 oder mehrmals zu finden. Der reguläre Ausdruck enthält den <code>i</code> Modifikator und unterscheidet somit nicht zwischen Groß- und Kleinschreibung.</p> + +<pre class="brush: js notranslate">var str = 'Fuer mehr Informationen siehe Kapitel 3.4.5.1'; +var re = /siehe (kapitel \d+(\.\d)*)/i; +var found = str.match(re); + +console.log(found); + +// gibt folgendes auf der Konsole aus: +// [ 'siehe Kapitel 3.4.5.1', +// 'Kapitel 3.4.5.1', +// '.1', +// index: 22, +// input: 'Fuer mehr Informationen siehe Kapitel 3.4.5.1' ] +</pre> + +<h3 id="Verwendung_von_match_mit_den_i_und_g_Modifikatoren">Verwendung von <code>match()</code> mit den <code>i</code> und <code>g</code> Modifikatoren</h3> + +<p>Die Buchstaben von A - E und von a - e werden auf der Konsole ausgegeben.</p> + +<pre class="brush: js notranslate">var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'; +var regexp = /[A-E]/gi; +var matches_array = str.match(regexp); + +console.log(matches_array); +// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e'] +</pre> + +<h3 id="match_ohne_Parameter"><code>match()</code> ohne Parameter</h3> + +<pre class="brush: js notranslate">var str = "Nichts kommt von nichts."; + +str.match(); +// [""]</pre> + +<h3 id="Verwendung_mit_einem_nicht_regulären_Ausdruck">Verwendung mit einem nicht regulären Ausdruck</h3> + +<p>Falls ein String oder eine Zahl anstatt eines regulären Ausdrucks übergeben wird, wird der Parameter in einen {{jsxref("RegExp", "regulären Ausdruck")}} konvertiert. Ist es eine positive Zahl mit Vorzeichen, wird das positive Vorzeichen ignoriert.</p> + +<pre class="brush: js notranslate">var str1 = "NaN bedeutet not a number. Infinity enthält -Infinity and +Infinity in JavaScript.", + str2 = "Zahlen: 1, 6, 3", + str3 = "null ist ein Datentyp."; + +str1.match("number"); // ["number"] +str1.match(NaN); // ["NaN"] +str1.match(Infinity); // ["Infinity"] +str1.match(+Infinity); // ["Infinity"] +str1.match(-Infinity); // ["-Infinity"] +str2.match(6); // ["6"] +str2.match(+3); // ["3"] +str3.match(null); // ["null"]</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">Extras</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Anfangsdefinition. Implementiert in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.match', 'String.prototype.match')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität">Browser-Kompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.String.match")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("RegExp")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/prototype/index.html b/files/de/web/javascript/reference/global_objects/string/prototype/index.html new file mode 100644 index 0000000000..e2c896b98d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/prototype/index.html @@ -0,0 +1,189 @@ +--- +title: String.prototype +slug: Web/JavaScript/Reference/Global_Objects/String/prototype +tags: + - Eigentum + - JavaScript + - Prototyp + - Referenz + - Strang + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<div>{{JSRef}}</div> + +<p><font><font>Die </font></font><strong><code>String.prototype</code></strong><font><font>Eigenschaft repräsentiert das Prototypobjekt {{jsxref ("String")}}.</font></font></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Beschreibung"><font><font>Beschreibung</font></font></h2> + +<p><font><font>Alle {{jsxref ("String")}} Instanzen erben von </font></font><code>String.prototype</code><font><font>. </font><font>Änderungen am </font></font><code>String</code><font><font>Prototypobjekt werden an alle Instanzen von {{jsxref ("String")}} weitergegeben.</font></font></p> + +<h2 id="Eigenschaften"><font><font>Eigenschaften</font></font></h2> + +<dl> + <dt><code>String.prototype.constructor</code></dt> + <dd><font><font>Gibt die Funktion an, mit der der Prototyp eines Objekts erstellt wird.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.length")}}</font></font></dt> + <dd><font><font>Reflektiert die Länge der Zeichenfolge.</font></font></dd> + <dt><code><em>N</em></code></dt> + <dd><font><font>Wird verwendet, um auf das Zeichen an der </font></font><em><font><font>N-</font></font></em><font><font> ten Position </font><font>zuzugreifen, </font><font>wobei </font></font><em><font><font>N</font></font></em><font><font> eine ganze Zahl zwischen 0 und eins ist, die kleiner als der Wert von {{jsxref ("String.length", "length")} ist. </font><font>Diese Eigenschaften sind schreibgeschützt.</font></font></dd> +</dl> + +<p>Methods</p> + +<h2 id="Methoden"><font><font>Methoden</font></font></h2> + +<h3 id="Methoden_die_nichts_mit_HTML_zu_tun_haben"><font><font>Methoden, die nichts mit HTML zu tun haben</font></font></h3> + +<dl> + <dt><font><font>{{jsxref ("String.prototype.charAt ()")}}</font></font></dt> + <dd><font><font>Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen Index zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.charCodeAt ()")}}</font></font></dt> + <dd><font><font>Gibt eine Zahl zurück, die der UTF-16-Code-Einheitswert am angegebenen Index ist.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.codePointAt ()")}}</font></font></dt> + <dd><font><font>Gibt eine nicht negative Ganzzahl zurück, die der Codepunktwert des UTF-16-codierten Codepunkts ab dem angegebenen Index ist.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.concat ()")}}</font></font></dt> + <dd><font><font>Kombiniert den Text zweier Zeichenfolgen und gibt eine neue Zeichenfolge zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.includes ()")}}</font></font></dt> + <dd><font><font>Legt fest, ob eine Zeichenfolge in einer anderen Zeichenfolge gefunden werden darf.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.endsWith ()")}}</font></font></dt> + <dd><font><font>Bestimmt, ob eine Zeichenfolge mit den Zeichen einer anderen Zeichenfolge endet.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.indexOf ()")}}</font></font></dt> + <dd><font><font>Gibt den Index innerhalb des aufrufenden {{jsxref ("String")}} Objekts des ersten Vorkommens des angegebenen Werts zurück oder -1, falls nicht gefunden.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.lastIndexOf ()")}}</font></font></dt> + <dd><font><font>Gibt den Index innerhalb des aufrufenden {{jsxref ("String")}} Objekts des letzten Vorkommens des angegebenen Werts zurück oder -1, falls nicht gefunden.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.localeCompare ()")}}</font></font></dt> + <dd><font><font>Gibt eine Zahl zurück, die angibt, ob eine Referenzzeichenfolge vor oder nach der angegebenen Zeichenfolge in Sortierreihenfolge steht oder mit dieser übereinstimmt.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.match ()")}}</font></font></dt> + <dd><font><font>Wird verwendet, um einen regulären Ausdruck mit einer Zeichenfolge abzugleichen.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.matchAll ()")}}</font></font></dt> + <dd><font><font>Gibt einen Iterator aller Übereinstimmungen zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.normalize ()")}}</font></font></dt> + <dd><font><font>Gibt die Unicode-Normalisierungsform des aufrufenden Zeichenfolgenwerts zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.padEnd ()")}}</font></font></dt> + <dd><font><font>Füllt die aktuelle Zeichenfolge am Ende mit einer bestimmten Zeichenfolge auf, um aus einer bestimmten Länge eine neue Zeichenfolge zu erstellen.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.padStart ()")}}</font></font></dt> + <dd><font><font>Füllt die aktuelle Zeichenfolge von Anfang an mit einer bestimmten Zeichenfolge auf, um aus einer bestimmten Länge eine neue Zeichenfolge zu erstellen.</font></font></dd> + <dt><s><font><font>{{jsxref ("String.prototype.quote ()")}} {{obsolete_inline}}</font></font></s></dt> + <dd><s><font><font>Umschließt die Zeichenfolge in doppelte Anführungszeichen (" </font></font><code>"</code><font><font>").</font></font></s></dd> + <dt><font><font>{{jsxref ("String.prototype.repeat ()")}}</font></font></dt> + <dd><font><font>Gibt eine Zeichenfolge zurück, die aus den Elementen des Objekts besteht, die zu den angegebenen Zeiten wiederholt wurden.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.replace ()")}}</font></font></dt> + <dd><font><font>Wird verwendet, um eine Übereinstimmung zwischen einem regulären Ausdruck und einer Zeichenfolge zu finden und die übereinstimmende Teilzeichenfolge durch eine neue Teilzeichenfolge zu ersetzen.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.search ()")}}</font></font></dt> + <dd><font><font>Führt die Suche nach einer Übereinstimmung zwischen einem regulären Ausdruck und einer angegebenen Zeichenfolge aus.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.slice ()")}}</font></font></dt> + <dd><font><font>Extrahiert einen Abschnitt einer Zeichenfolge und gibt eine neue Zeichenfolge zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.split ()")}}</font></font></dt> + <dd><font><font>Teilt ein {{jsxref ("Global_Objects / String", "String")}} -Objekt in ein Array von Zeichenfolgen auf, indem die Zeichenfolge in Teilzeichenfolgen aufgeteilt wird.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.startsWith ()")}}</font></font></dt> + <dd><font><font>Legt fest, ob eine Zeichenfolge mit den Zeichen einer anderen Zeichenfolge beginnt.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.substr ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>Gibt die Zeichen in einer Zeichenfolge zurück, die an der angegebenen Position mit der angegebenen Anzahl von Zeichen beginnt.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.substring ()")}}</font></font></dt> + <dd><font><font>Gibt die Zeichen in einer Zeichenfolge zwischen zwei Indizes in die Zeichenfolge zurück.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toLocaleLowerCase ()")}}</font></font></dt> + <dd><font><font>Die Zeichen in einer Zeichenfolge werden unter Berücksichtigung des aktuellen Gebietsschemas in Kleinbuchstaben konvertiert. </font><font>Für die meisten Sprachen wird das Gleiche wie {{jsxref ("String.prototype.toLowerCase ()", "toLowerCase ()")}} zurückgegeben.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toLocaleUpperCase ()")}}</font></font></dt> + <dd><font><font>Die Zeichen in einer Zeichenfolge werden unter Berücksichtigung des aktuellen Gebietsschemas in Großbuchstaben umgewandelt. </font><font>Für die meisten Sprachen wird das Gleiche wie {{jsxref ("String.prototype.toUpperCase ()", "toUpperCase ()")}} zurückgegeben.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toLowerCase ()")}}</font></font></dt> + <dd><font><font>Gibt den aufrufenden Zeichenfolgenwert zurück, der in Kleinbuchstaben konvertiert wurde.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toSource ()")}} {{non-standard_inline}}</font></font></dt> + <dd><font><font>Gibt ein Objektliteral zurück, das das angegebene Objekt darstellt. </font><font>Mit diesem Wert können Sie ein neues Objekt erstellen. </font><font>Überschreibt die Methode {{jsxref ("Object.prototype.toSource ()")}}.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toString ()")}}</font></font></dt> + <dd><font><font>Gibt eine Zeichenfolge zurück, die das angegebene Objekt darstellt. </font><font>Überschreibt die Methode {{jsxref ("Object.prototype.toString ()")}}.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.toUpperCase ()")}}</font></font></dt> + <dd><font><font>Gibt den aufrufenden Zeichenfolgenwert zurück, der in Großbuchstaben konvertiert wurde.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.trim ()")}}</font></font></dt> + <dd><font><font>Schneidet Leerzeichen vom Anfang und Ende der Zeichenfolge ab. </font><font>Teil des ECMAScript 5-Standards.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.trimStart ()")}}</font></font><br> + <font><font>{{jsxref ("String.prototype.trimLeft ()")}}</font></font></dt> + <dd><font><font>Schneidet Leerzeichen vom Anfang der Zeichenfolge ab.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.trimEnd ()")}}</font></font><br> + <font><font>{{jsxref ("String.prototype.trimRight ()")}</font></font></dt> + <dd><font><font>Schneidet Leerzeichen vom Ende der Zeichenfolge ab.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.valueOf ()")}}</font></font></dt> + <dd><font><font>Gibt den Grundwert des angegebenen Objekts zurück. </font><font>Überschreibt die Methode {{jsxref ("Object.prototype.valueOf ()")}}.</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype. @@ iterator ()", "String.prototype [@@ iterator] ()")}}</font></font></dt> + <dd><font><font>Gibt ein neues </font></font><code>Iterator</code><font><font>Objekt zurück, das die Codepunkte eines String-Werts durchläuft und jeden Codepunkt als String-Wert zurückgibt.</font></font></dd> +</dl> + +<h3 id="HTML-Wrapper-Methoden"><font><font>HTML-Wrapper-Methoden</font></font></h3> + +<p><font><font>Diese Methoden sind nur eingeschränkt einsetzbar, da sie nur einen Teil der verfügbaren HTML-Tags und -Attribute bereitstellen.</font></font></p> + +<dl> + <dt><font><font>{{jsxref ("String.prototype.anchor ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{htmlattrxref ("name", "a", "<a name=\"name\">")}} (Hypertext-Ziel)</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.big ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("big")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.blink ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("blinken")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.bold ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("b")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.fixed ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("tt")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.fontcolor ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{htmlattrxref ("color", "font", "<font color = \" color \ ">")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.fontsize ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{htmlattrxref ("size", "font", "<font size = \" size \ ">")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.italics ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("i")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.link ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{htmlattrxref ("href", "a", "<a href=\"url\">")}} (Link zu URL)</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.small ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("small")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.strike ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("strike")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.sub ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("sub")}}</font></font></dd> + <dt><font><font>{{jsxref ("String.prototype.sup ()")}} {{deprecated_inline}}</font></font></dt> + <dd><font><font>{{HTMLElement ("sup")}}</font></font></dd> +</dl> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Anfangsdefinition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser-Kompatibilität"><font><font>Browser-Kompatibilität</font></font></h2> + +<p class="hidden"> <font><font>Die Kompatibilitätstabelle auf dieser Seite wird aus strukturierten Daten generiert. </font><font>Wenn Sie zu den Daten beitragen möchten, lesen Sie bitte </font></font><a href="https://github.com/mdn/browser-compat-data"><font><font>https://github.com/mdn/browser-compat-data</font></font></a><font><font> und senden Sie uns eine Pull-Anfrage.</font></font></p> + +<p>{{Compat("javascript.builtins.String.prototype")}}</p> + +<h2 id="Sieh_auch">Sieh auch</h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/raw/index.html b/files/de/web/javascript/reference/global_objects/string/raw/index.html new file mode 100644 index 0000000000..4405b1b72d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/raw/index.html @@ -0,0 +1,160 @@ +--- +title: String.raw() +slug: Web/JavaScript/Reference/Global_Objects/String/raw +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/raw +--- +<div>{{JSRef}}</div> + +<div>Die statische <strong><code>String.raw()</code></strong> Methode ist eine tag Funktion für <a href="/de/docs/Web/JavaScript/Reference/template_strings">template literale</a> ähnlich dem r Präfix in Python oder dem @ Präfix in C# für String Literale (es gibt jedoch einen Unterschied: siehe in der Beschreibung <a href="https://bugs.chromium.org/p/v8/issues/detail?id=5016">dieses Issues</a>). Es wird verwendet um rohen, unveränderten Text zu verwenden.</div> + +<div> </div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>String.raw(<var>callSite</var>, <var>...substitutions</var>) +String.raw`templateString` +</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>callSite</code></dt> + <dd>Sauber formatiertes template call object, wie <code>{ raw: 'string' }</code>.</dd> + <dt><code>...substitutions</code></dt> + <dd>Enthält Substitutionswerte.</dd> + <dt><code>templateString</code></dt> + <dd>Ein <a href="/de/docs/Web/JavaScript/Reference/template_strings">template string</a>, optional mit Substitutionen (<code>${...}</code>).</dd> +</dl> + +<h3 id="Rückgabewerte">Rückgabewerte</h3> + +<p>Einen rohen, unveränderbaren String des template Strings.</p> + +<h3 id="Auftretende_Errors">Auftretende Errors</h3> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Ein {{jsxref("TypeError")}} wird ausgeworfen wenn das erste Argument nicht sauber formatiert ist.</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Meistens wird <code>String.raw()</code> mit template strings (Vorlagen-Zeichenketten) benutzt. Die erste oben beschriebene Syntax wird kaum benutzt weil die JavaScript engine die Argumente richtig aufrufen wird so wie bei anderen <a href="/de/docs/Web/JavaScript/Reference/template_strings#Tagged_template_strings">tag Funktionen.</a></p> + +<p><code>String.raw()</code> ist die einzige built-in tag function für template strings; Sie funktioniert wie eine default template function und führt concatenation (Verbindung mehrerer Strings zu einem) aus. Man kann sie sogar mit JS code neu schreiben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwendung_von_String.raw()">Verwendung von <code>String.raw()</code></h3> + +<pre class="brush: js">String.raw`Hi\n${2+3}!`; +// 'Hi\\n5!', das Zeichen nach 'Hi' ist kein newline (Zeilenumbruch) Zeichen, +// '\' und 'n' sind zwei Zeichen. + +String.raw`Hi\u000A!`; +// 'Hi\\u000A!', hier genauso, diesmal bekommen wir folgende Zeichen zurrück: +// \, u, 0, 0, 0, A, 6 +// Alle Typen von escape characters (besondere Steuerzeichen) sind ineffektiv +// Backslashes werden unverändert ausgegeben. +// Man kann dies prüfen indem man die .length property des strings abfragt +console.log( String.raw`Hi\u000A!`.length ) // gibt 9 zurrück +console.log( "Hi\u000A!".length ) // gibt 4 zurrück + + +let name = 'Bob'; +String.raw`Hi\n${name}!`; +// 'Hi\\nBob!', Substitutionen werden bearbeitet. + +// Normalerweise ruft man String.raw() nicht als function auf aber man kann +//folgendes: +String.raw({ raw: 'test' }, 0, 1, 2); +// 't0e1s2t' +</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-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>41</td> + <td>{{CompatGeckoDesktop("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>41</td> + <td>{{CompatGeckoMobile("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/template_strings">Template strings</a></li> + <li>{{jsxref("String")}}</li> + <li><a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar">Lexical grammar</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/repeat/index.html b/files/de/web/javascript/reference/global_objects/string/repeat/index.html new file mode 100644 index 0000000000..6008654521 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/repeat/index.html @@ -0,0 +1,286 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Reference/Global_Objects/String/repeat +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Referenz + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>repeat()</code></strong>-Funktion erzeugt und gibt eine Zeichenkette zurück, die die spezifizierte Anzahl von Kopien der angegebenen Zeichenkette aneinandergereiht enthält.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.repeat(<var>Anzahl</var>);</code> +</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>Anzahl</code></dt> + <dd>Eine Zahl zwischen 0 und +∞: [0, +∞), die die Anzahl Kopien der Ursprungszeichenkette in der neu erzeugten Zeichenkette definiert.</dd> +</dl> + +<h3 id="Rückgabeergebnis">Rückgabeergebnis</h3> + +<p>Eine neue Zeichenkette mit der angegebenen Anzahl an Kopien der vorgegebenen Zeichenkette.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<ul> + <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: die Wiederholungsanzahl darf nicht negativ sein.</li> + <li>{{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: die Anzahl an Wiederholungen darf nicht unendlich sein und die maximale Zeichenkettenlänge nicht überschreiten.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">'abc'.repeat(-1); // Parameterfehler +'abc'.repeat(0); // '' +'abc'.repeat(1); // 'abc' +'abc'.repeat(2); // 'abcabc' +'abc'.repeat(3.5); // 'abcabcabc' (Anzahl wird in einen ganzzahligen Integer umgewandelt) +'abc'.repeat(1/0); // Parameterfehler + +({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2); +// 'abcabc' (repeat() ist eine generische Methode) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Funktion wurde zur ECMAScript 2015 Spezifikation hinzugefügt und steht unter Umständen noch nicht in allen JavaScript-Implementierungen zur Verfügung. Bedarfsweise können Sie die Methode <code>String.prototype.repeat()</code> durch folgenden Code zur Verfügung stellen:</p> + +<pre class="brush: js">if (!String.prototype.repeat) { + String.prototype.repeat = function(count) { + 'use strict'; + if (this == null) { + throw new TypeError('can\'t convert ' + this + ' to object'); + } + var str = '' + this; + count = +count; + if (count != count) { + count = 0; + } + if (count < 0) { + throw new RangeError('repeat count must be non-negative'); + } + if (count == Infinity) { + throw new RangeError('repeat count must be less than infinity'); + } + count = Math.floor(count); + if (str.length == 0 || count == 0) { + return ''; + } + // Ensuring count is a 31-bit integer allows us to heavily optimize the + // main part. But anyway, most current (August 2014) browsers can't handle + // strings 1 << 28 chars or longer, so: + if (str.length * count >= 1 << 28) { + throw new RangeError('repeat count must not overflow maximum string size'); + } + var rpt = ''; + for (var i = 0; i < count; i++) { + rpt += str; + } + return rpt; + } +} +</pre> + +<h4 id="Polyfill_ES5">Polyfill ES5</h4> + +<pre class="syntaxbox">//#es5 +'use strict'; +(function(win){ + var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o && typeof(o)==='function' && typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x && x.constructor===o && x!==p?'symbol':typeof x}};return f})(win), + exist=function(o,p,t){return p in o && typeOf(o[p])===t}; + (function(w){ + var o=w.String.prototype; + if(!exist(o,'repeat','function')){o.repeat=(function(A,E){return function(n){var i=n>>0,s=this,l=s.length,j;if(i===0||l<1){s=''}else{j=268435456;if(i<0||i>=j||i*l>j){throw new RE('Invalidcountvalue')}else if(i>0){s=A(++i).join(s)}};return s}})(w.Array,w.RangeError)}; + })(win); +})(window); + +//test: +console.clear(); +console.log( +'abc'.repeat(false),//'' +'abc'.repeat({}),//'' +'abc'.repeat([]),//'' +'abc'.repeat(['']),//'' +'abc'.repeat([0]),//'' +'abc'.repeat([0,1]),//'' +'abc'.repeat([1,1]),//'' +'abc'.repeat(0),//'' +'abc'.repeat(.6),//'' +'abc'.repeat(true),//'abc' +'abc'.repeat(1),//'abc' +'abc'.repeat(2),//'abcabc' +'abc'.repeat([2]),//'abcabc' +'abc'.repeat(3.5),//'abcabcabc' +''.repeat(2)//'' +); +console.log( +'abc'.repeat(-Infinity),//RangeError: Invalid count value +'abc'.repeat(Infinity),//RangeError: Invalid count value +'abc'.repeat(1/0),//RangeError: Invalid count value +'abc'.repeat(-1)//RangeError: Invalid count value +); + +/* +es5 src: +'use strict'; +(function(win){ + + var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o && typeof(o)==='function' && typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x && x.constructor===o && x!==p?'symbol':typeof x}};return f})(win), + exist=function(o,p,t){return p in o && typeOf(o[p])===t}; + + (function(w){ + var o=w.String.prototype; + if(!exist(o,'repeat','function')){ + o.repeat=(function(A,E){ + return function(n){ + var i=n>>0,s=this,l=s.length,j; + if(i===0||l<1){s=''}else{ + j=268435456; + if(i<0||i>=j||i*l>j){throw new RE('Invalidcountvalue')}else if(i>0){s=A(++i).join(s)} + }; + return s + }; + })(w.Array,w.RangeError); + }; + //.. + })(win); + +})(window); +*/ +</pre> + +<h4 id="Polyfill_ES6">Polyfill ES6</h4> + +<pre class="syntaxbox">//#es6 + +(w=>{ + + const typeOf=(o=>{let f=x=>typeof x;if(o && 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=>x && x.constructor===o && x!==p?s:typeof x}};return f})(w.Symbol), + + exist=(o,p,t)=>p in o && typeOf(o[p])===t; + + (o=>{ + + if(!exist(o,'repeat','function')){const A=w.Array,E=w.RangeError;o.repeat=function(n){var i=n>>0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i<0||i>=(t=268435456)||i*l>t){throw new E('Invalid count value')}else if(i>0){s=A(++i).join(t)}}};return s}}; + + })(w.String.prototype); + +})(window); + +/* + +es6 src: + +(w=>{ + + const typeOf=(o=>{let f=x=>typeof x;if(o && 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=>x && x.constructor===o && x!==p?s:typeof x}};return f})(w.Symbol), + + exist=(o,p,t)=>p in o && typeOf(o[p])===t; + + + (o=>{ + + if(!exist(o,'repeat','function')){ + + const A=w.Array; + + o.repeat=function(n){var i=n>>0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i<0||i>=(t=268435456)||i*l>t){throw new RangeError('Invalid count value')}else if(i>0){s=A(++i).join(t)}}};return s}; + + }; + + //.. + + })(w.String.prototype); + + +})(window); + +*/ + + +//test: + +console.clear(); + +console.log( + +'abc'.repeat(false),//'' + +'abc'.repeat({}),//'' + +'abc'.repeat([]),//'' + +'abc'.repeat(['']),//'' + +'abc'.repeat([0]),//'' + +'abc'.repeat([0,1]),//'' + +'abc'.repeat([1,1]),//'' + +'abc'.repeat(0),//'' + +'abc'.repeat(.6),//'' + +'abc'.repeat(true),//'abc' + +'abc'.repeat(1),//'abc' + +'abc'.repeat(2),//'abcabc' + +'abc'.repeat([2]),//'abcabc' + +'abc'.repeat(3.5),//'abcabcabc' + +''.repeat(2)//'' + +); + +console.log( + +'abc'.repeat(-Infinity),//RangeError: Invalid count value + +'abc'.repeat(Infinity),//RangeError: Invalid count value + +'abc'.repeat(1/0),//RangeError: Invalid count value + +'abc'.repeat(-1)//RangeError: Invalid count 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-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Erste Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</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.String.repeat")}}</p> diff --git a/files/de/web/javascript/reference/global_objects/string/replace/index.html b/files/de/web/javascript/reference/global_objects/string/replace/index.html new file mode 100644 index 0000000000..c375d3d1f6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/replace/index.html @@ -0,0 +1,344 @@ +--- +title: String.prototype.replace() +slug: Web/JavaScript/Reference/Global_Objects/String/replace +tags: + - Expressions + - JavaScript + - Method + - Prototype + - Reference + - Regular + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/replace +--- +<p>{{JSRef}}<br> + Die <code><strong>replace()</strong></code>-Methode gibt eine neue Zeichenkette zurück, in der einige oder alle Übereinstimmungen mit einem <code>Muster</code> durch einen <code>Ersatz</code> ausgetauscht wurden. Das <code>Muster</code> kann eine Zeichenkette oder eine RegExp sein, als <code>Ersatz </code>dienen eine Zeichenkette oder eine Funktion, welche für jede Übereinstimmung aufgerufen wird.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><em>str</em>.replace(<em>regexp|substr</em>, <em>newSubStr|function</em></code><code>);</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Ein {{jsxref("Global_Objects/RegExp", "RegExp")}}-Objekt. Die Übereinstimmung wird durch den Rückgabewert aus Parameter #2 ersetzt.</dd> +</dl> + +<dl> + <dt><code>substr</code></dt> + <dd>Eine {{jsxref("Global_Objects/String", "Zeichenkette")}}, welche durch <code>newSubStr</code> ersetzt werden soll. Nur das erste Vorkommen wird ersetzt.</dd> +</dl> + +<dl> + <dt><code>newSubStr</code></dt> + <dd>Die {{jsxref("Global_Objects/String", "Zeichenkette")}}, welche den Substring aus Parameter #1 ersetzt. Eine Anzahl spezieller Ersetzungsmuster wird unterstützt, siehe den "<a href="#Eine_Zeichenkette_als_Parameter_angeben">Eine Zeichenkette als Parameter angeben</a>"-Abschnitt weiter unten.</dd> +</dl> + +<dl> + <dt><code>function</code></dt> + <dd>Eine Funktion, welche aufgerufen wird, um den neuen Substring zu erzeugen, der an Stelle des gefundenen Substrings aus Parameter #1 stehen soll. Die Argumente für diese Funktion werden im "<a href="#Eine_Funktion_als_Parameter_angeben">Eine Funktion als Parameter angeben</a>"-Abschnitt unten erläutert.</dd> +</dl> + +<h3 id="Rückgabe">Rückgabe</h3> + +<p>Eine neue Zeichenkette, in der einige oder alle Übereinstimmungen mit einem Muster durch einen Ersatz ausgetauscht wurden.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Diese Methode ändert nicht das <code>String</code>-Objekt, auf welchem sie aufgerufen wird. Sie gibt lediglich einen neuen String zurück.</p> + +<p>Um ein globales Suchen und Ersetzen durchzuführen, setzen Sie den <code>g</code>-Umschalter im Regulären Ausdruck.</p> + +<h3 id="Eine_Zeichenkette_als_Parameter_angeben" name="Eine_Zeichenkette_als_Parameter_angeben">Eine Zeichenkette als Parameter angeben</h3> + +<p>Die Ersatzzeichenkette kann folgende spezielle Ersetzungsmuster beinhalten:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Pattern</td> + <td class="header">Inserts</td> + </tr> + <tr> + <td><code>$$</code></td> + <td>Fügt ein "$" ein.</td> + </tr> + <tr> + <td><code>$&</code></td> + <td>Fügt den gefundenen Substring ein.</td> + </tr> + <tr> + <td><code>$`</code></td> + <td>Fügt den Stringteil vor dem gefundenen Substring ein.</td> + </tr> + <tr> + <td><code>$'</code></td> + <td>Fügt den Stringteil nach dem gefundenen Substring ein.</td> + </tr> + <tr> + <td style="white-space: nowrap;"><code>$<em>n</em></code></td> + <td>Mit <code><em>n</em></code> als nicht negative ganze Zahl kleiner als 100 wird der <em>n</em>te eingeklammerte Submatch-String eingefügt, der im ersten Argument in der <code>RegExp</code> angegeben wurde.</td> + </tr> + </tbody> +</table> + +<h3 id="Eine_Funktion_als_Parameter_angeben" name="Eine_Funktion_als_Parameter_angeben">Eine Funktion als Parameter angeben</h3> + +<p>Sie können eine Funktion als zweiten Parameter angeben. In diesem Fall wird diese Funktion aufgerufen, nachdem die Suche ausgeführt wurde. Der Rückgabewert der Funktion wird als Ersatz eingesetzt. (Anmerkung: Die oben genannten speziellen Ersetzungsmuster werden in diesem Fall <em>nicht</em> beachtet.) Bedenken Sie, dass die Funktion für jede Übereinstimmung erneut aufgerufen wird, wenn der reguläre Ausdruck im ersten Parameter den global-Flag gesetzt hat.</p> + +<p>Die Argumente dieser Funktion lauten wie folgt:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Möglicher Name</td> + <td class="header">Gelieferter Wert</td> + </tr> + <tr> + <td><code>match</code></td> + <td>Der gefundene Substring. (Entspricht $& oben.)</td> + </tr> + <tr> + <td><code>p1, p2, ...</code></td> + <td>Der <em>n</em>th eingeklammerte Submatch-String, fall im ersten Argument ein <code>RegExp-Objekt</code> angegeben wurde. (Entspricht $1, $2, etc. oben.) Wurde zum Beispiel <code>/(\a+)(\b+)/ angegeben, so ist</code> <code>p1</code> die Übereinstimmung für<code> \a+</code>, und <code>p2</code> für <code>\b+</code>.</td> + </tr> + <tr> + <td><code>offset</code></td> + <td>Die Position, an welcher der gefundene Substring innerhalb der gesamten Zeichenkette gefunden wurde. War zum Beispiel die gesamte Zeichenkette <code>"abcd"</code> und der gefundene Substring <code>"bc"</code>, dann wäre das Argument <code>1</code>.)</td> + </tr> + <tr> + <td style="white-space: nowrap;"><code>string</code></td> + <td>Die gesamte Zeichenkette, welche durchsucht wird.</td> + </tr> + </tbody> +</table> + +<p>(Die genaue Anzahl der Argumente hängt davon ab, ob das erste Argument eine <code>RegExp</code> war und wieviele eingeklammerte Submatches in diesem Fall angegeben wurden.)</p> + +<p>Das folgende Beispiel wird <code>newString </code>auf <code>"<span class="console-formatted-string source-code">abc - 12345 - #$*%</span>"</code> setzen:</p> + +<pre class="brush: js">function replacer(match, p1, p2, p3, offset, string){ + // p1 is nondigits, p2 digits, and p3 non-alphanumerics + return [p1, p2, p3].join(' - '); +} +newString = "abc12345#$*%".replace(/([^\d]*)(\d*)([^\w]*)/, replacer); +</pre> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example_Defining_the_regular_expression_in_replace" name="Example:_Defining_the_regular_expression_in_replace">Beispiel: Definieren des regulären Ausdrucks in <code>replace</code></h3> + +<p>Globales Ersetzen kann nur mit einem regulären Ausdruck durchgeführt werden. Im folgenden Beispiel wird der reguläre Ausdruck in <code>replace</code> definiert und beinhaltet den Schalter <code>ignore case</code>.</p> + +<pre class="brush: js">var str = "Twas the night before Xmas..."; +var newstr = str.replace(/xmas/i, "Christmas"); +print(newstr); +</pre> + +<p>Dies erzeugt die Ausgabe "Twas the night before Christmas..."</p> + +<h3 id="Example_Using_global_and_ignore_with_replace" name="Example:_Using_global_and_ignore_with_replace">Beispiel: Nutzung von <code>global</code> und <code>ignore</code> mit <code>replace</code></h3> + +<p>Das nachfolgende Beispiel enthält einen regulären Ausdruck, der sowohl das <code>global</code> als auch das <code>ignore</code> Flag gesetzt hat. Dadurch wird von <code>replace</code> jedes Vorkommnis von 'apples' in der Zeichenkette durch 'oranges' ersetzt.</p> + +<pre class="brush: js">var re = /apples/gi; +var str = "Apples are round, and apples are juicy."; +var newstr = str.replace(re, "oranges"); +print(newstr); +</pre> + +<p>Dies erzeugt die Ausgabe "oranges are round, and oranges are juicy."</p> + +<h3 id="Beispiel_Vertausche_Wörter_in_Strings">Beispiel: Vertausche Wörter in Strings</h3> + +<p>Im folgenden Skript werden die Wörter in dem String getauscht. Für die Vertauschung im Text nutzt das Skript die Ersetzungspatterns <code>$1</code> und <code>$2</code>.</p> + +<pre class="brush: js">var re = /(\w+)\s(\w+)/; +var str = "John Smith"; +var newstr = str.replace(re, "$2, $1"); +print(newstr); +</pre> + +<p>Die Ausgabe ist: "Smith, John".</p> + +<h3 id="Example_Using_an_inline_function_that_modifies_the_matched_characters" name="Example:_Using_an_inline_function_that_modifies_the_matched_characters">Beispiel: Nutzung von Inline-Funktionen, die die erkannten Zeichen modifizieren</h3> + +<p>In diesem Beispiel werden alle Großbuchstaben durch einen Bindestrich und den entsprechenden Kleinbuchstaben ersetzt. Der wichtige Punkt in dem Beispiel ist, dass der Additions-Operator (Konkatination) vor dem Zurückgeben der neuen Zeichenkette erfolgen muss.</p> + +<p>Die Ersetzungsfunktion bekommt das erkannte Muster als Parameter übergeben und benutzt diesen, um den Buchstaben zu transformieren und ihn mit dem Bindestrich zu verbinden. Zum Schluss wird das Ergebnis zum Ersetzen zurückgegeben.</p> + +<pre class="brush: js">function styleHyphenFormat(propertyName) { + function upperToHyphenLower(match) { + return '-' + match.toLowerCase(); + } + return propertyName.replace(/[A-Z]/g, upperToHyphenLower); +} +</pre> + +<p>Gegeben <code>styleHyphenFormat('borderTop')</code>, gibt 'border-top' zurück.</p> + +<p>Weil das Ergebnis transformiert werden soll, bevor die finale Ersetzung durchgeführt wird, muss eine Funktion eingesetzt werden. Dieses erzwingt die Ausführung von <code>toLowerCase()</code>. Wenn man das gleiche versucht ohne eine Funktion zu benutzen, wird die toLowerCase() Methode ohne Wirkung sein.</p> + +<pre class="brush: js">var newString = propertyName.replace(/[A-Z]/g, '-' + '$&'.toLowerCase()); // won't work +</pre> + +<p>Dieses ist weil <code>'$&'.toLowerCase()</code> ausgeführt wird, bevor der String als Pattern genutzt wird.</p> + +<h3 id="Example_Replacing_a_Fahrenheit_degree_with_its_Celsius_equivalent" name="Example:_Replacing_a_Fahrenheit_degree_with_its_Celsius_equivalent">Beispiel: Grad Fahrenheit in Celsius-Grad umwandeln</h3> + +<p>Das folgende Beispiel ersetzt einen Wert in Grad Fahrenheit durch den entsprechenden Celsius-Wert. Der Fahrenheitwert sollte eine Nummer sein, die mit einem F endet. Die Funktion gibt eine Celsius-Temperatur mit der Endung C aus. Ist zum Beispiel der Eingabewert 212F, so gibt die Funktion 100C zurück. Ist die Nummer 0F, so wird -17,77777777777778C zurück gegeben.</p> + +<p>Der reguläre Ausdruck <code>test</code> prüft jede Nummer, die mit F endet. Die Nummer in Grad Fahrenheit ist durch den zweiten Funktionsparameter, <code>p1</code>, ansprechbar. Die Funktion setzt den Celsiuswert basierend auf dem Fahrenheitwert in einer Zeichenkette in der <code>f2c</code>-Funktion. <code>f2c gibt dann den Celsiuswert zurück. Diese Funktion </code>ähnelt dem s///e-Flag in Perl.</p> + +<pre class="brush: js">function f2c(x) { + function convert(str, p1, offset, s) { + return ((p1-32) * 5/9) + "C"; + } + var s = String(x); + var test = /(\d+(?:\.\d*)?)F\b/g; + return s.replace(test, convert); +} +</pre> + +<h3 id="Example_Use_an_inline_function_with_a_regular_expression_to_avoid_for_loops" name="Example: Use an inline function with a regular expression to avoid for loops" style="line-height: 24px;">Beispiel: Verwenden einer inline-Funktion mit einem regulärem Ausdruck um Schleifen zu vermeiden</h3> + +<p>Das folgende Beispiel nimmt eine Zeichenkettenmuster und konvertiert es in ein Array von Objekten.</p> + +<p><strong>Eingabe:</strong><br> + Eine Zeichenkette, die aus den Zeichen x, - und _ besteht</p> + +<pre>x-x_ +x---x---x---x--- +x-xxx-xx-x- +x_x_x___x___x___</pre> + +<div><strong><span style="line-height: 1.5;">Ausgabe:</span></strong></div> + +<div><span style="line-height: 1.5;">Ein Array mit Objekten. Ein 'x' zeigt einen 'an'-Status an, ein '-' (Bindestrich) symbolisiert einen 'aus'-Status und ein '_' (Unterstrich) gibt die Länge des 'an'-Status an.</span></div> + +<pre class="brush: json"><span style="line-height: 1.5;">[</span> + { on: true, length: 1 }, + { on: false, length: 1 }, + { on: true, length: 2 } + ... +]</pre> + +<div><strong>Ausschnitt:</strong></div> + +<div> +<pre class="brush: js">var str = 'x-x_'; +var retArr = []; +str.replace(/(x_*)|(-)/g, function(match, p1, p2){ + if(p1) retArr.push({ on: true, length: p1.length }); + if(p2) retArr.push({ on: false, length: 1 }); +}); + +console.log(retArr);</pre> +</div> + +<div>Der Ausschnitt generiert ein Array mit drei Objekten im gewünschten Format, ohne eine Schleife zu verwenden.</div> + +<div></div> + +<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.<br> + Implementiert in JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Eigenschaft</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Firefox-spezifische_Bemerkungen">Firefox-spezifische Bemerkungen</h2> + +<ul> + <li>Mit dem Start von Gecko 27 {{geckoRelease(27)}}, wurde diese Methode an die ECMAScript Spezifikation angepasst. Wenn <code>replace()</code> mit einem globalen regulären Ausdruck aufgerufen wird, wird die {{jsxref("RegExp.lastIndex")}} Eigenschaft (wenn sie Spezifiziert wurde) auf 0 zurückgesetzt ({{bug(501739)}}).</li> + <li>Mit dem Start von Gecko 39 {{geckoRelease(39)}} wurden das nicht standardisierte <code>flags</code> Argument als deprecated markiert und wirft eine Warnung in der Konsole ({{bug(1142351)}}).</li> + <li>Mit dem Start von Gecko 47 {{geckoRelease(47)}} wurden das nicht standardisierte <code>flags</code> Argument nicht länger in <span class="short_text" id="result_box" lang="de"><span>Nicht-</span><span>Release-Builds</span></span> unterstützt und wird bald vollständig entfernt ({{bug(1245801)}}).</li> + <li>Mit dem Start von Gecko 49 {{geckoRelease(49)}} wurden das nicht standardisierte <code>flags</code> Argument nicht mehr unterstützt ({{bug(1108382)}}).</li> +</ul> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/slice/index.html b/files/de/web/javascript/reference/global_objects/string/slice/index.html new file mode 100644 index 0000000000..d30b18e21f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/slice/index.html @@ -0,0 +1,152 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/String/slice +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>slice()</code></strong> Methode extrahiert einen Teilbereich eines Strings und gibt einen neuen String zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.slice(<var>AnfangIndex</var>[, E<var>ndIndex</var>])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>AnfangIndex</code></dt> + <dd>Der nullbasierte Index von welchem mit der Extraktion begonnen wird. Wenn dieser negativ ist, wird er als <code>strLength + AnfangIndex, </code>wobei <code>strLength</code> die länge des Strings darstellt, (bspw., wenn <code>AnfangIndex</code> <code>-3</code> ist, wird es als <code>strLength - 3 gewertet</code>). Wenn <code>beginIndex</code><em> </em>größer oder gleich length des Strings ist, gibt <code>slice()</code> einen leeren String zurück.</dd> + <dt><code>EndIndex</code></dt> + <dd>Optional. Der nullbasierte Index <em>vor</em> welchem die Extraktion beendet wird. Der Charakter an diesem Index wird nicht mit einbezogen. Wenn <code>EndIndex </code>ausgelassen wird, extrahiert <code>slice()</code> bis zum Ende des Strings. Wenn <code>EndIndex </code>negativ ist, wird es wie <code>strLength + EndIndex</code> gewertet, wobei strLength sich auf die Länge des Strings bezieht (z.B.: wenn E<code>ndIndex</code> <code>-3 ist, wird es gewertet wie </code><code>strLength - 3).</code></dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Ein neuer String, welcher die extrahierte Sektion des Strings enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>slice()</code> extrahiert den Text eines Strings und gibt einen neuen zurück. Änderungen im einen String wirken sich nicht auf den anderen String aus.</p> + +<p><code>slice()</code> extrahiert bis, aber nicht einschließlich, <code>EndIndex. </code><code>str.slice(1, 4)</code> extrahiert den zweiten Charakter bis zum vierten (Character mit den Indexen 1, 2, und 3).</p> + +<p>Als Beispiel, <code>str.slice(2, -1)</code> extrahiert den dritten Charakter bis zum zweiten, bis zum letzten Charakter im String.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzen_von_slice()_um_einen_neuen_String_zu_erzeugen"><code>Benutzen von slice()</code> um einen neuen String zu erzeugen</h3> + +<p>Das folgende Beispiel benutzt <code>slice()</code> um einen neuen String zu erzeugen.</p> + +<pre class="brush: js">var str1 = 'The morning is upon us.', // the length of str1 is 23. + str2 = str1.slice(1, 8), + str3 = str1.slice(4, -2), + str4 = str1.slice(12), + str5 = str1.slice(30); +console.log(str2); // OUTPUT: he morn +console.log(str3); // OUTPUT: morning is upon u +console.log(str4); // OUTPUT: is upon us. +console.log(str5); // OUTPUT: "" +</pre> + +<h3 id="Benutzen_von_slice()_mit_negativen_Indexen">Benutzen von <code>slice()</code> mit negativen Indexen</h3> + +<p>Das folgende Beispiel benutzt <code>slice()</code> mit negativen Indexen.</p> + +<pre class="brush: js">var str = 'The morning is upon us.'; +str.slice(-3); // returns 'us.' +str.slice(-3, -1); // returns 'us' +str.slice(0, -1); // returns 'The morning is upon us' +</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.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_kompatibilität">Browser kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> + <li>{{jsxref("Array.prototype.slice()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/split/index.html b/files/de/web/javascript/reference/global_objects/string/split/index.html new file mode 100644 index 0000000000..cfea09cc76 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/split/index.html @@ -0,0 +1,212 @@ +--- +title: String.prototype.split() +slug: Web/JavaScript/Reference/Global_Objects/String/split +translation_of: Web/JavaScript/Reference/Global_Objects/String/split +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>split()</code></strong> Methode teilt ein {{jsxref("String")}} Objekt in ein Array von Strings auf, indem der String in Teilstrings zerteilt wird, wobei ein angegebenes Trennzeichen verwendet wird, um zu bestimmen, wo die Aufteilung erfolgen soll.</p> + +<p>{{EmbedInteractiveExample("pages/js/string-split.html")}}</p> + +<h2 id="Summary" name="Summary">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.split([<var>separator</var>[, <var>limit</var>]])</code></pre> + +<div class="blockIndicator warning"> +<p>Achtung: Wenn leerer ein String ("") als Trennzeichen verwendet wird, wird der String <strong>nicht</strong> zwischen jedem <em>vom Benutzer wahrgenommenen Zeichen</em> (<a href="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries">Graphem-Cluster</a>) oder zwischen jedem Unicode-Zeichen (Codepoint) aufgeteilt, sondern zwischen jeder UTF-16-Codeeinheit. Dadurch werden <a href="http://unicode.org/faq/utf_bom.html#utf16-2">Ersatzpaare</a> (surrogate pairs) zerstört. Siehe auch <a href="https://stackoverflow.com/a/34717402">How do you get a string to a character array in JavaScript?</a> auf Stack Overflow.</p> +</div> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>separator</code> {{optional_inline}}</dt> + <dd>Ein String, der die Punkte angibt, an denen jede Aufteilung erfolgen soll. <code>separator</code> wird als Zeichenfolge oder als {{jsxref("Global_Objects/RegExp", "regulärer Ausdruck", "", 1)}} behandelt. Wenn ein Nur-Text <code>separator</code> mehr als ein Zeichen enthält, muss der gesamte String gefunden werden, damit eine Trennung erfolgt. Wenn <code>separator</code> nicht angegeben wird oder in <code>str</code> nicht vorkommt, enthält das zurückgegebene Array ein Element, das den gesamten String enthält. Wenn <code>separator</code> ein leerer String ist, wird jedes Zeichen von <code>str</code> in ein Array-Element umgewandelt.</dd> + <dt><code>limit</code> {{optional_inline}}</dt> + <dd>Ganzzahl, die ein Limit für die Anzahl der zu findenden Splits angibt. Wenn dieser Parameter angegeben wird, teilt die <code>split()</code> Methode die Zeichenfolge bei jedem Vorkommen des angegebenen <code>separator</code> auf, stoppt jedoch, nachdem die Anzahl von <code>limit</code> erreicht wurde. Es können immer noch weniger Einträge als <code>limit</code> enthalten sein, wenn das Ende des Strings erreicht wurde, bevor das angegebene Limit erreicht wird. Der übrig gebliebene Text wird im neuen Array nicht enthalten sein.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein {{jsxref("Array")}} mit Strings, welcher an jedem Punkt aufgeteilt wurde, an dem das Trennzeichen in der angegebenen Zeichenfolge aufgetreten ist.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Wenn gefunden, wird <code>separator</code> aus dem String entfernt und die Teilstrings werden in einem Array zurückgegeben. Wenn <code>separator</code> nicht gefunden oder weggelassen wird, enthält das Array ein Element, das aus dem gesamten String besteht. Wenn <code>separator</code> ein leerer String ist, wird <code>str</code> in ein Array aus Zeichen umgewandelt. Wenn <code>separator</code> am Anfang, Ende oder Anfang und Ende eines Strings gefunden wird, beginnt, endet oder beginnt und endet das Array mit einem leeren String. Besteht ein String daher nur aus einem einzigen Vorkommnis von <code>separator</code> besteht, besteht das Array also aus zwei leeren Strings.</p> + +<p>Wenn <code>separator</code> ein regulärer Ausdruck ist, der runde Klammern enthält, werden die Ergebnisse (einschließlich etwaiger undefinierter Ergebnisse) der Klammern bei jeder Übereinstimmung von <code>separator</code> in das ausgegebene Array eingefügt.</p> + +<div class="blockIndicator note"> +<p><strong>Hinweis:</strong> Wenn <code>separator</code> ein Array ist, wird das Array in einen String umgewandelt und als Trennzeichen verwendet.</p> +</div> + +<div class="blockIndicator note"> +<p><strong>Hinweis:</strong> Wenn der String leer ist, gibt <code>split()</code> ein Array zurück, das einen leeren String anstelle eines leeren Arrays enthält. Wenn sowohl der String als auch das Trennzeichen leere Zeichenfolgen sind, wird ein leeres Array zurückgegeben.</p> +</div> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_split" name="Example:_Using_split">Verwendung von <code>split()</code></h3> + +<p>Im folgenden Beispiel wird eine Funktion definiert, die einen String mithilfe des angegebenen Trennzeichens in ein Array aus Strings aufteilt. Nach dem Aufteilen des Strings protokolliert die Funktion Meldungen, die den ursprüngliche String angeben (vor der Aufteilung), das verwendete Trennzeichen, die Anzahl der Elemente im Array und die einzelnen Arrayelemente.</p> + +<pre class="brush: js">function splitString(stringToSplit, separator) { + var arrayOfStrings = stringToSplit.split(separator); + + console.log('The original string is: "' + stringToSplit + '"'); + console.log('The separator is: "' + separator + '"'); + console.log('The array has ' + arrayOfStrings.length + ' elements: ' + arrayOfStrings.join(' / ')); +} + +var tempestString = 'Oh brave new world that has such people in it.'; +var monthString = 'Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec'; + +var space = ' '; +var comma = ','; + +splitString(tempestString, space); +splitString(tempestString); +splitString(monthString, comma);</pre> + +<p>Das Beispiel erzeugt den folgende Ausgabe:</p> + +<pre class="brush: js">The original string is: "Oh brave new world that has such people in it." +The separator is: " " +The array has 10 elements: Oh / brave / new / world / that / has / such / people / in / it. + +The original string is: "Oh brave new world that has such people in it." +The separator is: "undefined" +The array has 1 elements: Oh brave new world that has such people in it. + +The original string is: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec" +The separator is: "," +The array has 12 elements: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec</pre> + +<h3 id="Example:_Removing_spaces_from_a_string" name="Example:_Removing_spaces_from_a_string">Leerzeichen aus einem String entfernen</h3> + +<p>Im folgenden Beispiel sucht <code>split()</code> nach 0 oder mehr Leerzeichen, gefolgt von einem Semikolon und 0 oder mehr Leerzeichen. Wenn es sie findet, entfernt es die Leerzeichen aus dem String. <code>nameList</code> ist das Array, was als Ergebnis von <code>split() zurückgegeben wird</code>.</p> + +<pre class="brush: js">var names = 'Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand '; + +console.log(names); + +var re = /\s*(?:;|$)\s*/; +var nameList = names.split(re); + +console.log(nameList);</pre> + +<p>Dies protokolliert zwei Zeilen. Die erste Zeile protokolliert die ursprüngliche Zeichenfolge und die zweite Zeile das resultierende Array.</p> + +<pre>Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand +[ "Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand", "" ] +</pre> + +<h3 id="Example:_Returning_a_limited_number_of_splits" name="Example:_Returning_a_limited_number_of_splits">Eine begrenzte Anzahl von Trennungen zurückgeben</h3> + +<p>Im folgenden Beispiel sucht <code>split()</code> nach 0 oder mehr Leerzeichen im String und gibt die ersten 3 Treffer zurück, die es findet.</p> + +<pre class="brush: js">var myString = 'Hello World. How are you doing?'; +var splits = myString.split(' ', 3); + +console.log(splits);</pre> + +<p>Dieses Skript gibt folgendes aus:</p> + +<pre>["Hello", "World.", "How"] +</pre> + +<h3 id="Teilen_mit_einer_RegExp_um_Teile_des_Trennzeichens_in_das_Ergebnis_aufzunehmen">Teilen mit einer <code>RegExp</code>, um Teile des Trennzeichens in das Ergebnis aufzunehmen</h3> + +<p>Wenn <code>separator</code> ein regulärer Ausdruck ist, der runde Klammern <code>()</code> enthält, werden übereinstimmende Ergebnisse in das Array aufgenommen.</p> + +<pre class="brush: js">var myString = 'Hello 1 word. Sentence number 2.'; +var splits = myString.split(/(\d)/); + +console.log(splits);</pre> + +<p>Dieses Skript gibt folgendes aus:</p> + +<pre class="brush: js">[ "Hello ", "1", " word. Sentence number ", "2", "." ]</pre> + +<p> </p> + +<h3 id="Teilen_mit_einem_Array_als_Trennzeichen">Teilen mit einem Array als Trennzeichen</h3> + +<p> </p> + +<pre class="brush: js">var myString = 'this|is|a|Test'; +var splits = myString.split(['|']); + +console.log(splits); //["this", "is", "a", "Test"] + +var myString = 'ca,bc,a,bca,bca,bc'; + +var splits = myString.split(['a','b']); +// myString.split(['a','b']) ist dasselbe wie myString.split(String(['a','b'])) + +console.log(splits); //["c", "c,", "c", "c", "c"]</pre> + +<h3 id="Example:_Reversing_a_String_using_split" name="Example:_Reversing_a_String_using_split">Einen String mit <code>split()</code> umkehren</h3> + +<div class="blockIndicator warning"> +<p>Dies ist keine robuste Art einen String umzukehren.</p> + +<pre class="brush: js">var str = 'asdfghjkl'; +var strReverse = str.split('').reverse().join(''); // 'lkjhgfdsa' +// split() returns an array on which reverse() and join() can be applied +</pre> + +<p>Das funktioniert nicht, wenn der String Graphem-Cluster enthält, selbst wenn ein Unicode-fähiger Split verwendet wird (verwenden Sie stattdessen bspw. <a href="https://github.com/mathiasbynens/esrever">esrever</a>).</p> + +<pre class="brush: js">var str = 'résumé'; +var strReverse = str.split(/(?:)/u).reverse().join(''); +// => "́emuśer" +</pre> + +<p><strong>Bonus:</strong> Verwenden Sie sen {{jsxref("Operators/Comparison_Operators", "===", "#Identity_.2F_strict_equality_(.3D.3D.3D)")}} Operator um zu testen, ob der ursprüngliche String ein Palindrom war.</p> +</div> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<p>{{Compat("javascript.builtins.String.split")}}</p> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("Array.prototype.join()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/startswith/index.html b/files/de/web/javascript/reference/global_objects/string/startswith/index.html new file mode 100644 index 0000000000..adbb0dce44 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/startswith/index.html @@ -0,0 +1,150 @@ +--- +title: String.prototype.startsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/startsWith +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Prototype + - Referenz + - String + - protype +translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith +--- +<div>{{JSRef}}</div> + +<p>Die <strong>startsWith()-</strong>Methode stellt fest, ob ein String mit den Zeichen eines anderen Strings beginnt, falls dies so ist, wird <code>true</code>, sonst wird <code>false</code> zurückgegeben. </p> + +<pre class="syntaxbox"><code><var>str</var>.startsWith(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>searchString</code></dt> + <dd>Die Zeichenfolge, nach der am Anfang des Strings gesucht wird.</dd> + <dt><code>position</code></dt> + <dd>Optional. Die Position, an der die Suche nach <code>searchString</code> begonnen werden soll. Der Standardwert ist 0.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p><strong>true</strong> wenn der String mit den Zeichen aus dem übergebenen String beginnt, andernfalls <strong>false</strong>.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Diese Methode dient dazu herauszufinden, ob ein String am Anfang eines anderen Strings steht. Die Methode unterscheidet Groß- und Kleinschreibung.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_startsWith">Benutzung von <code>startsWith()</code></h3> + +<pre class="brush: js">//startsWith +var str = 'Sein oder nicht sein, das ist hier die Frage'; + +console.log(str.startsWith('Sein oder')); // true +console.log(str.startsWith('nicht sein')); // false +console.log(str.startsWith('nicht sein', 10)); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Diese Methode ist Bestandteil der ECMAScript-6-Spezifikation. Dennoch kann es vorkommen, dass sie noch nicht in allen Javascript-Implementierungen vorhanden ist. Man kann ihre Funktionsweise allerdings mit folgendem Ausdruck emulieren:</p> + +<pre class="brush: js">if (!String.prototype.startsWith) { + String.prototype.startsWith = function(searchString, position) { + position = position || 0; + return this.indexOf(searchString, position) === position; + }; +} +</pre> + +<p>Eine robustere und schnellerer (optimierte) Version findet sich <a href="https://github.com/mathiasbynens/String.prototype.startsWith">auf GitHub, geschrieben von Mathias Bynens</a>.</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('ES2015', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<h2 id="CompatibilityTable"><span style="font-size: 14px; font-weight: normal; line-height: 1.5;">{{CompatibilityTable}}</span></h2> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Edge</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("41")}}</td> + <td>{{CompatGeckoDesktop("17")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>28</td> + <td>{{CompatSafari("9")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("36")}}</td> + <td>{{CompatGeckoMobile("17")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="sect1"> </h2> + +<p>Zu beachten ist, dass die MSDN Dokumentation für diese Methode (<a href="https://msdn.microsoft.com/de/library/mt146831(v=vs.94).aspx">https://msdn.microsoft.com/en-us/library/mt146831(v=vs.94).aspx</a>) besagt, das es nicht im Internet Explorer unterstützt wird.</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.endsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/substr/index.html b/files/de/web/javascript/reference/global_objects/string/substr/index.html new file mode 100644 index 0000000000..354d417ea9 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/substr/index.html @@ -0,0 +1,171 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Reference/Global_Objects/String/substr +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +--- +<div>{{JSRef}}</div> + +<p>Die Methode <strong><code>substr()</code></strong> gibt die Zeichen eines Strings in einem gegebenen Intervall zurück.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.substr(<var>start</var>[, <var>length</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>start</code></dt> + <dd>Ort im String, an dem mit dem Extrahieren von Zeichen begonnen wird. Wird eine negative Zahl übergeben, wird sie als <code>str.length - start</code> behandelt (Wenn <code>start</code> z. B. -3 ist, wird es als <code>str.length - 3</code> behandelt).</dd> + <dt><code>length</code></dt> + <dd>Optional. Die Anzahl der Zeichen, die extrahiert werden sollen.</dd> +</dl> + +<h3 id="Description" name="Description">Rückgabewert</h3> + +<p>Einen neuen String, der den extrahierten Bereich des gegebene Strings enthält. Wenn <strong><code>length</code> <code>0</code></strong> oder negativ ist, wird ein leerer String zurückgegeben.</p> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>start</code> ist ein Zeichenindex. Der Index des ersten Zeichens ist 0 und der Index des letzten Zeichens ist 1 weniger als die Länge des Strings. <code>substr()</code>fängt mit dem Extrahieren von Zeichen bei <code>start</code> an und extrahiert <code>length</code> Zeichen (es sei denn, es erreicht vorher das Ende des Strings, dann gibt es weniger zurück).</p> + +<p>Wenn <code>start</code> positiv ist und größer gleich der Länge des Strings ist, gibt <code>substr()</code> einen leeren String zurück.</p> + +<p>Wenn <code>start</code> negativ ist, verwendet <code>substr()</code> es als Zeichenindex vom Ende des Strings. Wenn <code>start</code> negativ ist und <code>abs(start)</code> größer als die Länge des Strings ist, verwendet <code>substr()</code> 0 als Zeichenindex. Anmerkung: Der beschriebene Umgang mit negativen Werten für <code>start</code> wird von Microsoft JScript nicht unterstützt.</p> + +<p>Wenn <code>length</code> 0 oder negativ ist, gibt <code>substr()</code> einen leeren String zurück. Wenn <code>length</code> nicht übergeben wird, extrahiert <code>substr()</code> alle Zeichen bis zum Ende des Strings.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_substr" name="Example:_Using_substr">Verwenden von <code>substr()</code></h3> + +<pre class="brush: js">var str = 'abcdefghij'; + +console.log('(1, 2): ' + str.substr(1, 2)); // '(1, 2): bc' +console.log('(-3, 2): ' + str.substr(-3, 2)); // '(-3, 2): hi' +console.log('(-3): ' + str.substr(-3)); // '(-3): hij' +console.log('(1): ' + str.substr(1)); // '(1): bcdefghij' +console.log('(-20, 2): ' + str.substr(-20, 2)); // '(-20, 2): ab' +console.log('(20, 2): ' + str.substr(20, 2)); // '(20, 2): ' +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p>Microsofts JScript unterstützt keine negativen Werte für den Startindex. Der folgende Kompatibilitätscode ist ein Workaround für diesen Bug:</p> + +<pre class="brush: js">// Nur verwenden, wenn die substr()-Funktion nicht funktioniert +if ('ab'.substr(-1) != 'b') { + /** + * Einen Teilstring erhalten + * @param {integer} start Startindex des Teilstrings + * @param {integer} length Länge des Teilstrings + * @return {string} + */ + String.prototype.substr = function(substr) { + return function(start, length) { + // Aufruf der Originalfunktion + return substr.call(this, + // Wenn start negativ ist, berechnen wie viel start + // vom Anfang des Strings ist + start < 0 ? this.length + start : start, + length); + } + }(String.prototype.substr); +} +</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>Im (informativen) Anhang B "Compatibility" definiert. Implementiert in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Im (informativen) Anhang B "Compatibility" definiert.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Im (normativen) Anhang B "Additional ECMAScript Features for Web Browsers" definiert.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Im (normativen) Anhang B "Additional ECMAScript Features for Web Browsers" definiert.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Grundlegende Unterstützung</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.slice()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/substring/index.html b/files/de/web/javascript/reference/global_objects/string/substring/index.html new file mode 100644 index 0000000000..4ed1e33959 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/substring/index.html @@ -0,0 +1,199 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Reference/Global_Objects/String/substring +tags: + - Funktion + - JavaScript + - Method + - Methode(2) + - Méthode + - Prototype + - Reference + - Referenz + - Référence(2) + - String + - Zeichenkette +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Definition</h2> + +<p>Die <strong><code>substring()</code></strong> Methode gibt einen Teilstring eines <code>Strings</code> zwischen einem Index und einem anderen, oder dem Ende der Zeichenkette zurück.</p> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.substring(<var>indexA</var>[, <var>indexB</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>indexA</code></dt> + <dd>Ein Integer zwischen <code>0</code> und der Länge der Zeichenkette, welcher das erste Zeichen des Teilstrings repräsentiert.</dd> + <dt><code>indexB</code></dt> + <dd>Optional. Ein Integer zwischen <code>0</code> und der Länge der Zeichenkette, welcher das erste nicht im Teilstring enthaltene Zeichen darstellt.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>substring()</code> extrahiert Zeichen von <code>indexA</code> bis nicht einschließlich <code>indexB</code>. Im Detail:</p> + +<ul> + <li>Falls <code>indexA</code> gleich <code>indexB ist</code>, gibt <code>substring()</code> einen leeren String zurück.</li> + <li>Falls <code>indexB</code> nicht angegeben ist, extrahiert <code>substring()</code> alle Zeichen bis zum Ende der Zeichenkette.</li> + <li>Falls eines der Argumente kleiner als 0 oder {{jsxref("Global_Objects/NaN", "NaN")}} ist, wird dieser als 0 interpretiert.</li> + <li>Falls eines der Argumente größer als die Länge der Zeichenkette ist, wird dieses als <code>stringName.length behandelt</code>.</li> +</ul> + +<p>Falls <code>indexA</code> größer als <code>indexB ist</code>, werden die Argumente vertauscht <code>substring()</code>; zum Beispiel, <code><em>str</em>.substring(1, 0) == <em>str</em>.substring(0, 1)</code>.</p> + +<h2 id="Examples" name="Examples">Beispiele</h2> + +<h3 id="Example:_Using_substring" name="Example:_Using_substring">Beispiel: Benutzung von <code>substring()</code></h3> + +<p>Das folgende Beispiel benutzt <code>substring()</code>, um Zeichen des Strings <code>'Mozilla' anzuzeigen</code>:</p> + +<pre class="brush: js">var anyString = 'Mozilla'; + +// Zeigt 'Moz' +console.log(anyString.substring(0, 3)); +console.log(anyString.substring(3, 0)); + +// Zeigt 'lla' +console.log(anyString.substring(4, 7)); +console.log(anyString.substring(7, 4)); + +// Zeigt 'Mozill' +console.log(anyString.substring(0, 6)); + +// Zeigt 'Mozilla' +console.log(anyString.substring(0, 7)); +console.log(anyString.substring(0, 10)); +</pre> + +<h3 id="Example:_Using_substring_with_length_property" name="Example:_Using_substring_with_length_property">Beispiel: Benutzung von <code>substring()</code> mit <code>length</code> Eigenschaft</h3> + +<p>Das folgende Beispiel benutzt die <code>substring()</code> Methode und die {{jsxref("String.length", "length")}} Eigenschaft, um die letzten Zeichen des Strings zu extrahieren. Diese Methode ist leichter zu merken, da die genauen Start- und Endparameter nicht bekannt sein müssen.</p> + +<pre class="brush: js">// Zeigt 'illa' - die letzten 4 Zeichen +var anyString = 'Mozilla'; +var anyString4 = anyString.substring(anyString.length - 4); +console.log(anyString4); + +// Zeigt 'zilla' - die letzten 5 Zeichen +var anyString = 'Mozilla'; +var anyString5 = anyString.substring(anyString.length - 5); +console.log(anyString5); +</pre> + +<h3 id="Example:_Replacing_a_substring_within_a_string" name="Example:_Replacing_a_substring_within_a_string">Beispiel: Ersetze ein Teilstring mit einem String</h3> + +<p>Das folgende Beispiel ersetzt ein Teilstring mit einem String. Es werden sowohhl einzelne Zeichen als auch Teilstrings ersetzt. Der Funktionsaufruf am Ende des Beispiel ändert die Zeichenkette <code>'Brave New World'</code> in <code>'Brave New Web'</code>.</p> + +<pre class="brush: js">// Ersetzt oldS mit newS in der Zeichenkette fullS +function replaceString(oldS, newS, fullS) { + for (var i = 0; i < fullS.length; ++i) { + if (fullS.substring(i, i + oldS.length) == oldS) { + fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length); + } + } + return fullS; +} + +replaceString('World', 'Web', 'Brave New World'); +</pre> + +<p>Beachte, dass dieses Beispiel auch in einer Endlosschleife resultieren kann, wenn <code>oldS</code> ein Teilstring von <code>newS</code> ist — zum Beispiel, falls 'World' mit 'OtherWorld' ersetzt wird. Der folgende Code zeigt ein bessere Methode Strings zu ersetzen:</p> + +<pre class="brush: js">function replaceString(oldS, newS, fullS) { + return fullS.split(oldS).join(newS); +} +</pre> + +<p>Der oben stehende Code zeigt ein Beispiel für die Verwendung der substring Operation. Falls Teilstrings ersetzt werden, kann in den meisten Fällen {{jsxref("String.prototype.replace()")}} verwendet werden.</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>ECMAScript 1. Edition.</td> + <td>Standard</td> + <td>In JavaScript 1.0 implementiert.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Standard Support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Standard Support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.slice()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/suchen/index.html b/files/de/web/javascript/reference/global_objects/string/suchen/index.html new file mode 100644 index 0000000000..5fb838010a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/suchen/index.html @@ -0,0 +1,105 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Reference/Global_Objects/String/suchen +tags: + - JavaScript + - Méthode + - Prototyp + - Referenz + - Regulärer Ausdruck + - Zeichenkette +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>search()</code></strong> methode führt eine Suche für eine Übereinstimmung von einem Regulären Ausdruck und diesem {{jsxref("String")}} Objekt.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-search.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.search(<var>regexp</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Ein Regulär-Ausdruck Objekt. Wenn ein nicht-RegExp Objekt <code>obj</code> eingereicht wird, wird es durch <code>new RegExp(obj)</code> zu {{jsxref("RegExp")}} konvertiert.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Die erste übereinstimmung zwischen dem Regulären Audruck und und der gegebenen Zeichenkette; wenn nicht gefunden, <strong>-1</strong>.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Wenn du wissen willst ob ein Muster gefunden wurde, und was sein Index ist nutze <code>search()</code> (wenn du nur wissen willst ob es das gibt nutze die ähnliche {{jsxref("RegExp.prototype.test()", "test()")}} Methode auf dem RegExp Prototyp, der einen boolean zurückgibt); für mehr informationen (aber langsamererere Ausführung) nutze {{jsxref("String.prototype.match()", "match()")}} (ähnlich zum Ausdruck {{jsxref("RegExp.prototype.exec()", "exec()")}}).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_search">Benutzung von <code>search()</code></h3> + +<p>Das folgende Beispiel durchsucht eine Zeichenkette mit 2 verschiedenen regex Objekten, um eine erfolgreiche, und unerfolgreiche Suche zu zeigen.</p> + +<pre class="brush: js">var str = "hey LukE"; +var re = /[A-Z]/g; +var re2 = /[.]/g; +console.log(str.search(re)); // gibt 4 zurück, was der Index des ersten Großbuchstaben "L" ist. +console.log(str.search(re2)); // gibt -1 zurück kann "." nicht finden</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>Initielle Definition. Eingeführt in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilitä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.String.search")}}</p> + +<h2 id="Gecko-spezifische_Hinweise">Gecko-spezifische Hinweise</h2> + +<ul> + <li><code>flags</code> war ein nicht-standard Zweitargument nur in Gecko verfügbar: <var>str</var>.search(<var>regexp, flags</var>)</li> + <li>Vorher {{Gecko("8.0")}}, <code>search()</code> war falsch eingeführt; wenn es ohne oder mit {{jsxref("undefined")}} parametern Ausgeführt wurde, würde es mit 'undefined' übereinstimmen, anstatt mit einer leeren Zeichenkette übereinzustimmen. Das wurde behoben; jetzt ist <code>'a'.search()</code> und <code>'a'.search(undefined)</code> korrekt und geben 0 zurück.</li> + <li>Ab Gecko 39 {{geckoRelease(39)}}, gibt das nicht-Standard <code>flag</code> Argument eine Konsolenwarnung ({{bug(1142351)}}).</li> + <li>Ab Gecko 47 {{geckoRelease(47)}}, ist das nicht-Standard <code>flag</code> Argument nicht länger unterstützt in nicht-veröffentlichten Builds und wird bald vollständig entfernt ({{bug(1245801)}}).</li> + <li>Ab Gecko 49 {{geckoRelease(49)}}, ist das nicht-Standard <code>flag</code> Argument nicht länger unterstützt ({{bug(1108382)}}).</li> +</ul> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/de/web/javascript/reference/global_objects/string/tolowercase/index.html new file mode 100644 index 0000000000..f3eb4d9f68 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/tolowercase/index.html @@ -0,0 +1,79 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +tags: + - JavaScript + - Method + - Prototype + - Referenz + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>toLowerCase()</code></strong> Methode gibt den Wert des aufrufenden Strings in Kleinbuchstaben umgewandelt zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.toLowerCase()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer String, der den alten String konvertiert zu Kleinbuchstaben enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toLowerCase()</code> Methode gibt den Wert des Strings in Kleinbuchstaben umgewandelt zurück. <code>toLowerCase()</code> hat keine Auswirkungen auf den Wert des Strings <code>str</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_toLowerCase()">Benutzung von <code>toLowerCase()</code></h3> + +<pre class="brush: js">console.log('ALPHABET'.toLowerCase()); // 'alphabet' +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</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.String.toLowerCase")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/touppercase/index.html b/files/de/web/javascript/reference/global_objects/string/touppercase/index.html new file mode 100644 index 0000000000..c221990e73 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/touppercase/index.html @@ -0,0 +1,127 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +--- +<div> +<div>{{JSRef}}</div> + +<p>Die <strong><code>toUpperCase()</code></strong> Methode gibt den Wert des aufrufenden Strings in Großbuchstaben umgewandelt zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.toUpperCase()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer String, der den alten String konvertiert zu Großbuchstaben enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>toUpperCase()</code> Methode gibt den Wert des Strings in Großbuchstaben umgewandelt zurück. <code>toUpperCase()</code> hat keine Auswirkungen auf den Wert des Strings <code>str</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Benutzung_von_toUpperCase()">Benutzung von <code>toUpperCase()</code></h3> + +<pre class="brush: js">console.log('alphabet'.toUpperCase()); // 'ALPHABET' +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> +</ul> +</div> diff --git a/files/de/web/javascript/reference/global_objects/string/trim/index.html b/files/de/web/javascript/reference/global_objects/string/trim/index.html new file mode 100644 index 0000000000..59ada93228 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/trim/index.html @@ -0,0 +1,93 @@ +--- +title: String.prototype.trim() +slug: Web/JavaScript/Reference/Global_Objects/String/Trim +tags: + - ECMAScript 5 + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim +--- +<div>{{JSRef}}</div> + +<p>Die<strong><code> trim()</code></strong> Methode entfernt Leerzeichen an beiden Enden einer Zeichenfolge. Das betrifft Leerzeichen verschiedenster Art (space, tab, no-break space, etc.) und alle Zeilenumbruch einleitende Zeichen (LF, CR, etc.).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>str</var>.trim()</pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuer String, der den gegebenen String ohne Whitespaces am Anfang und am Ende enthält.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>trim()</code> Methode gibt eine Zeichenfolge ohne Leerzeichen an beiden Enden zurück. <code>trim()</code> beeinflusst oder verändert nicht den ursprünglichen Wert der Zeichenfolge.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="trim()_verwenden"><code>trim()</code> verwenden</h3> + +<p>Das folgende Beispiel zeigt die kleingeschriebene Zeichenfolge <strong><code>'foo'</code></strong>:</p> + +<pre class="brush: js">var orig = ' foo '; +console.log(orig.trim()); // 'foo' + +// Ein Beispiel bei dem .trim() Leerzeichen an einem Ende entfernt + +var orig = 'foo '; +console.log(orig.trim()); // 'foo' +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Führe folgenden Code vor allem anderen aus um die Methode <strong><code>trim()</code></strong> zu erstellen sollte sie nativ nicht zur Verfügung stehen.</p> + +<pre class="brush: js">if (!String.prototype.trim) { + String.prototype.trim = function () { + return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); + }; +} +</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('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.8.1.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.trim', 'String.prototype.trim')}}</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.String.trim")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li> + <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/trimleft/index.html b/files/de/web/javascript/reference/global_objects/string/trimleft/index.html new file mode 100644 index 0000000000..db5dbd55cb --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/trimleft/index.html @@ -0,0 +1,58 @@ +--- +title: String.prototype.trimLeft() +slug: Web/JavaScript/Reference/Global_Objects/String/TrimLeft +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimStart +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <strong><code>trimLeft()</code></strong> Methode entfernt Leerzeichen vom linken Ende der Zeichenkette.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.trimLeft()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuen String, der den alten String ohne Whitespaces auf der linken Seite beinhaltet.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>trimLeft()</code> Methode gibt die Zeichenkette ohne Leerzeichen am linken Ende zurück. <code>trimLeft()</code> manipuliert nicht den Wert der Zeichenkette.</p> + +<h2 id="Beispiel">Beispiel</h2> + +<h3 id="trimLeft()_verwenden"><code>trimLeft()</code> verwenden</h3> + +<p>Im folgenden Beispiel wird die Funktionalität dieser Methode dargestellt.</p> + +<pre class="brush: js; highlight: [5]">var str = ' foo '; + +console.log(str.length); // 8 + +str = str.trimLeft(); +console.log(str.length); // 5 +console.log(str); // 'foo ' +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Gehört keinem Standard an. Hinzugefügt in JavaScript 1.8.1.</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.String.trimLeft")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/string/trimright/index.html b/files/de/web/javascript/reference/global_objects/string/trimright/index.html new file mode 100644 index 0000000000..b66e15f474 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/string/trimright/index.html @@ -0,0 +1,58 @@ +--- +title: String.prototype.trimRight() +slug: Web/JavaScript/Reference/Global_Objects/String/TrimRight +tags: + - JavaScript + - Method + - Prototype + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>Die <strong><code>trimRight()</code></strong> Methode entfernt Leerzeichen vom rechten Ende der Zeichenkette.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>str</var>.trimRight()</code></pre> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein neuen String, der den alten String ohne Whitespaces auf der rechten Seite beinhaltet.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die <code>trimRight()</code> Methode gibt die Zeichenkette ohne Leerzeichen am rechten Ende zurück. <code>trimRight()</code> manipuliert nicht den Wert der Zeichenkette.</p> + +<h2 id="Beispiel">Beispiel</h2> + +<h3 id="trimRight()_verwenden"><code>trimRight()</code> verwenden</h3> + +<p>Im folgenden Beispiel wird die Funktionalität dieser Methode dargestellt.</p> + +<pre class="brush: js; highlight: [5]">var str = ' foo '; + +console.log(str.length); // 8 + +str = str.trimRight(); +console.log(str.length); // 6 +console.log(str); // ' foo' +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Gehört keinem Standard an. Hinzugefügt in JavaScript 1.8.1.</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.String.trimRight")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/syntaxerror/index.html b/files/de/web/javascript/reference/global_objects/syntaxerror/index.html new file mode 100644 index 0000000000..4b4edda7c5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/syntaxerror/index.html @@ -0,0 +1,133 @@ +--- +title: SyntaxError +slug: Web/JavaScript/Reference/Global_Objects/SyntaxError +tags: + - Error + - JavaScript + - Object + - Reference + - SyntaxError +translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError +--- +<div>{{JSRef}}</div> + +<p>Das <code><strong>SyntaxError</strong></code> Objekt repräsentiert einen Fehler, der auftritt, wenn versucht wird syntaktisch falschen Quelltext zu interpretieren.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Ein <code>SyntaxError</code> wird erzeugt, wenn die JavaScript-Umgebung Quelltextstücke entdeckt, die nicht der Syntax der Sprachdefinition von JavaScript entspricht.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new SyntaxError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Optional. Für Menschen lesbare Beschreibung des Fehlers.</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Optional. Der Name der Datei, in der der Fehler erzeugt wurde.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Optional. Die Zeilennummer, in der der Fehler erzeugt wurde.</dd> +</dl> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("SyntaxError.prototype")}}</dt> + <dd>Erlaubt es Eigenschaften zu allen <code>SyntaxError</code> Objekten hinzuzufügen.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p>Das globale <code>SyntaxError</code>-Objekt enthält keine eigenen Methoden. Jedoch erbt das Objekt einige Methoden durch die Prototypenkette.</p> + +<h2 id="SyntaxError_Instanzen"><code>SyntaxError</code> Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype', 'Methoden')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Auffangen_eines_SyntaxError">Auffangen eines <code>SyntaxError</code></h3> + +<pre class="brush: js">try { + eval('hoo bar'); +} catch (e) { + console.log(e instanceof SyntaxError); // true + console.log(e.message); // "missing ; before statement" + console.log(e.name); // "SyntaxError" + console.log(e.fileName); // "Scratchpad/1" + console.log(e.lineNumber); // 1 + console.log(e.columnNumber); // 4 + console.log(e.stack); // "@Scratchpad/1:2:3\n" +} +</pre> + +<h3 id="Erzeugen_eines_SyntaxError">Erzeugen eines <code>SyntaxError</code></h3> + +<pre class="brush: js">try { + throw new SyntaxError('Hello', 'someFile.js', 10); +} catch (e) { + console.log(e instanceof SyntaxError); // true + console.log(e.message); // "Hello" + console.log(e.name); // "SyntaxError" + console.log(e.fileName); // "someFile.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:11:9\n" +} +</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.4', 'SyntaxError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-syntaxerror', 'SyntaxError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-syntaxerror', 'SyntaxError')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.SyntaxError")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("SyntaxError.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/syntaxerror/prototype/index.html b/files/de/web/javascript/reference/global_objects/syntaxerror/prototype/index.html new file mode 100644 index 0000000000..10ae05f755 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/syntaxerror/prototype/index.html @@ -0,0 +1,88 @@ +--- +title: SyntaxError.prototype +slug: Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype +tags: + - Error + - JavaScript + - Property + - Prototype + - SyntaxError +translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>SyntaxError.prototype</strong></code> Eigenschaft repräsentiert die Eigenschaft die Eigenschaft für den {{jsxref("SyntaxError")}} Konstruktor.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Alle {{jsxref("SyntaxError")}} Instanzen erben von <code>SyntaxError.prototype</code>. Man kann den Prototypen einsetzen, um Eigenschaften oder Methoden für allen Instanzen hinzuzufügen.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>SyntaxError.prototype.constructor</code></dt> + <dd>Spezifiziert die Funktion, die einen Instanz des Prototypen erstellt.</dd> + <dt>{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}</dt> + <dd>Fehlermeldung. Obwohl ECMA-262 Spezifiziert, dass {{jsxref("SyntaxError")}} eine eigene <code>message</code> Eigenschaft haben sollte, erbt dieser in <a href="/de/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> die Eigenschaft {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}</dt> + <dd>Fehlername. Vererbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}</dt> + <dd>Pfad zur Datei, in der der Fehler erzeugt wurde. Vererbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}</dt> + <dd>Zeilennummer, in der der Fehler erzeugt wurde. Vererbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}</dt> + <dd>Spaltennummer, in der der Fehler erzeugt wurde. Vererbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}} {{non-standard_inline}}</dt> + <dd>Stack trace. Vererbt von {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p>Obwohl das {{jsxref("SyntaxError")}} Prototypobjekt keine Methoden enthält, haben {{jsxref("SyntaxError")}} Instanzen einige Vererbte Methoden durch die Prototypenkette.</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.SyntaxError")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/typeerror/index.html b/files/de/web/javascript/reference/global_objects/typeerror/index.html new file mode 100644 index 0000000000..609c799d77 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/typeerror/index.html @@ -0,0 +1,133 @@ +--- +title: TypeError +slug: Web/JavaScript/Reference/Global_Objects/TypeError +tags: + - Error + - JavaScript + - Object + - Reference + - TypeError +translation_of: Web/JavaScript/Reference/Global_Objects/TypeError +--- +<div>{{JSRef}}</div> + +<p>Das <code><strong>TypeError</strong></code> Objekt repräsentiert einen Fehler, wenn ein Wert nicht dem erwartetem Typ enspricht.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new TypeError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Optional. Beschreibung des Fehlers</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Optional. Name der Datei, welches den Fehlerverursachenden Code beinhaltet</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Optional. Zeilennummer des Codes, welches den Fehler verursacht</dd> +</dl> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Ein <code>TypeError</code> wird generiert, wenn ein an eine Funktion mitgegebener Operand oder Argument, inkompatibel dem erwartetem Typ ist.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt>{{jsxref("TypeError.prototype")}}</dt> + <dd>Erlaubt das Hinzufügen von Eigenschaften an einem <code>TypeError</code> Objekt.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p>Die Globale <code>TypeError</code> kennt keine eigene Methode, jedoch erbt diese einige Methoden durch die Prototype-Kette.</p> + +<h2 id="TypeError_Instanzen"><code>TypeError</code> Instanzen</h2> + +<h3 id="Eigenschaften_2">Eigenschaften</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/TypeError/prototype', 'Eigenschaften')}}</div> + +<h3 id="Methoden_2">Methoden</h3> + +<div>{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/TypeError/prototype', 'Methoden')}}</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Abfangen_eines_TypeError">Abfangen eines <code>TypeError</code></h3> + +<pre class="brush: js">try { + null.f(); +} catch (e) { + console.log(e instanceof TypeError); // true + console.log(e.message); // "null hat keine Eigenschaften" + console.log(e.name); // "TypeError" + console.log(e.fileName); // "Scratchpad/1" + console.log(e.lineNumber); // 2 + console.log(e.columnNumber); // 2 + console.log(e.stack); // "@Scratchpad/2:2:3\n" +} +</pre> + +<h3 id="Erzeugen_eines_TypeError">Erzeugen eines <code>TypeError</code></h3> + +<pre class="brush: js">try { + throw new TypeError('Hallo', "someFile.js", 10); +} catch (e) { + console.log(e instanceof TypeError); // true + console.log(e.message); // "Hallo" + console.log(e.name); // "TypeError" + console.log(e.fileName); // "someFile.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:2:9\n" +} +</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', '#sec-15.11.6.5', 'TypeError')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.5', 'TypeError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-typeerror', 'TypeError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-typeerror', 'TypeError')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.TypeError")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("TypeError.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/typeerror/prototype/index.html b/files/de/web/javascript/reference/global_objects/typeerror/prototype/index.html new file mode 100644 index 0000000000..d75e8efe4d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/typeerror/prototype/index.html @@ -0,0 +1,88 @@ +--- +title: TypeError.prototype +slug: Web/JavaScript/Reference/Global_Objects/TypeError/prototype +tags: + - Error + - JavaScript + - Property + - Prototype + - TypeError +translation_of: Web/JavaScript/Reference/Global_Objects/TypeError +--- +<div>{{JSRef}}</div> + +<p>Die <code><strong>TypeError.prototype</strong></code> Eigenschaft repräsentiert den prototype des {{jsxref("TypeError")}} Konstruktors.</p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Alle {{jsxref("TypeError")}} Instanzen erben von <code>TypeError.prototype</code>. Dem prototype können über alle Instanzen hinweg Eigenschaften und Methoden hinzugefügt werden.</p> + +<h2 id="Eigenschaften">Eigenschaften</h2> + +<dl> + <dt><code>TypeError.prototype.constructor</code></dt> + <dd>Spezifiziert die Instanz erstellende Funktion.</dd> + <dt>{{jsxref("Error.prototype.message", "TypeError.prototype.message")}}</dt> + <dd>Fehlermeldung. ECMA-262 spezifiziert, dass {{jsxref("TypeError")}} eine eigene <code>message</code> Eigenschaft zur Verfügung stellen soll. In <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> jedoch, erbt es von {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "TypeError.prototype.name")}}</dt> + <dd>Fehlerbezeichnung. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "TypeError.prototype.fileName")}}</dt> + <dd>Pfad zur Datei, welche den Fehler verursachte. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "TypeError.prototype.lineNumber")}}</dt> + <dd>Zeile in welcher der Fehler verusacht wurde. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "TypeError.prototype.columnNumber")}}</dt> + <dd>Zeichennummer der Zeile in welcher der Fehler verursacht wurde. Geerbt von {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "TypeError.prototype.stack")}}</dt> + <dd>Stack trace. Geerbt von {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Methoden">Methoden</h2> + +<p>Das {{jsxref("TypeError")}} prototype Objekt beinhaltet keine eigenen Methoden, jedoch erben {{jsxref("TypeError")}} Instanzen einige Methoden durch die Prototypenkette.</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', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initiale Definition</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definiert als <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.TypeError")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/undefined/index.html b/files/de/web/javascript/reference/global_objects/undefined/index.html new file mode 100644 index 0000000000..9c0dd8f5f7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/undefined/index.html @@ -0,0 +1,135 @@ +--- +title: undefined +slug: Web/JavaScript/Reference/Global_Objects/undefined +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/undefined +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>Die globale Eigenschaft <code><strong>undefined</strong></code> repräsentiert den Wert <code>{{Glossary("Undefined", "undefined")}}</code> . Dieser Wert ist einer der {{Glossary("Primitive", "primitiven Typen")}} in JavaScript.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-undefined.html")}}</div> + + + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>undefined</code></pre> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p><code>undefined</code> ist eine Eigenschaft des <em>globalen Objektes</em>, was bedeutet, dass es eine Variable im globalen Gültigkeitsbereich ist. Der initiale Wert von <code>undefined</code> ist der primitive Wert <code>{{Glossary("Undefined", "undefined")}}</code>.</p> + +<p>In modernen Browsern (JavaScript 1.8.5 / Firefox 4+) ist <code>undefined</code> eine nicht konfigurierbare und nicht beschreibbare Eigenschaft. Dieses ist in der ECMAScript 5 Spezifikation definiert. Immer wenn das nicht der Fall ist, sollte das Überschreiben von <code>undefined</code> unterlassen werden.</p> + +<p>Eine Variable, die nicht mit einem Wert beschrieben wurde, ist vom Typ <code>undefined</code>. Methoden oder Anweisungen geben ebenfalls <code>undefined</code> zurück, wenn eine Variable, die ausgewertet wird, mit keinem Wert beschrieben ist. Eine Funktion hat <code>undefined</code> als Rückgabewert, wenn kein Wert {{jsxref("Statements/return", "zurückgegeben")}} wird.</p> + +<div class="warning"> +<p>Weil es möglich ist {{Glossary("Identifier", "Bezeichner")}} (Variablennamen) in jedem anderen Scope anders zu definieren, ist es auch möglich <code>undefined</code> neu zu defnieren (weil <code>undefined</code> kein {{jsxref("Reserved_Words", "reserviertes Schlüsselwort")}}) ist). Dieses einzusetzen ist jedoch keine gute Idee, weil der Quelltext dadurch schwer zu verstehen ist.</p> + +<pre class="brush: js">// NICHT NACHMACHEN + +// gibt "foo string" aus +(function(){ var undefined = 'foo'; console.log(undefined, typeof undefined); })(); + +// gibt "foo string" aus +(function(undefined){ console.log(undefined, typeof undefined); })('foo'); +</pre> +</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Identität_und_undefined">Identität und <code>undefined</code></h3> + +<p>Man kann <code>undefined</code> in Verbindung mit dem strikten Gleichheitsoperator nutzen, um den Wert von Variablen auf <code>undefined</code> zu prüfen. Im folgenden Beispiel ist die Variable <code>x</code> nicht definiert und die if-Anweisung wird zu <code>true</code> ausgewertet.</p> + +<pre class="brush: js">var x; +if (x === undefined) { + // Diese Anweisung wird ausgeführt +} +else { + // Diese Anweisung wird nicht ausgeführt +} +</pre> + +<div class="note">Hinweis: Der strikte Gleichheitsoperator muss statt dem Standard-Gleichheitsoperator benutzt werden, weil <code>x == undefined</code> auch prüft, ob <code>x</code> <code>null</code> ist, was bei strikter Gleichheit nicht so ist. <code>null</code> ist nicht äquivalent zu <code>undefined</code> Für Details siehe {{jsxref("Operators/Comparison_Operators", "Vergleichsoperatoren")}}</div> + +<h3 id="Typeof_Operator_und_undefined"><code>Typeof</code> Operator und <code>undefined</code></h3> + +<p>Alternativ kann {{jsxref("Operators/typeof", "typeof")}} eingesetzt werden:</p> + +<pre class="brush: js">var x; +if (typeof x === 'undefined') { + // Diese Anweisung wird ausgeführt +} +</pre> + +<p>Ein Grund {{jsxref("Operators/typeof", "typeof")}} zu nutzen, ist, dass diese Variante keinen Fehler erzeugt, wenn eine Variable nicht definiert ist.</p> + +<pre class="brush: js">// x wurde nicht definiert +if (typeof x === 'undefined') { // wird ohne Fehler zu true ausgewertet + // Diese Anweisung wird ausgeführt +} + +if(x === undefined){ // erzeugt einen ReferenceError + +} +</pre> + +<p>Diese Technik sollte so oft es geht vermieden werden. JavaScript ist eine Sprache mit statischen Gültigkeitsbereichen, was bedeutet, dass eine Variable immer in seinem geschlossenen Kontext gelesen werden kann, egal ob sie <span class="dpf_sent" id="dpfsent_1">existiert </span> oder nicht. Die einzige Ausnahme ist der globale Gültigkeitsbereich, jedoch ist dieser an das <em>globale Objekt</em> gebunden, weshalb die Existenz einer Variablen auf dem <em>globalen Objekt</em> geprüft werden kann. Dafür kann der {{jsxref("Operators/in", "in")}}-Operator genutzt werden.</p> + +<h3 id="Void_Operator_und_undefined"><code>Void</code> Operator und <code>undefined</code></h3> + +<p>Der {{jsxref("Operators/void", "void")}}-Operator ist die dritte Alternative.</p> + +<pre class="brush: js">var x; +if (x === void 0) { + // Diese Anweisung wird ausgeführt +} + +// y wurde nicht definiert +if (y === void 0) { + // erzeugt einen ReferenceError (im gegensatz zu `typeof`) +} +</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', '#sec-4.3.9', 'undefined')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initiale Definition. Implementiert in JavaScript 1.3</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.1.3', 'undefined')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-undefined', 'undefined')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-undefined', 'undefined')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browserkompatibilität">Browserkompatibilität</h2> + + + +<p>{{Compat("javascript.builtins.undefined")}}</p> diff --git a/files/de/web/javascript/reference/global_objects/unescape/index.html b/files/de/web/javascript/reference/global_objects/unescape/index.html new file mode 100644 index 0000000000..315c332a35 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/unescape/index.html @@ -0,0 +1,126 @@ +--- +title: unescape() +slug: Web/JavaScript/Reference/Global_Objects/unescape +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/unescape +--- +<div> +<div> +<div>{{jsSidebar("Objects")}} {{deprecated_header()}}</div> +</div> +</div> + +<h2 id="Summary" name="Summary">Zusammenfassung</h2> + +<p>Die veraltete <code><strong>unescape()</strong></code> Methode erstellt einen neuen String, in dem hexadezimal escapte Sequenzen mit den entsprechenden umgewandelten Zeichen ersetzt werden. Die escape Sequenz kann vorher durch eine Funktion wie {{jsxref("Global_Objects/escape", "escape")}} erzeugt werden. Da <code>unescape</code> veraltet ist, sollte {{jsxref("Global_Objects/decodeURI", "decodeURI")}} oder {{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent")}} verwendet werden.</p> + +<div class="note"><strong>HInweis:</strong> <code>unescape</code> sollte nicht verwendet werden um URIs zu decodieren, nutze stattdessen <code>decodeURI</code>.</div> + +<h2 id="Syntax" name="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>unescape(str)</code></pre> + +<h3 id="Parameters" name="Parameters">Parameter</h3> + +<dl> + <dt><code>str</code></dt> + <dd>Ein String der decodiert werden soll.</dd> +</dl> + +<h2 id="Description" name="Description">Beschreibung</h2> + +<p>Die <code>unescape</code> Funktion ist eine Eigenschaft des <em>global object</em>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js">unescape("abc123"); // "abc123" +unescape("%E4%F6%FC"); // "äöü" +unescape("%u0107"); // "ć" +</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>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initiale Definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.2', 'unescape')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definiert im (informative) Compatibility Annex B</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-unescape-string', 'unescape')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definiert im (normative) Annex B for Additional ECMAScript Features for Web Browsers</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_Also" name="See_Also">Siehe auch</h2> + +<ul> + <li>{{jsxref("Global_Objects/decodeURI", "decodeURI")}}</li> + <li>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/uneval/index.html b/files/de/web/javascript/reference/global_objects/uneval/index.html new file mode 100644 index 0000000000..b44eccc21a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/uneval/index.html @@ -0,0 +1,109 @@ +--- +title: uneval() +slug: Web/JavaScript/Reference/Global_Objects/uneval +translation_of: Web/JavaScript/Reference/Global_Objects/uneval +--- +<div>{{jsSidebar("Objects")}}{{Non-standard_header}}</div> + +<p>Die <code><strong>uneval()</strong></code> Funktion gibt den Quelltext eines Objekts als String zurück.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">uneval(<var>object</var>)</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><code>object</code></dt> + <dd>Ein JavaScript Ausdruck oder eine Anweisung.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Eine String-Darstellung des Quelltexts des Objekts.</p> + +<div class="note"><strong>Notiz:</strong> Es wird keine gültige JSON Darstellung des Objekts zurückgegeben.</div> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p><code>uneval()</code> ist eine Top-Level Funktion und somit mit keinem Objekt verbunden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush:js">var a = 1; +uneval(a); // gibt einen String zurück der 1 enthält + +var b = "1"; +uneval(b) // gibt einen String zurück der "1" enthält + +uneval(function foo(){}); // gibt "(function foo(){})" zurück + +var a = uneval(function foo(){return 'hi'}); +var foo = eval(a); +foo(); // gibt "hi" zurück +</pre> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<p>Kein Bestandteil einer Spezifikation.</p> + +<h2 id="Browser_Kompatibilität">Browser Kompatibilität</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> + <li>{{jsxref("JSON.stringify")}}</li> + <li>{{jsxref("JSON.parse")}}</li> + <li>{{jsxref("Object.toSource")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/webassembly/compile/index.html b/files/de/web/javascript/reference/global_objects/webassembly/compile/index.html new file mode 100644 index 0000000000..a18c69da30 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/webassembly/compile/index.html @@ -0,0 +1,91 @@ +--- +title: WebAssembly.compile() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/compile +tags: + - API + - JavaScript + - Method + - Object + - Reference + - WebAssembly + - compile +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/compile +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>WebAssembly.compile()</code></strong> Funktion kompiliert ein {{jsxref("WebAssembly.Module")}} aus WebAssembly Binärcode. Hilfreich ist diese Funktion, um ein Modul zu kompilieren, bevor es instanziiert werden kann (Andernfalls sollte die {{jsxref("WebAssembly.instantiate()")}} Funktion verwendet werden).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Promise<WebAssembly.Module> WebAssembly.compile(bufferSource);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><em>bufferSource</em></dt> + <dd>Ein <a href="/en-US/docs/Web/JavaScript/Typed_arrays">typisiertes Array</a> oder <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer">ArrayBuffer</a>, das den Binärcode des zu kompilierenden .wasm Moduls enthält.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein <code>Promise</code>, das sich in ein {{jsxref("WebAssembly.Module")}} kompiliertes Objekt auflöst.</p> + +<h3 id="Fehlerbehandlung">Fehlerbehandlung</h3> + +<ul> + <li>Wenn <code>bufferSource</code> kein <a href="/en-US/docs/Web/JavaScript/Typed_arrays">typisiertes Array</a> ist, wird ein {{jsxref("TypeError")}} geworfen.</li> + <li>Wenn die Kompilierung fehlschlägt, wird das Promise mit einem {{jsxref("WebAssembly.CompileError")}} verworfen.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Das folgende Beispiel kompiliert den geladenen simple.wasm Bytecode unter Verwendung der <span style="font-size: 1rem; letter-spacing: -0.00278rem;"> </span><code style="font-size: 1rem; letter-spacing: -0.00278rem;">compile()</code><span style="font-size: 1rem; letter-spacing: -0.00278rem;"> Funktion und sendet ihn an einen </span><a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API" style="font-size: 1rem; letter-spacing: -0.00278rem;">Web Worker</a><span style="font-size: 1rem; letter-spacing: -0.00278rem;"> mittels </span><a href="/en-US/docs/Web/API/Worker/postMessage" style="font-size: 1rem; letter-spacing: -0.00278rem;">postMessage()</a><span style="font-size: 1rem; letter-spacing: -0.00278rem;">.</span></p> + +<pre class="brush: js">var worker = new Worker("wasm_worker.js"); + +fetch('simple.wasm').then(response => + response.arrayBuffer() +).then(bytes => + WebAssembly.compile(bytes) +).then(mod => + worker.postMessage(mod) +);</pre> + +<div class="note"> +<p><strong>Hinweis</strong>: Du wirst wahrscheinlich in den meisten Fällen {{jsxref("WebAssembly.compileStreaming()")}} verwenden wollen, da es effizienter als <code>compile()</code> arbeitet.</p> +</div> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spezifikation</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('WebAssembly JS', '#webassemblycompile', 'compile()')}}</td> + <td>{{Spec2('WebAssembly JS')}}</td> + <td>Initial draft definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.WebAssembly.compile")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de-DE/docs/WebAssembly">WebAssembly</a> Übersichtsseite</li> + <li><a href="/en-US/docs/WebAssembly/Concepts">WebAssembly concepts</a></li> + <li><a href="/en-US/docs/WebAssembly/Using_the_JavaScript_API">Using the WebAssembly JavaScript API</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html b/files/de/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html new file mode 100644 index 0000000000..13cbbdeef4 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html @@ -0,0 +1,87 @@ +--- +title: WebAssembly.compileStreaming() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming +tags: + - API + - JavaScript + - Method + - Object + - Reference + - WebAssembly + - compile + - compileStreaming + - streaming +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming +--- +<div>{{JSRef}}</div> + +<p>Die <strong><code>WebAssembly.compileStreaming()</code></strong> Funktion kompiliert ein {{jsxref("WebAssembly.Module")}} direkt aus einer zugrunde liegenden Quelle. Nützlich ist diese Funktion wenn ein Modul kompiliert werden muss, bevor es instanziiert werden kann. (ansonsten sollte die {{jsxref("WebAssembly.instantiateStreaming()")}} Funktion verwendet werden).</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Promise<WebAssembly.Module> WebAssembly.compileStreaming(<em>source</em>);</pre> + +<h3 id="Parameter">Parameter</h3> + +<dl> + <dt><em>source</em></dt> + <dd>Ein {{domxref("Response")}} Objekt oder ein Promise das sich zu einem solchen auflöst. Es stellt die zugrunde liegende Quelle eines .wasm Moduls dar, die gestreamt und kompiliert werden soll.</dd> +</dl> + +<h3 id="Rückgabewert">Rückgabewert</h3> + +<p>Ein <code>Promise</code> das sich in ein {{jsxref("WebAssembly.Module")}} Objekt auflöst, welche das kompilierte Modul darstellt.</p> + +<h3 id="Ausnahmen">Ausnahmen</h3> + +<ul> + <li>Wenn <code>bufferSource</code> kein <a href="/en-US/docs/Web/JavaScript/Typed_arrays">typisiertes Array<font color="#001000"> </font></a>ist, wird ein {{jsxref("TypeError")}} geworfen.</li> + <li>Schlägt die Kompilierung fehl, wird das Promise mit einem {{jsxref("WebAssembly.CompileError")}} verworfen.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Das folgende Beispiel (siehe unsere <a href="https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/compile-streaming.html">compile-streaming.html</a> Demo auf GitHub, und <a href="https://mdn.github.io/webassembly-examples/js-api-examples/compile-streaming.html">siehe das live Beispiel</a>) streamt ein .wasm Modul direkt aus der zugrunde liegenden Quelle und kompiliert es in ein {{jsxref("WebAssembly.Module")}} Objekt. Weil die <code>compileStreaming()</code> Funktion ein Promise für ein {{domxref("Response")}} Objekt annimmt, kann ihr direkt ein {{domxref("WindowOrWorkerGlobalScope.fetch()")}} Aufruf durchgereicht werden, woraufhin es die Antwort in diese Funktion abgibt, sobald das Promise sich erfüllt.</p> + +<pre class="brush: js">var importObject = { imports: { imported_func: arg => console.log(arg) } }; + +WebAssembly.compileStreaming(fetch('simple.wasm')) +.then(module => WebAssembly.instantiate(module, importObject)) +.then(instance => instance.exports.exported_func());</pre> + +<p>Das resultierende Modul wird dann mittels {{jsxref("WebAssembly.instantiate()")}} instanziiert und die bereitgestellte Funktion wird aufgerufen.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spezifikationen</th> + <th scope="col">Status</th> + <th scope="col">Kommentar</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('WebAssembly Embedding', '#webassemblycompilestreaming', 'compileStreaming()')}}</td> + <td>{{Spec2('WebAssembly Embedding')}}</td> + <td>Initial draft definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.WebAssembly.compileStreaming")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/en-US/docs/WebAssembly">WebAssembly</a> Übersichtsseite</li> + <li><a href="/en-US/docs/WebAssembly/Concepts">WebAssembly concepts</a></li> + <li><a href="/en-US/docs/WebAssembly/Using_the_JavaScript_API">Using the WebAssembly JavaScript API</a></li> +</ul> diff --git a/files/de/web/javascript/reference/global_objects/webassembly/index.html b/files/de/web/javascript/reference/global_objects/webassembly/index.html new file mode 100644 index 0000000000..4681f473fd --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/webassembly/index.html @@ -0,0 +1,111 @@ +--- +title: WebAssembly +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly +tags: + - API + - JavaScript + - Objekt + - Referenz + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly +--- +<div>{{JSRef}}</div> + +<p>Das <strong><code>WebAssembly</code></strong> JavaScript Objekt existiert als Namensraum für alle <a href="/en-US/docs/WebAssembly">WebAssembly</a>-bezogenen Funktionalitäten.</p> + +<p>Anders als die meisten anderen globalen Objekte, ist <code>WebAssembly</code> kein Konstruktor (es ist kein Funktionsobjekt). Es kann mit {{jsxref("Math")}} verglichen werden, welches ebenfalls einen Namensraum für mathematische Konstanten und Funktionen bildet. Oder mit {{jsxref("Intl")}}, welches den Namensraum für die Internationalisierunges API mit sprachabhängigen Funktionen bildet. </p> + +<h2 id="Beschreibung">Beschreibung</h2> + +<p>Die primäre Verwendung des <code>WebAssembly</code> Objekts sind:</p> + +<ul> + <li>Laden von WebAssembly Code, verwenden der {{jsxref("WebAssembly.instantiate()")}} Funktion.</li> + <li>Neue Speicher- und Tabelleninstanzen mittels der {{jsxref("WebAssembly.Memory()")}}/{{jsxref("WebAssembly.Table()")}} Konstruktoren.</li> + <li>Bereitstellen von Einrichtungen zur Fehlerbehandlung, die in WebAssembly auftreten, mittels der {{jsxref("WebAssembly.CompileError()")}}/{{jsxref("WebAssembly.LinkError()")}}/{{jsxref("WebAssembly.RuntimeError()")}} Konstruktoren.</li> +</ul> + +<h2 id="Methoden">Methoden</h2> + +<dl> + <dt>{{jsxref("WebAssembly.instantiate()")}}</dt> + <dd>Die primäre API für das Kompilieren und Instanziieren des WebAssembly Codes. Der Rückgabewert als <code>Promise</code> ergibt ein <code>Module</code> als auch die erste <code>Instance</code>.</dd> + <dt>{{jsxref("WebAssembly.instantiateStreaming()")}}</dt> + <dd>Kompiliert und instanziiert ein WebAssembly-Modul direkt aus einer Streamingquelle, mit dem Rückgabewert als <code>Promise</code> ergibt sich ein <code>Module</code> als auch die erste <code>Instance</code>.</dd> + <dt>{{jsxref("WebAssembly.compile()")}}</dt> + <dd>Kompiliert ein {{jsxref("WebAssembly.Module")}} aus dem WebAssembly Binärcode, wodurch die Instanziierung als separater Schritt durchgeführt werden kann.</dd> + <dt>{{jsxref("WebAssembly.compileStreaming()")}}</dt> + <dd>Kompiliert ein {{jsxref("WebAssembly.Module")}} direkt aus einer Streamingquelle, wodurch die Instanziierung als separater Schritt durchgeführt werden kann.</dd> + <dt>{{jsxref("WebAssembly.validate()")}}</dt> + <dd>Validiert das gegebene, typisierte Array eines WebAssembly Binärcodes. Gibt zurück, ob die Bytes validen WebAssembly Code darstellen (<code>true</code>) oder nicht (<code>false</code>).</dd> +</dl> + +<h2 id="Konstruktoren">Konstruktoren</h2> + +<dl> + <dt>{{jsxref("WebAssembly.Global()")}}</dt> + <dd>Erzeugt ein neues WebAssembly <code>Global</code> Objekt.</dd> + <dt>{{jsxref("WebAssembly.Module()")}}</dt> + <dd>Erzeugt ein neues WebAssembly <code>Module</code> Objekt.</dd> + <dt>{{jsxref("WebAssembly.Instance()")}}</dt> + <dd>Erzeugt ein neues WebAssembly <code>Instance</code> Objekt.</dd> + <dt>{{jsxref("WebAssembly.Memory()")}}</dt> + <dd>Erzeugt ein neues WebAssembly <code>Memory</code> Objekt.</dd> + <dt>{{jsxref("WebAssembly.Table()")}}</dt> + <dd>Erzeugt ein neues WebAssembly <code>Table</code> Objekt.</dd> + <dt>{{jsxref("WebAssembly.CompileError()")}}</dt> + <dd>Erzeugt ein neues WebAssembly <code>CompileError</code> Objekt.</dd> + <dt>{{jsxref("WebAssembly.LinkError()")}}</dt> + <dd>Erzeugt ein neues WebAssembly <code>LinkError</code> Objekt.</dd> + <dt>{{jsxref("WebAssembly.RuntimeError()")}}</dt> + <dd>Erzeugt ein neues WebAssembly <code>RuntimeError</code> Objekt.</dd> +</dl> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Das folgende Beispiel (siehe <a href="https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/instantiate-streaming.html">instantiate-streaming.html</a> Demo auf GitHub, <a href="https://mdn.github.io/webassembly-examples/js-api-examples/instantiate-streaming.html">siehe auch live</a>) streamt ein .wasm Modul direkt aus einer zugrunde liegenden Quelle, um es dann zu kompilieren und zu instanziieren. Das Promise erfüllt sich mit einem <code>ResultObject</code>. Weil die <code>instantiateStreaming()</code> Funktion ein Promise für ein {{domxref("Response")}} akzeptiert, kann ihr ein {{domxref("WindowOrWorkerGlobalScope.fetch()")}} direkt übergeben werden, welches die Antwort an die Funktion weitergibt, sobald das Promise sich erfüllt.</p> + +<pre class="brush: js">var importObject = { imports: { imported_func: arg => console.log(arg) } }; + +WebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject) +.then(obj => obj.instance.exports.exported_func()); +</pre> + +<p>Auf die <code>ResultObject</code> Instanz wird damit zugegriffen und die beinhaltete, exportierte Funktion aufgerufen.</p> + +<h2 id="Spezifikationen">Spezifikationen</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('WebAssembly JS', '#the-webassembly-object', 'WebAssembly')}}</td> + <td>{{Spec2('WebAssembly JS')}}</td> + <td>Initial draft definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Browserkompatibilität</h2> + +<div> + + +<p>{{Compat("javascript.builtins.WebAssembly")}}</p> +</div> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/en-US/docs/WebAssembly">WebAssembly</a> Übersicht</li> + <li><a href="/en-US/docs/WebAssembly/Concepts">WebAssembly concepts</a></li> + <li><a href="/en-US/docs/WebAssembly/Using_the_JavaScript_API">Using the WebAssembly JavaScript API</a></li> +</ul> + +<section id="Quick_Links"> </section> |