From 4ab365b110f2f1f2b736326b7059244a32115089 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:45:38 +0100 Subject: unslug de: move --- .../global_objects/arraybuffer/index.html | 69 +++ .../reference/global_objects/boolean/index.html | 84 +++ .../reference/global_objects/dataview/index.html | 110 ++++ .../reference/global_objects/date/index.html | 183 +++++++ .../reference/global_objects/error/index.html | 114 ++++ .../reference/global_objects/evalerror/index.html | 90 ++++ .../reference/global_objects/function/index.html | 100 ++++ .../global_objects/generatorfunction/index.html | 67 +++ .../global_objects/internalerror/index.html | 62 +++ .../global_objects/intl/collator/index.html | 80 +++ .../global_objects/intl/datetimeformat/index.html | 84 +++ .../global_objects/intl/numberformat/index.html | 82 +++ .../reference/global_objects/map/index.html | 87 ++++ .../reference/global_objects/number/index.html | 90 ++++ .../reference/global_objects/object/index.html | 220 ++++++++ .../reference/global_objects/rangeerror/index.html | 129 +++++ .../reference/global_objects/string/index.html | 190 +++++++ .../global_objects/syntaxerror/index.html | 89 ++++ .../reference/global_objects/typeerror/index.html | 89 ++++ .../web/javascript/reference/operators/index.html | 575 +++++++++++++++++++++ .../reference/operators/spread_syntax/index.html | 220 ++++++++ .../index.html | 244 +++++++++ .../index.html | 247 +++++++++ .../index.html | 413 +++++++++++++++ .../reference/statements/switch/index.html | 121 +++++ 25 files changed, 3839 insertions(+) create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/boolean/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/dataview/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/date/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/error/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/evalerror/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/function/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/internalerror/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/intl/collator/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/intl/datetimeformat/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/intl/numberformat/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/map/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/number/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/object/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/rangeerror/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/string/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html create mode 100644 files/de/conflicting/web/javascript/reference/global_objects/typeerror/index.html create mode 100644 files/de/conflicting/web/javascript/reference/operators/index.html create mode 100644 files/de/conflicting/web/javascript/reference/operators/spread_syntax/index.html create mode 100644 files/de/conflicting/web/javascript/reference/operators_5b3986b830cf68059c03079ef10ff039/index.html create mode 100644 files/de/conflicting/web/javascript/reference/operators_8b4515dbed18a24ecb01bfe0755ca163/index.html create mode 100644 files/de/conflicting/web/javascript/reference/operators_bf514126b51a6e9b7591809ecc554076/index.html create mode 100644 files/de/conflicting/web/javascript/reference/statements/switch/index.html (limited to 'files/de/conflicting/web/javascript/reference') diff --git a/files/de/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html b/files/de/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html new file mode 100644 index 0000000000..ee766c3529 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html @@ -0,0 +1,69 @@ +--- +title: ArrayBuffer.prototype +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype +tags: + - ArrayBuffer + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +translation_of_original: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype +--- +
{{JSRef}}
+ +

Die ArrayBuffer.prototype Eigenschaft repräsentiert den Prototyp für das {{jsxref("ArrayBuffer")}} Objekt.

+ +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

ArrayBuffer Instanzen erben von ArrayBuffer.prototype. Wie bei allen Konstruktoren, kann der Prototype des Konstruktorobjekts geändert werden, um Änderungen für alle ArrayBuffer Instanzen zu übernehmen.

+ +

Eigenschaften

+ +
+
ArrayBuffer.prototype.constructor
+
Spezifiziert die Funktion, die das Prototypeobjekt erstellt. Der Initialwert ist der eingebaute Standard-ArrayBuffer-Konstruktor.
+
{{jsxref("ArrayBuffer.prototype.byteLength")}} {{readonlyInline}}
+
Die größe, in Bytes, des Arrays. Dieser wird bei der Erstellung des Arrays ermittelt und kan nicht geändert werden.
+
+ +

Methoden

+ +
+
{{jsxref("ArrayBuffer.prototype.slice()")}}
+
Gibt einen neuen ArrayBuffer zurück, welcher eine Kopie der Bytes des eigentlichen ArrayBuffer einthält. Die Kopie geht von begin (inklusiv) bis end (exclusiv). Wenn einer der Werte negativ ist, referenziert er auf den Index vom Ende des Arrays an und nicht vom Beginn des Arrays.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpzifikationStatusKommentar
{{SpecName('ES6', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}{{Spec2('ES6')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.ArrayBuffer.prototype")}}

+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/boolean/index.html b/files/de/conflicting/web/javascript/reference/global_objects/boolean/index.html new file mode 100644 index 0000000000..62a430fac2 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/boolean/index.html @@ -0,0 +1,84 @@ +--- +title: Boolean.prototype +slug: Web/JavaScript/Reference/Global_Objects/Boolean/prototype +tags: + - Boolean + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +translation_of_original: Web/JavaScript/Reference/Global_Objects/Boolean/prototype +--- +
{{JSRef}}
+ +
Die Boolean.prototype Eigenschaft repräsentiert den Prototypen des  {{jsxref("Boolean")}} Konstruktors.
+ +
 
+ +
{{js_property_attributes(0, 0, 0)}}
+ +
{{EmbedInteractiveExample("pages/js/boolean-constructor.html")}}
+ + + +

Beschreibung

+ +

{{jsxref("Boolean")}} Instanzen ergen von from Boolean.prototype. Man kann das prototype Objekt benutzen, um Eigenschaften und Methoden zu allen {{jsxref("Boolean")}} Instanzen hinzuzufügen.

+ +

Eigenschaften

+ +
+
Boolean.prototype.constructor
+
Gibt die Funktion, die einen Instanz des Prototypen erstellt zurück. Im Standardfall ist das die Funktion {{jsxref("Boolean")}}.
+
+ +

Methoden

+ +
+
{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}}
+
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.
+
{{jsxref("Boolean.prototype.toString()")}}
+
Gibt einen String "true" oder "false" zurück, abhängig vom Wert des Objektes. Diese Methode überschreibt die {{jsxref("Object.prototype.toString()")}} Methode.
+
{{jsxref("Boolean.prototype.valueOf()")}}
+
Gibt einen primitiven Wert des {{jsxref("Boolean")}} Objektes zurück. Diese Methode überschreibt die {{jsxref("Object.prototype.valueOf()")}} Methode.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.6.3.1', 'Boolean.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-boolean.prototype', 'Boolean.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-boolean.prototype', 'Boolean.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Boolean.prototype")}}

+
diff --git a/files/de/conflicting/web/javascript/reference/global_objects/dataview/index.html b/files/de/conflicting/web/javascript/reference/global_objects/dataview/index.html new file mode 100644 index 0000000000..e03aff8a8d --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/dataview/index.html @@ -0,0 +1,110 @@ +--- +title: DataView.prototype +slug: Web/JavaScript/Reference/Global_Objects/DataView/prototype +tags: + - DataView + - JavaScript + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/DataView +translation_of_original: Web/JavaScript/Reference/Global_Objects/DataView/prototype +--- +
{{JSRef}}
+ +

Die DataView.prototype Eigenschaft repräsentiert den Prototypen für das {{jsxref("DataView")}} Objekt.

+ +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

DataView Instanzen erben von DataView.prototype. Wie bei allen Konstruktoren, können Änderungen am Prototypen Änderungen in allen DataView Instanzen zur folge haben.

+ +

Eigenschaften

+ +
+
DataView.prototype.constructor
+
Spezifiziert die Funktion, die ein Objekt des Prototypen erstellt. Der initialwert ist der Standard eingebaute DataView Konstruktor
+
{{jsxref("DataView.prototype.buffer")}} {{readonlyInline}}
+
Der {{jsxref("ArrayBuffer")}}, der von dieser Ansicht repräsentiert wird. Wird bei der Erstellung erzeugt und deswegen kann nur lesend darauf zugegriffen werden.
+
{{jsxref("DataView.prototype.byteLength")}} {{readonlyInline}}
+
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.
+
{{jsxref("DataView.prototype.byteOffset")}} {{readonlyInline}}
+
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.
+
+ +

Methoden

+ +

Lesend

+ +
+
{{jsxref("DataView.prototype.getInt8()")}}
+
Gibt eine 8-Bit ganze Zahl mit Vorzeichen (byte) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.
+
{{jsxref("DataView.prototype.getUint8()")}}
+
Gibt eine 8-Bit vorzeichenlose ganze Zahl (unsigned byte) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.
+
{{jsxref("DataView.prototype.getInt16()")}}
+
Gibt eine 16-Bit ganze Zahl mit Vorzeichen (short) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.
+
{{jsxref("DataView.prototype.getUint16()")}}
+
Gibt eine 16-Bit vorzeichenlose ganze Zahl (unsigned short) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.
+
{{jsxref("DataView.prototype.getInt32()")}}
+
Gibt eine 32-Bit ganze Zahl mit Vorzeichen (long) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.
+
{{jsxref("DataView.prototype.getUint32()")}}
+
Gibt eine 32-Bit vorzeichenlose ganze Zahl (unsigned long) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück.
+
{{jsxref("DataView.prototype.getFloat32()")}}
+
Gibt eine 32-Bit Gleitkommazahl mit Vorzeichen (float) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück
+
{{jsxref("DataView.prototype.getFloat64()")}}
+
Gibt eine 64-Bit Gleitkommazahl mit Vorzeichen (double) eines spezifizierten Byte-Offsets vom Start der Ansicht zurück
+
+ +

Schreibend

+ +
+
{{jsxref("DataView.prototype.setInt8()")}}
+
Speichert eine ganze 8-Bit Zahl mit Vorzeichen (byte) an einem spezifizierten Offset vom Start der Ansicht.
+
{{jsxref("DataView.prototype.setUint8()")}}
+
Speichert eine ganze vorzeichenlose 8-Bit Zahl (unsigned byte) an einem spezifizierten Offset vom Start der Ansicht.
+
{{jsxref("DataView.prototype.setInt16()")}}
+
Speichert eine ganze 16-Bit Zahl mit Vorzeichen (short) an einem spezifizierten Offset vom Start der Ansicht.
+
{{jsxref("DataView.prototype.setUint16()")}}
+
Speichert eine ganze vorzeichenlose 16-Bit Zahl (unsigned short) an einem spezifizierten Offset vom Start der Ansicht.
+
{{jsxref("DataView.prototype.setInt32()")}}
+
Speichert eine ganze 32-Bit Zahl mit Vorzeichen (long) an einem spezifizierten Offset vom Start der Ansicht.
+
{{jsxref("DataView.prototype.setUint32()")}}
+
Speichert eine ganze vorzeichenlose 32-Bit Zahl (unsigned long) an einem spezifizierten Offset vom Start der Ansicht.
+
{{jsxref("DataView.prototype.setFloat32()")}}
+
Speichert eine 32-Bit Gleitkommazahl mit Vorzeichen (float) an einem spezifizierten Offset vom Start der Ansicht.
+
{{jsxref("DataView.prototype.setFloat64()")}}
+
Speichert eine 64-Bit Gleitkommazahl mit Vorzeichen (double) an einem spezifizierten Offset vom Start der Ansicht.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES6', '#sec-dataview.prototype', 'DataView.prototype')}}{{Spec2('ES6')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-dataview.prototype', 'DataView.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.DataView.prototype")}}

+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/date/index.html b/files/de/conflicting/web/javascript/reference/global_objects/date/index.html new file mode 100644 index 0000000000..ab69ff1528 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/date/index.html @@ -0,0 +1,183 @@ +--- +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 +translation_of_original: Web/JavaScript/Reference/Global_Objects/Date/prototype +--- +
{{JSRef}}
+ +

Die Date.prototype-Eigenschaft ist der Prototype für den {{jsxref("Date")}}-Konstruktor

+ +
{{js_property_attributes(0, 0, 1)}}
+ +

Beschreibung

+ +

JavaScript-{{jsxref("Date")}}-Instanzen erben von Date.prototype. Man kann das Konstruktorprototype-Objekt ändern, um Eigenschaften und Methoden aller {{jsxref("Date")}}-Instanzen zu ändern.

+ +

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()")}}.

+ +

Mit Einführung von ECMAScript 6 ist das Date.prototype-Objekt ein normales Objekt. Es ist keine Instanz von {{jsxref("Date")}}.

+ +

Eigenschaften

+ +
+
Date.prototype.constructor
+
Eine Funktion, die Instanzen erzeugen kann. Der {{jsxref("Date")}}-Konstruktor ist der Standard.
+
+ +

Methoden

+ +

Getter

+ +
+
{{jsxref("Date.prototype.getDate()")}}
+
Gibt den Tag des Monats (1 - 31) eines Datums gemäß der Ortszeit zurück.
+
{{jsxref("Date.prototype.getDay()")}}
+
Gibt den Tag der Woche (0 - 6) eines Datums gemäß der Ortszeit zurück.
+
{{jsxref("Date.prototype.getFullYear()")}}
+
Gibt das Jahr (4 Ziffern für 4 ziffrige Jahre) eines Datums gemäß der Ortszeit zurück.
+
{{jsxref("Date.prototype.getHours()")}}
+
Gibt die Stunde (0 - 23) eines Datums gemäß der Ortszeit zurück.
+
{{jsxref("Date.prototype.getMilliseconds()")}}
+
Gibt die Millisekunden (0 - 999) eines Datums gemäß der Ortszeit zurück.
+
{{jsxref("Date.prototype.getMinutes()")}}
+
Gibt die Minuten (0 - 59) eines Datums gemäß der Ortszeit zurück.
+
{{jsxref("Date.prototype.getMonth()")}}
+
Gibt den Monat (0 - 11) eines Datums gemäß der Ortszeit zurück.
+
{{jsxref("Date.prototype.getSeconds()")}}
+
Gibt die Sekunden (0 - 59) eines Datums gemäß der Ortszeit zurück.
+
{{jsxref("Date.prototype.getTime()")}}
+
Gibt den nummerischen Wert eines Datums als Millisekunden seit 1. Januar 1970 00:00:00 UTC (negativ für frühere Daten) zurück.
+
{{jsxref("Date.prototype.getTimezoneOffset()")}}
+
Gibt den Zeitzonenunterschied in Minuten für die aktuelle Region zurück.
+
{{jsxref("Date.prototype.getUTCDate()")}}
+
Gibt den Tag des Monats (1 - 31) eines Datums gemäß der Weltzeit zurück.
+
{{jsxref("Date.prototype.getUTCDay()")}}
+
Gibt den Tag der Woche (0 - 6) eines Datums gemäß der Weltzeit zurück.
+
{{jsxref("Date.prototype.getUTCFullYear()")}}
+
Gibt das Jahr (4 Ziffern für 4 ziffrige Jahre) eines Datums gemäß der Weltzeit zurück.
+
{{jsxref("Date.prototype.getUTCHours()")}}
+
Gibt die Stunden (0 - 23) eines Datums gemäß der Weltzeit zurück.
+
{{jsxref("Date.prototype.getUTCMilliseconds()")}}
+
Gibt die Millisekunden (0 - 999) eines Datums gemäß der Weltzeit zurück.
+
{{jsxref("Date.prototype.getUTCMinutes()")}}
+
Gibt die Minuten (0 - 59) eines Datums gemäß der Weltzeit zurück.
+
{{jsxref("Date.prototype.getUTCMonth()")}}
+
Gibt den Monat (0 - 11) eines Datums gemäß der Weltzeit zurück.
+
{{jsxref("Date.prototype.getUTCSeconds()")}}
+
Gibt die Sekunden (0 - 59) eines Datums gemäß der Weltzeit zurück.
+
{{jsxref("Date.prototype.getYear()")}} {{deprecated_inline}}
+
Gibt das Jahr (nur 2 - 3 Ziffern) eines Datums gemäß der Ortszeit zurück. Stattdessen sollte {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}} benutzt werden.
+
+ +

Setter

+ +
+
{{jsxref("Date.prototype.setDate()")}}
+
Setzt den Tag des Monats eines Datums gemäß der Ortszeit.
+
{{jsxref("Date.prototype.setFullYear()")}}
+
Setzt das Jahr (4 Ziffern für vierstellige Jahre) eines Datums gemäß der Ortszeit.
+
{{jsxref("Date.prototype.setHours()")}}
+
Setzt die Stunden eines Datums gemäß der Ortszeit.
+
{{jsxref("Date.prototype.setMilliseconds()")}}
+
Setzt die Millisekunden eines Datums gemäß der Ortszeit.
+
{{jsxref("Date.prototype.setMinutes()")}}
+
Setzt die Minuten eines Datums gemäß der Ortszeit.
+
{{jsxref("Date.prototype.setMonth()")}}
+
Setzt den Monat eines Datums gemäß der Ortszeit.
+
{{jsxref("Date.prototype.setSeconds()")}}
+
Setzt die Sekunden eines Datums gemäß der Ortszeit.
+
{{jsxref("Date.prototype.setTime()")}}
+
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.
+
{{jsxref("Date.prototype.setUTCDate()")}}
+
Setzt den Tag des Monats eines Datums gemäß der Weltzeit.
+
{{jsxref("Date.prototype.setUTCFullYear()")}}
+
Setzt das Jahr (4 Ziffern für 4 ziffrige Jahre) eines Datums gemäß der Weltzeit.
+
{{jsxref("Date.prototype.setUTCHours()")}}
+
Setzt die Stunde eines Datums gemäß der Weltzeit.
+
{{jsxref("Date.prototype.setUTCMilliseconds()")}}
+
Setzt die Millisekunden eines Datums gemäß der Weltzeit.
+
{{jsxref("Date.prototype.setUTCMinutes()")}}
+
Setzt die Minuten eines Datums gemäß der Weltzeit.
+
{{jsxref("Date.prototype.setUTCMonth()")}}
+
Setzt den Monat eines Datums gemäß der Weltzeit.
+
{{jsxref("Date.prototype.setUTCSeconds()")}}
+
Setzt die Sekunden eines Datums gemäß der Weltzeit.
+
{{jsxref("Date.prototype.setYear()")}} {{deprecated_inline}}
+
Setzt das Jahr (nur 2 - 3 Ziffern) eines Datums gemäß der Ortszeit. Stattdessen sollte {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} benutzt werden.
+
+ +

Konvertierungsgetter

+ +
+
{{jsxref("Date.prototype.toDateString()")}}
+
Gibt das Datum als menschlich lesbaren String zurück (z. B. Thu Apr 12 2018). 
+
{{jsxref("Date.prototype.toISOString()")}}
+
Konvertiert ein Datum zu einem String im erweiterten ISO-8601-Format.
+
{{jsxref("Date.prototype.toJSON()")}}
+
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()")}}.
+
{{jsxref("Date.prototype.toGMTString()")}} {{deprecated_inline}}
+
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.
+
{{jsxref("Date.prototype.toLocaleDateString()")}}
+
Gibt einen String mit ortssensitiver Repräsentation eines Datums zurück. Dieses Datum basiert auf den Systemeinstellungen.
+
{{jsxref("Date.prototype.toLocaleFormat()")}} {{non-standard_inline}}
+
Konvertiert ein Datum zu einem String mithilfe eines Formatierungsstrings.
+
{{jsxref("Date.prototype.toLocaleString()")}}
+
Gibt einen String mit ortssensitiver Repräsentation eines Datums zurück. Diese Method überschreibt die  {{jsxref("Object.prototype.toLocaleString()")}}-Methode.
+
{{jsxref("Date.prototype.toLocaleTimeString()")}}
+
Gibt einen String mit ortssensitiver Repräsentation der Zeit eines Datums zurück. Diese Zeit basiert auf den Systemeinstellungen.
+
{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}}
+
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
+
{{jsxref("Date.prototype.toString()")}}
+
Gibt eine String-Repräsentation eines {{jsxref("Date")}}-Objektes zurück. Diese Methode überschreibt die {{jsxref("Object.prototype.toString()")}} Methode.
+
{{jsxref("Date.prototype.toTimeString()")}}
+
Gibt die Zeit eines Datums als menschlich lesbaren String zurück.
+
{{jsxref("Date.prototype.toUTCString()")}}
+
Konvertiert das Datum zu einem String unter Einsatz der UTC-Zeitzone.
+
{{jsxref("Date.prototype.valueOf()")}}
+
Gibt ein primitiven Wert eines {{jsxref("Date")}}-Objektes zurück. Diese Methode überschreibt die {{jsxref("Object.prototype.valueOf()")}}-Methode.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.9.5', 'Date.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Date.prototype")}}

diff --git a/files/de/conflicting/web/javascript/reference/global_objects/error/index.html b/files/de/conflicting/web/javascript/reference/global_objects/error/index.html new file mode 100644 index 0000000000..2a48748822 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/error/index.html @@ -0,0 +1,114 @@ +--- +title: Error.prototype +slug: Web/JavaScript/Reference/Global_Objects/Error/prototype +tags: + - Error + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Error +translation_of_original: Web/JavaScript/Reference/Global_Objects/Error/prototype +--- +
{{JSRef}}
+ +

Die Error.prototype Eigenschaft repräsentiert den Prototypen für den {{jsxref("Error")}} Konstruktor.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Alle {{jsxref("Error")}} Instanzen und Instanzen von {{jsxref("Global_Objects/Error", "nicht generischen Errors", "#Error_types", 1)}} erben von Error.prototype. Wie bei jeder Konstruktorfunktion, kann man den Prototypen des Konstruktors einsetzen, um Eigenschaften oder Methoden bei allen erstellten Instanzen hinzuzufügen.

+ +

Eigenschaften

+ +

Standard-Eigenschaften

+ +
+
Error.prototype.constructor
+
Spezifiziert die Funktion, die einen Prototypen einer Instanz erstellt.
+
{{jsxref("Error.prototype.message")}}
+
Errornachricht.
+
{{jsxref("Error.prototype.name")}}
+
Errorname.
+
+ +

Vendor-spezifische Erweiterungen

+ +
{{non-standard_header}}
+ +

Microsoft

+ +
+
{{jsxref("Error.prototype.description")}} {{non-standard_inline}}
+
Errorbeschreibung. Ist das gleiche wie {{jsxref("Error.prototype.message")}}
+
{{jsxref("Error.prototype.number")}} {{non-standard_inline}}
+
Errornummer.
+
+ +

Mozilla

+ +
+
{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}
+
Pfad zu der Datei, die der der Error ausgelöst wurde.
+
{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}
+
Zeilennummer in der Datei, in der der Error ausgelöst wurde.
+
{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}
+
Spaltennummer in der Zeile, in der der Error ausgelöst wurde.
+
{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}
+
Stacktrace.
+
+ +

Methoden

+ +
+
{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}
+
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.
+
{{jsxref("Error.prototype.toString()")}}
+
Gibt einen String zurück, der das Objekt repräsentiert. Überschreibt die {{jsxref("Object.prototype.toString()")}} Methode.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-error.prototype', 'Error')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Error.prototype")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/evalerror/index.html b/files/de/conflicting/web/javascript/reference/global_objects/evalerror/index.html new file mode 100644 index 0000000000..7de0a353bc --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/evalerror/index.html @@ -0,0 +1,90 @@ +--- +title: EvalError.prototype +slug: Web/JavaScript/Reference/Global_Objects/EvalError/prototype +tags: + - Error + - EvalError + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/EvalError +translation_of_original: Web/JavaScript/Reference/Global_Objects/EvalError/prototype +--- +
{{JSRef}}
+ +

Die EvalError.prototype Eigenschaft repräsentiert den Prototypen des {{jsxref("EvalError")}} Konstruktors.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Alle {{jsxref("EvalError")}} Instanzen erben von EvalError.prototype. Man kann den Prototypen benutzen, um Eigenschaften oder Methoden für alle Instanzen hinzuzufügen.

+ +

Eigenschaften

+ +
+
EvalError.prototype.constructor
+
Spezifiziert die Funktion, die einen Instanzprototypen erstellt.
+
{{jsxref("Error.prototype.message", "EvalError.prototype.message")}}
+
Fehlernachricht. Obwohl ECMA-262 spezifiziert, dass {{jsxref("EvalError")}} seine eigene message Eigenschaft haben soll, wird diese in SpiderMonkey von {{jsxref("Error.prototype.message")}} geerbt.
+
{{jsxref("Error.prototype.name", "EvalError.prototype.name")}}
+
Fehlername. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "EvalError.prototype.fileName")}}
+
Pfad zur Datei, die der der Fehler ausgelöst hat. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "EvalError.prototype.lineNumber")}}
+
Zeilennummer in der Datei, in der der Fehler ausgelöst wurde. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "EvalError.prototype.columnNumber")}}
+
Dpaltennummer in der Zeile, in der der Fehler ausgelöst wurde. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "EvalError.prototype.stack")}}
+
Stacktrace. Geerbt von {{jsxref("Error")}}.
+
+ +

Methoden

+ +

Obwohl des {{jsxref("EvalError")}} Prototypobjekt keine eigene Methode enthält, erben {{jsxref("EvalError")}} Instanzen einige Methoden durch die Prototypenkette.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES3')}}{{Spec2('ES3')}}Initiale Definition.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Definiert als NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Definiert als NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}}Definiert als NativeError.prototype.
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.EvalError")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/function/index.html b/files/de/conflicting/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..44598455e8 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,100 @@ +--- +title: Function.prototype +slug: Web/JavaScript/Reference/Global_Objects/Function/prototype +tags: + - Function + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function +translation_of_original: Web/JavaScript/Reference/Global_Objects/Function/prototype +--- +
{{JSRef}}
+ +

Die Function.prototype Eigenschaft repräsentiert das {{jsxref("Function")}} Prototyp Objekt.

+ +

Beschreibung

+ +

{{jsxref("Function")}} Objekte erben von Function.prototype.  Function.prototype kann nicht modifiziert werden.

+ +

Eigenschaften

+ +
+
{{jsxref("Function.arguments")}} {{deprecated_inline}}
+
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
+
{{jsxref("Function.arity")}} {{obsolete_inline}}
+
Wurde benutzt, um die Anzahl der erwarteten Argumente einer Funktion einzustellen, ist jedoch entfernt. Stattdessen kann die {{jsxref("Function.length", "length")}} Eigenschaft genutzt werden.
+
{{jsxref("Function.caller")}} {{non-standard_inline}}
+
Spezifizert die Funktion, die die aktuelle Funktion aufgerufen hat.
+
{{jsxref("Function.length")}}
+
Spezifizert die Anzahl der Parameter, die eine Funktion erwartet.
+
{{jsxref("Function.name")}}
+
Der Name einer Funktion.
+
{{jsxref("Function.displayName")}} {{non-standard_inline}}
+
Der angezeigte Name einer Funktion.
+
Function.prototype.constructor
+
Spezifiziert die Funktion, die ein Objekt Prototyp erstellt. Mehr Informationen bei {{jsxref("Object.prototype.constructor")}}.
+
+ +

Methoden

+ +
+
{{jsxref("Function.prototype.apply()")}}
+
Führt eine Funktion aus und setzt das this Objekt mit einem übergebenen wert. Parameter können in einem {{jsxref("Array")}} Objekt übergeben werden.
+
{{jsxref("Function.prototype.bind()")}}
+
Erstellt eine neue Funktion, die beim Aufruf einen angegebenen Wert für this hat, wobei die Argumentfolge vor dem Aufruf der neuen Funktion fest steht.
+
{{jsxref("Function.prototype.call()")}}
+
Führt eine Funktion aus und setzt this auf einen übergebenen Wert. Parameter können übergeben werden.
+
{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}
+
Gibt true zurück, wenn die Funktion ein Generator ist, anderfalls false.
+
{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}
+
Gibt eine Stringrepräsentation des Quelltextes einer Funktion zurück. Sie überschreibt die {{jsxref("Object.prototype.toSource")}} Methode.
+
{{jsxref("Function.prototype.toString()")}}
+
Gibt eine Stringrepräsentation des Quelltextes einer Funktion zurück. Sie überschreibt die {{jsxref("Object.prototype.toString")}} Methode.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.1
{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.prototype")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html b/files/de/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html new file mode 100644 index 0000000000..e514a8c9d7 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html @@ -0,0 +1,67 @@ +--- +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 +translation_of_original: Web/JavaScript/Reference/Global_Objects/GeneratorFunction/prototype +--- +
{{JSRef}}
+ +

Die GeneratorFunction.prototype Eigenschaft repräsentiert den Prototypen des {{jsxref("GeneratorFunction")}} Objektes.

+ +

Beschreibung

+ +

{{jsxref("GeneratorFunction")}} Objekt erbt von GeneratorFunction.prototype. GeneratorFunction.prototype kann nicht verändert werden.

+ +

Eigenschaften

+ +
+
GeneratorFunction.constructor
+
Der initiale Wert von {{jsxref("GeneratorFunction")}}.
+
GeneratorFunction.prototype.prototype
+
Der Wert ist %GeneratorPrototype%.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.GeneratorFunction.prototype")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/internalerror/index.html b/files/de/conflicting/web/javascript/reference/global_objects/internalerror/index.html new file mode 100644 index 0000000000..8ed0c2de4b --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/internalerror/index.html @@ -0,0 +1,62 @@ +--- +title: InternalError.prototype +slug: Web/JavaScript/Reference/Global_Objects/InternalError/prototype +tags: + - Error + - InternalError + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/InternalError +translation_of_original: Web/JavaScript/Reference/Global_Objects/InternalError/prototype +--- +
{{JSRef}} {{non-standard_header}}
+ +

Die InternalError.prototype Eigenschaft repräsentiert den Prototypen des {{jsxref("InternalError")}} Konstruktors.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Alle {{jsxref("InternalError")}} Instanzen erben von InternalError.prototype. Man kann den Prototypen benutzt, um Eigenschaften oder Methoden für alle Instanzen hinzuzufügen.

+ +

Eigenschaften

+ +
+
InternalError.prototype.constructor
+
Spezifiziert die Funktion, die einen Instanzen Prototyp erstellt.
+
{{jsxref("Error.prototype.message", "InternalError.prototype.message")}}
+
Fehlermeldung. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.name", "InternalError.prototype.name")}}
+
Fehlername. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "InternalError.prototype.fileName")}}
+
Pfad zur Datei, in der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "InternalError.prototype.lineNumber")}}
+
Zeilennummer, in der Datei, in der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "InternalError.prototype.columnNumber")}}
+
Spaltennummer, in der Zeile, in der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "InternalError.prototype.stack")}}
+
Stacktrace. Geerbt von {{jsxref("Error")}}.
+
+ +

Methoden

+ +

Obwohl das {{jsxref("InternalError")}} Prototypobjekt keine eigenen Methoden besitzt, erben {{jsxref("InternalError")}} Instanzen einige Methoden durch die Prototypenkette.

+ +

Spezifikationen

+ +

In keiner Spezifikation enthalten.

+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.InternalError")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/intl/collator/index.html b/files/de/conflicting/web/javascript/reference/global_objects/intl/collator/index.html new file mode 100644 index 0000000000..2b041c3f26 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/intl/collator/index.html @@ -0,0 +1,80 @@ +--- +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 +translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/Collator/prototype +--- +
{{JSRef}}
+ +

Die Intl.Collator.prototype Eigenschaft repräsentiert das Prototypobjekt für den {{jsxref("Collator", "Intl.Collator")}} Konstruktor.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Siehe im Beitrag {{jsxref("Collator")}} für eine Beschreibung von Intl.Collator Instanzen.

+ +

{{jsxref("Collator", "Intl.Collator")}} Instanzen erben von Intl.Collator.prototype. Änderungen am Prototypobjekt werden an alle {{jsxref("Collator", "Intl.Collator")}} Instanzen vererbt.

+ +

Eigenschaften

+ +
+
{{jsxref("Collator.compare", "Intl.Collator.prototype.compare")}}
+
Getter; gibt eine Funktion zurück, die zwei Strings abhängig vom der Sortierreihenfolge des {{jsxref("Global_Objects/Collator", "Intl.Collator")}} Objektes vergleicht.
+
Intl.Collator.prototype.constructor
+
Eine Referenz zu {{jsxref("Global_Objects/Collator", "Intl.Collator")}}.
+
+ +

Methoden

+ +
+
{{jsxref("Collator.resolvedOptions", "Intl.Collator.prototype.resolvedOptions()")}}
+
Gibt ein neues Objekt mit Eigenschaften zu Gebiets- und Collation-Optionen, die bei der Initialisierung des Objekte ermittelt wurden.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES Int 1.0', '#sec-10.2.1', 'Intl.Collator.prototype')}}{{Spec2('ES Int 1.0')}}Initiale Definition.
{{SpecName('ES Int 2.0', '#sec-10.2.1', 'Intl.Collator.prototype')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype', 'Intl.Collator.prototype')}}{{Spec2('ES Int Draft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Intl.Collator.prototype")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/intl/datetimeformat/index.html b/files/de/conflicting/web/javascript/reference/global_objects/intl/datetimeformat/index.html new file mode 100644 index 0000000000..ab0a86d286 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/intl/datetimeformat/index.html @@ -0,0 +1,84 @@ +--- +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 +translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/prototype +--- +
{{JSRef}}
+ +
Die Intl.DateTimeFormat.prototype Eigenschaft ist ein Prototyp Objekt für den {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Konstruktor.
+ +
 
+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Für eine Beschreibung von Intl.DateTimeFormat Instanzen siehe im Artikel {{jsxref("DateTimeFormat")}} nach.

+ +

{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Instanzen erben von Intl.DateTimeFormat.prototype. Änderungen in der Eigenschaft prototype wirken sich auf alle Instanzen von {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} aus.

+ +

Eigenschaften

+ +
+
Intl.DateTimeFormat.prototype.constructor
+
Eine Referenz zu {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.
+
{{jsxref("DateTimeFormat.format", "Intl.DateTimeFormat.prototype.format")}}
+
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.
+
+ +

Methoden

+ +
+
{{jsxref("DateTimeFormat.formatToParts", "Intl.DateTimeFormat.prototype.formatToParts()")}}
+
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.
+
{{jsxref("DateTimeFormat.resolvedOptions", "Intl.DateTimeFormat.prototype.resolvedOptions()")}}
+
Gibt ein neues Objekt mit den Eigenschaften der Sprache und des Formates zum Erstellungszeitpunkt des Objektes zurück.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES Int 1.0', '#sec-12.2.1', 'Intl.DateTimeFormat.prototype')}}{{Spec2('ES Int 1.0')}}Initiale Definition.
{{SpecName('ES Int 2.0', '#sec-12.2.1', 'Intl.DateTimeFormat.prototype')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype', 'Intl.DateTimeFormat.prototype')}}{{Spec2('ES Int Draft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Intl.DateTimeFormat.prototype")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/intl/numberformat/index.html b/files/de/conflicting/web/javascript/reference/global_objects/intl/numberformat/index.html new file mode 100644 index 0000000000..142aefbfcc --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/intl/numberformat/index.html @@ -0,0 +1,82 @@ +--- +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 +translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/prototype +--- +
{{JSRef}}
+ +

Die Intl.NumberFormat.prototype Eigenschaft repräsentiert das Prototypobjekt für einen {{jsxref("NumberFormat", "Intl.NumberFormat")}} Konstruktor.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Siehe {{jsxref("NumberFormat")}} für eine Beschreibung von Intl.NumberFormat Instanzen.

+ +

{{jsxref("NumberFormat", "Intl.NumberFormat")}} Instanzen erben von Intl.NumberFormat.prototype. Veränderungen am Prototypobjekt werden an alle {{jsxref("NumberFormat", "Intl.NumberFormat")}} Instanzen vererbt.

+ +

Eigenschaften

+ +
+
Intl.NumberFormat.prototype.constructor
+
Eine Referenz zu Intl.NumberFormat.
+
{{jsxref("NumberFormat.format", "Intl.NumberFormat.prototype.format")}}
+
Getter; gibt eine Funktion zurück, die eine Zahl nach den Sprach- und Formatierungsoptionen dieses {{jsxref("NumberFormat")}} Objektes formatiert.
+
+ +

Methoden

+ +
+
{{jsxref("NumberFormat.formatToParts", "Intl.NumberFormat.prototype.formatToParts()")}}
+
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.
+
{{jsxref("NumberFormat.resolvedOptions", "Intl.NumberFormat.prototype.resolvedOptions()")}}
+
Gibt ein neues Objekt mit eigenschaften zurück, die Sprach- und Formatierungsoptionen enthält, die bei der Initialisierung des Objektes errechnet wurden.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKomment
{{SpecName('ES Int 1.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}{{Spec2('ES Int 1.0')}}Initiale Definition.
{{SpecName('ES Int 2.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype', 'Intl.NumberFormat.prototype')}}{{Spec2('ES Int Draft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Intl.NumberFormat.prototype")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/map/index.html b/files/de/conflicting/web/javascript/reference/global_objects/map/index.html new file mode 100644 index 0000000000..35399160b1 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/map/index.html @@ -0,0 +1,87 @@ +--- +title: Map.prototype +slug: Web/JavaScript/Reference/Global_Objects/Map/prototype +tags: + - JavaScript + - Map + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Map +translation_of_original: Web/JavaScript/Reference/Global_Objects/Map/prototype +--- +
{{JSRef}}
+ +

Die Map.prototype Eigenschaft repräsentiert den Prototyp für den {{jsxref("Map")}} Konstruktor.

+ +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

{{jsxref("Map")}} Instanzen erben von {{jsxref("Map.prototype")}}. Man kann das prototype Objekt des Konstruktors nutzen, um Eigenschaften oder Methoden für alle map Instanzen hinzuzufügen.

+ +

Eigenschaften

+ +
+
Map.prototype.constructor
+
Gibt die Funktion zurück, die einen Instanzenprototype erstellt. Der Standardwert ist die {{jsxref("Map")}} Funktion.
+
{{jsxref("Map.prototype.size")}}
+
Gibt die Anzahl an Schlüssel/Werte-Paaren in dem Map Objekt zurück.
+
+ +

Methoden

+ +
+
{{jsxref("Map.prototype.clear()")}}
+
Entfernt alle Schlüssel/Werte-Paare von dem Map Objekt.
+
{{jsxref("Map.delete", "Map.prototype.delete(schlüssel)")}}
+
Gibt true zurück, wenn ein Element im Map Objekt existiert und gelöscht wird, oder false wenn das Element nicht existiert. Map.prototype.has(schlüssel) wird danach false zurückgeben.
+
{{jsxref("Map.prototype.entries()")}}
+
Gibt ein neues Iterator Objekt mit allen [Schlüssel, Wert] Paaren als Array von jedem Element in dem Map Objekt in Einfügereihenfolge zurück.
+
{{jsxref("Map.forEach", "Map.prototype.forEach(callbackFn[, thisArg])")}}
+
Ruft callbackFn einmal für jedes Schlüssel/Wert Paar in dem Map Objekt in der Einfügereihenfolge aus. Wenn ein thisArg Parameter angegeben ist, wird dieser als this für jeden Funktionsaufruf benutzt.
+
{{jsxref("Map.get", "Map.prototype.get(schlüssel)")}}
+
Gibt den Wert zu dem zugehörigen schlüssel zurück oder undefined wenn dieser nicht existiert.
+
{{jsxref("Map.has", "Map.prototype.has(schlüssel)")}}
+
Gibt einen boolean zurück, der angibt, ob ein Wert mit den schlüssel in einem Map Objekt vorhanden ist oder nicht.
+
{{jsxref("Map.prototype.keys()")}}
+
Gibt ein neues Iterator Objekt mit allen Schlüsseln von jedem Element in dem Map Objekt in Einfügereihenfolge zurück.
+
{{jsxref("Map.set", "Map.prototype.set(schlüssel, wert)")}}
+
Setzt den wert für einen schlüssel im Map Objekt. Gibt das Map Objekt zurück.
+
{{jsxref("Map.prototype.values()")}}
+
Gibt ein neues Iterator Objekt mit allen Werten von jedem Element in dem Map Objekt in Einfügereihenfolge zurück.
+
{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}
+
Gibt ein neues Iterator Objekt mit allen [Schlüssel, Wert] Paaren als Array von jedem Element in dem Map Objekt in Einfügereihenfolge zurück.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-map.prototype', 'Map.prototype')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-map.prototype', 'Map.prototype')}}{{Spec2('ESDraft')}}
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Map.prototype")}}

+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/number/index.html b/files/de/conflicting/web/javascript/reference/global_objects/number/index.html new file mode 100644 index 0000000000..f44a20d90d --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/number/index.html @@ -0,0 +1,90 @@ +--- +title: Number.prototype +slug: Web/JavaScript/Reference/Global_Objects/Number/prototype +tags: + - JavaScript + - Number + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number +translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/prototype +--- +
{{JSRef}}
+ +

Die Eigenschaft Number.prototype repräsentiert den Prototypen für den {{jsxref("Number")}} Konstruktor.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Alle {{jsxref("Number")}} Instanzen erben von Number.prototype. Das prototype Objekt des {{jsxref("Number")}} Konstruktors kann verändert werden um alle Instanzen von {{jsxref( "Number")}} zu erweitern.

+ +

Eigenschaften

+ +
+
Number.prototype.constructor
+
Gibt die Funktion zurück, die die Instanz dieses Objektes erzeugt hat. Als Standardwert ist das das {{jsxref("Number")}} Objekt.
+
+ +

Methoden

+ +
+
{{jsxref("Number.prototype.toExponential()")}}
+
Gibt eine Zeichenkette (string) zurück, die die Nummer in Exponential Notation repräsentiert.
+
{{jsxref("Number.prototype.toFixed()")}}
+
Gibt eine Zeichenkette (string) zurück, die die Nummer als Festkommazahl repräsentiert.
+
{{jsxref("Number.prototype.toLocaleString()")}}
+
Gibt eine Zeichenkette (string) zurück, die die sprachenübliche Repräsentation der Nummer repräsentiert. Überschreibt die  {{jsxref("Object.prototype.toLocaleString()")}} Methode.
+
{{jsxref("Number.prototype.toPrecision()")}}
+
Gibt eine Zeichenzette (string) zurück, die die Zahl in einer bestimmten Genauigkeit als Festkommazahl repräsentiert.
+
{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}
+
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.
+
{{jsxref("Number.prototype.toString()")}}
+
Gibt eine Zeichenkette (string) zurück, die die Zahl in einer bestimmten Basis repräsentiert. Überschreibt die {{jsxref("Object.prototype.toString()")}} Methode.
+
{{jsxref("Number.prototype.valueOf()")}}
+
Gibt einen primitiven Wert des Objektes zurück. Überschreibt die {{jsxref("Object.prototype.valueOf()")}} Methode.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-properties-of-the-number-prototype-object', 'Number')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Number.prototype")}}

+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/object/index.html b/files/de/conflicting/web/javascript/reference/global_objects/object/index.html new file mode 100644 index 0000000000..d6fdd3de2b --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/object/index.html @@ -0,0 +1,220 @@ +--- +title: Object.prototype +slug: Web/JavaScript/Reference/Global_Objects/Object/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object +translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype +--- +
{{JSRef}}
+ +

Das Object.prototype Attribut repräsentiert das Prototype Objekt von {{jsxref("Object")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Alle Objekte in JavaScript stammen von {{jsxref("Object")}}; alle Objekte erben Methoden und Attribute von Object.prototype, wobei diese  überschrieben werden können (mit Ausnahme von Objekten mit einem null-Prototyp, sprich Object.create(null)). Die Prototypen anderer Konstruktoren zum Beispiel, überschreiben das constructor Attribut und stellen ihre eigenen Methoden zur Verfügung {{jsxref("Object.prototype.toString()", "toString()")}}. Änderungen am  Object prototype Objekt werden an alle Objekte weitergeleitet, solange die betroffenen Attribute und Methoden nicht zuvor in der Kette der Prototypen überschrieben wurden.

+ +

Attribute

+ +
+
{{jsxref("Object.prototype.constructor")}}
+
Die Funktion, die den Prototypen eines Objekts erstellt.
+
{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}
+
Zeigt auf das Objekt, das als bei der Initialisierung des Objektes als Prototyp diente.
+
{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}
+
Erlaubt das Erstellen einer Funktion, die dann ausgeführt wird, wenn ein undefiniertes Objekt als Methode aufgerufen wird.
+
{{jsxref("Object.prototype.count","Object.prototype.__count__")}} {{obsolete_inline}}
+
Wurde benutzt um die Anzahl der aufzählbaren Attribute direkt durch das Objekt zurückzugeben; mittlerweile entfernt.
+
{{jsxref("Object.prototype.parent","Object.prototype.__parent__")}} {{obsolete_inline}}
+
Wurde benutzt um auf den Kontext eines Objektes zu verweisen; mittlerweile entfernt.
+
+ +

Methoden

+ +
+
{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Verknüpft eine Funktion mit einem Attribut, das, wenn darauf zugegriffen wird eine Funktion ausführt und deren Rückgabewert zurück gibt.
+
{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Verknüpft eine Funktion mit einem Attribut, das, wenn dieses gesetzt werden soll, eine Funktion ausführt, die das Attribut modifiziert.
+
{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Gibt die Funktion zurück, die mit dem spezifizierten Attribut über die Methode {{jsxref("Object.prototype.__defineGetter__()", "__defineGetter__()")}} verknüpft ist.
+
{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Gibt die Funktion zurück, die mit dem spezifizierten Attribut über die Methode {{jsxref("Object.prototype.__defineSetter__()", "__defineSetter__()")}} verknüpft ist.
+
{{jsxref("Object.prototype.hasOwnProperty()")}}
+
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.
+
{{jsxref("Object.prototype.isPrototypeOf()")}}
+
Gibt einen Boolean Wert zurück, der anzeigt, ob das spezifizierte Objekt in der Prototyp-Kette des Objekts, das diese Funktion aufruft, enthalten ist.
+
{{jsxref("Object.prototype.propertyIsEnumerable()")}}
+
Gibt einen Boolean Wert zurück, der anzeigt, ob das interne ECMAScript [[Enumerable]] attribute gesetzt ist.
+
{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}
+
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.
+
{{jsxref("Object.prototype.toLocaleString()")}}
+
Ruft {{jsxref("Object.toString", "toString()")}} auf.
+
{{jsxref("Object.prototype.toString()")}}
+
Gibt eine String-Darstellung des Objekts zurück.
+
{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}
+
Entfernt einen Kontrollpunkt von einem Attribut des Objekts.
+
{{jsxref("Object.prototype.valueOf()")}}
+
Gibt den primitiven Wert des spezifizierten Objekts zurück.
+
{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}
+
Fügt einem Attribut des Objekts einen Kontrollpunkt hinzu.
+
{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}
+
Wurde genutzt, um einen String bestehend aus JavaScript Code, im Kontext des aktuellen Objekts auszuwerten; wurde entfernt;
+
+ +

Beispiele

+ +

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:

+ +
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();
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-object.prototype', 'Object.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browser Kompatibilität

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

See also

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/rangeerror/index.html b/files/de/conflicting/web/javascript/reference/global_objects/rangeerror/index.html new file mode 100644 index 0000000000..fba99e1e5a --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/rangeerror/index.html @@ -0,0 +1,129 @@ +--- +title: RangeError.prototype +slug: Web/JavaScript/Reference/Global_Objects/RangeError/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/RangeError +translation_of_original: Web/JavaScript/Reference/Global_Objects/RangeError/prototype +--- +
{{JSRef}}
+ +

Die RangeError.prototype Eigenschaft repräsentiert den Prototypen des {{jsxref("RangeError")}} Konstruktoren.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Alle {{jsxref("RangeError")}} Instanzen erben vom RangeError.prototype. Man kann den Prototypen nutzen um Eigenschaften oder Methoden allen Instanzen hinzuzufügen.

+ +

Eigenschaften

+ +
+
RangeError.prototype.constructor
+
Spezifiziert die Funktion welche den Prototypen einer Instanz erschaffen hat.
+
{{jsxref("Error.prototype.message", "RangeError.prototype.message")}}
+
Fehlermeldung. Obwohl ECMA-262 angibt, dass {{jsxref("RangeError")}} seine eigene message Eigenschaft versorgen sollte, erbt es in SpiderMonkey die {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "RangeError.prototype.name")}}
+
Fehlername. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "RangeError.prototype.fileName")}}
+
Der Dateipfad verursacht diesen Fehler. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "RangeError.prototype.lineNumber")}}
+
Die Zeile in der Datei, bei der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "RangeError.prototype.columnNumber")}}
+
Die Spaltennummer der Zeile , bei der der Fehler auftritt. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "RangeError.prototype.stack")}}
+
Stack - Ablaufverfolgung. Geerbt von {{jsxref("Error")}}.
+
+ +

Methoden

+ +

 Obwohl das {{jsxref("RangeError")}} Prototypobjekt keine eigenen Methoden beinhaltet, beerben {{jsxref("RangeError")}} Instanzen einige Methoden durch die Prototypenkette.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusBeschreibung
{{SpecName('ES3')}}{{Spec2('ES3')}}Initialdefinition.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Definiert als NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Definiert als NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}}Definiert als NativeError.prototype.
+ +

Browserkompatibilität

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
MerkmalChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
MerkmalAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/string/index.html b/files/de/conflicting/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..aad1a12ead --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,190 @@ +--- +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 +translation_of_original: Web/JavaScript/Reference/Global_Objects/String/prototype +--- +
{{JSRef}}
+ +

Die String.prototypeEigenschaft repräsentiert das Prototypobjekt {{jsxref ("String")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Beschreibung

+ +

Alle {{jsxref ("String")}} Instanzen erben von String.prototype. Änderungen am StringPrototypobjekt werden an alle Instanzen von {{jsxref ("String")}} weitergegeben.

+ +

Eigenschaften

+ +
+
String.prototype.constructor
+
Gibt die Funktion an, mit der der Prototyp eines Objekts erstellt wird.
+
{{jsxref ("String.prototype.length")}}
+
Reflektiert die Länge der Zeichenfolge.
+
N
+
Wird verwendet, um auf das Zeichen an der N- ten Position zuzugreifen, wobei N eine ganze Zahl zwischen 0 und eins ist, die kleiner als der Wert von {{jsxref ("String.length", "length")} ist. Diese Eigenschaften sind schreibgeschützt.
+
+ +

Methods

+ +

Methoden

+ +

Methoden, die nichts mit HTML zu tun haben

+ +
+
{{jsxref ("String.prototype.charAt ()")}}
+
Gibt das Zeichen (genau eine UTF-16-Codeeinheit) am angegebenen Index zurück.
+
{{jsxref ("String.prototype.charCodeAt ()")}}
+
Gibt eine Zahl zurück, die der UTF-16-Code-Einheitswert am angegebenen Index ist.
+
{{jsxref ("String.prototype.codePointAt ()")}}
+
Gibt eine nicht negative Ganzzahl zurück, die der Codepunktwert des UTF-16-codierten Codepunkts ab dem angegebenen Index ist.
+
{{jsxref ("String.prototype.concat ()")}}
+
Kombiniert den Text zweier Zeichenfolgen und gibt eine neue Zeichenfolge zurück.
+
{{jsxref ("String.prototype.includes ()")}}
+
Legt fest, ob eine Zeichenfolge in einer anderen Zeichenfolge gefunden werden darf.
+
{{jsxref ("String.prototype.endsWith ()")}}
+
Bestimmt, ob eine Zeichenfolge mit den Zeichen einer anderen Zeichenfolge endet.
+
{{jsxref ("String.prototype.indexOf ()")}}
+
Gibt den Index innerhalb des aufrufenden {{jsxref ("String")}} Objekts des ersten Vorkommens des angegebenen Werts zurück oder -1, falls nicht gefunden.
+
{{jsxref ("String.prototype.lastIndexOf ()")}}
+
Gibt den Index innerhalb des aufrufenden {{jsxref ("String")}} Objekts des letzten Vorkommens des angegebenen Werts zurück oder -1, falls nicht gefunden.
+
{{jsxref ("String.prototype.localeCompare ()")}}
+
Gibt eine Zahl zurück, die angibt, ob eine Referenzzeichenfolge vor oder nach der angegebenen Zeichenfolge in Sortierreihenfolge steht oder mit dieser übereinstimmt.
+
{{jsxref ("String.prototype.match ()")}}
+
Wird verwendet, um einen regulären Ausdruck mit einer Zeichenfolge abzugleichen.
+
{{jsxref ("String.prototype.matchAll ()")}}
+
Gibt einen Iterator aller Übereinstimmungen zurück.
+
{{jsxref ("String.prototype.normalize ()")}}
+
Gibt die Unicode-Normalisierungsform des aufrufenden Zeichenfolgenwerts zurück.
+
{{jsxref ("String.prototype.padEnd ()")}}
+
Füllt die aktuelle Zeichenfolge am Ende mit einer bestimmten Zeichenfolge auf, um aus einer bestimmten Länge eine neue Zeichenfolge zu erstellen.
+
{{jsxref ("String.prototype.padStart ()")}}
+
Füllt die aktuelle Zeichenfolge von Anfang an mit einer bestimmten Zeichenfolge auf, um aus einer bestimmten Länge eine neue Zeichenfolge zu erstellen.
+
{{jsxref ("String.prototype.quote ()")}} {{obsolete_inline}}
+
Umschließt die Zeichenfolge in doppelte Anführungszeichen (" "").
+
{{jsxref ("String.prototype.repeat ()")}}
+
Gibt eine Zeichenfolge zurück, die aus den Elementen des Objekts besteht, die zu den angegebenen Zeiten wiederholt wurden.
+
{{jsxref ("String.prototype.replace ()")}}
+
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.
+
{{jsxref ("String.prototype.search ()")}}
+
Führt die Suche nach einer Übereinstimmung zwischen einem regulären Ausdruck und einer angegebenen Zeichenfolge aus.
+
{{jsxref ("String.prototype.slice ()")}}
+
Extrahiert einen Abschnitt einer Zeichenfolge und gibt eine neue Zeichenfolge zurück.
+
{{jsxref ("String.prototype.split ()")}}
+
Teilt ein {{jsxref ("Global_Objects / String", "String")}} -Objekt in ein Array von Zeichenfolgen auf, indem die Zeichenfolge in Teilzeichenfolgen aufgeteilt wird.
+
{{jsxref ("String.prototype.startsWith ()")}}
+
Legt fest, ob eine Zeichenfolge mit den Zeichen einer anderen Zeichenfolge beginnt.
+
{{jsxref ("String.prototype.substr ()")}} {{deprecated_inline}}
+
Gibt die Zeichen in einer Zeichenfolge zurück, die an der angegebenen Position mit der angegebenen Anzahl von Zeichen beginnt.
+
{{jsxref ("String.prototype.substring ()")}}
+
Gibt die Zeichen in einer Zeichenfolge zwischen zwei Indizes in die Zeichenfolge zurück.
+
{{jsxref ("String.prototype.toLocaleLowerCase ()")}}
+
Die Zeichen in einer Zeichenfolge werden unter Berücksichtigung des aktuellen Gebietsschemas in Kleinbuchstaben konvertiert. Für die meisten Sprachen wird das Gleiche wie {{jsxref ("String.prototype.toLowerCase ()", "toLowerCase ()")}} zurückgegeben.
+
{{jsxref ("String.prototype.toLocaleUpperCase ()")}}
+
Die Zeichen in einer Zeichenfolge werden unter Berücksichtigung des aktuellen Gebietsschemas in Großbuchstaben umgewandelt. Für die meisten Sprachen wird das Gleiche wie {{jsxref ("String.prototype.toUpperCase ()", "toUpperCase ()")}} zurückgegeben.
+
{{jsxref ("String.prototype.toLowerCase ()")}}
+
Gibt den aufrufenden Zeichenfolgenwert zurück, der in Kleinbuchstaben konvertiert wurde.
+
{{jsxref ("String.prototype.toSource ()")}} {{non-standard_inline}}
+
Gibt ein Objektliteral zurück, das das angegebene Objekt darstellt. Mit diesem Wert können Sie ein neues Objekt erstellen. Überschreibt die Methode {{jsxref ("Object.prototype.toSource ()")}}.
+
{{jsxref ("String.prototype.toString ()")}}
+
Gibt eine Zeichenfolge zurück, die das angegebene Objekt darstellt. Überschreibt die Methode {{jsxref ("Object.prototype.toString ()")}}.
+
{{jsxref ("String.prototype.toUpperCase ()")}}
+
Gibt den aufrufenden Zeichenfolgenwert zurück, der in Großbuchstaben konvertiert wurde.
+
{{jsxref ("String.prototype.trim ()")}}
+
Schneidet Leerzeichen vom Anfang und Ende der Zeichenfolge ab. Teil des ECMAScript 5-Standards.
+
{{jsxref ("String.prototype.trimStart ()")}}
+ {{jsxref ("String.prototype.trimLeft ()")}}
+
Schneidet Leerzeichen vom Anfang der Zeichenfolge ab.
+
{{jsxref ("String.prototype.trimEnd ()")}}
+ {{jsxref ("String.prototype.trimRight ()")}
+
Schneidet Leerzeichen vom Ende der Zeichenfolge ab.
+
{{jsxref ("String.prototype.valueOf ()")}}
+
Gibt den Grundwert des angegebenen Objekts zurück. Überschreibt die Methode {{jsxref ("Object.prototype.valueOf ()")}}.
+
{{jsxref ("String.prototype. @@ iterator ()", "String.prototype [@@ iterator] ()")}}
+
Gibt ein neues IteratorObjekt zurück, das die Codepunkte eines String-Werts durchläuft und jeden Codepunkt als String-Wert zurückgibt.
+
+ +

HTML-Wrapper-Methoden

+ +

Diese Methoden sind nur eingeschränkt einsetzbar, da sie nur einen Teil der verfügbaren HTML-Tags und -Attribute bereitstellen.

+ +
+
{{jsxref ("String.prototype.anchor ()")}} {{deprecated_inline}}
+
{{htmlattrxref ("name", "a", "<a name=\"name\">")}} (Hypertext-Ziel)
+
{{jsxref ("String.prototype.big ()")}} {{deprecated_inline}}
+
{{HTMLElement ("big")}}
+
{{jsxref ("String.prototype.blink ()")}} {{deprecated_inline}}
+
{{HTMLElement ("blinken")}}
+
{{jsxref ("String.prototype.bold ()")}} {{deprecated_inline}}
+
{{HTMLElement ("b")}}
+
{{jsxref ("String.prototype.fixed ()")}} {{deprecated_inline}}
+
{{HTMLElement ("tt")}}
+
{{jsxref ("String.prototype.fontcolor ()")}} {{deprecated_inline}}
+
{{htmlattrxref ("color", "font", "<font color = \" color \ ">")}}
+
{{jsxref ("String.prototype.fontsize ()")}} {{deprecated_inline}}
+
{{htmlattrxref ("size", "font", "<font size = \" size \ ">")}}
+
{{jsxref ("String.prototype.italics ()")}} {{deprecated_inline}}
+
{{HTMLElement ("i")}}
+
{{jsxref ("String.prototype.link ()")}} {{deprecated_inline}}
+
{{htmlattrxref ("href", "a", "<a href=\"url\">")}} (Link zu URL)
+
{{jsxref ("String.prototype.small ()")}} {{deprecated_inline}}
+
{{HTMLElement ("small")}}
+
{{jsxref ("String.prototype.strike ()")}} {{deprecated_inline}}
+
{{HTMLElement ("strike")}}
+
{{jsxref ("String.prototype.sub ()")}} {{deprecated_inline}}
+
{{HTMLElement ("sub")}}
+
{{jsxref ("String.prototype.sup ()")}} {{deprecated_inline}}
+
{{HTMLElement ("sup")}}
+
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Anfangsdefinition.
{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}{{Spec2('ESDraft')}}
+ +

Browser-Kompatibilität

+ + + +

{{Compat("javascript.builtins.String.prototype")}}

+ +

Sieh auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html b/files/de/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html new file mode 100644 index 0000000000..eaa648d375 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html @@ -0,0 +1,89 @@ +--- +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 +translation_of_original: Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype +--- +
{{JSRef}}
+ +

Die SyntaxError.prototype Eigenschaft repräsentiert die Eigenschaft die Eigenschaft für den {{jsxref("SyntaxError")}} Konstruktor.

+ +

Beschreibung

+ +

Alle {{jsxref("SyntaxError")}} Instanzen erben von SyntaxError.prototype. Man kann den Prototypen einsetzen, um Eigenschaften oder Methoden für allen Instanzen hinzuzufügen.

+ +

Eigenschaften

+ +
+
SyntaxError.prototype.constructor
+
Spezifiziert die Funktion, die einen Instanz des Prototypen erstellt.
+
{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}
+
Fehlermeldung. Obwohl ECMA-262 Spezifiziert, dass {{jsxref("SyntaxError")}} eine eigene message Eigenschaft haben sollte, erbt dieser in SpiderMonkey die Eigenschaft {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}
+
Fehlername. Vererbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}
+
Pfad zur Datei, in der der Fehler erzeugt wurde. Vererbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}
+
Zeilennummer, in der der Fehler erzeugt wurde. Vererbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}
+
Spaltennummer, in der der Fehler erzeugt wurde. Vererbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}} {{non-standard_inline}}
+
Stack trace. Vererbt von {{jsxref("Error")}}.
+
+ +

Methoden

+ +

Obwohl das {{jsxref("SyntaxError")}} Prototypobjekt keine Methoden enthält, haben {{jsxref("SyntaxError")}} Instanzen einige Vererbte Methoden durch die Prototypenkette.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES3')}}{{Spec2('ES3')}}Initiale Definition.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Definiert als NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Definiert als NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}}Definiert als NativeError.prototype.
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.SyntaxError")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/global_objects/typeerror/index.html b/files/de/conflicting/web/javascript/reference/global_objects/typeerror/index.html new file mode 100644 index 0000000000..6c7e61d363 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/global_objects/typeerror/index.html @@ -0,0 +1,89 @@ +--- +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 +translation_of_original: Web/JavaScript/Reference/Global_Objects/TypeError/prototype +--- +
{{JSRef}}
+ +

Die TypeError.prototype Eigenschaft repräsentiert den prototype des {{jsxref("TypeError")}} Konstruktors.

+ +

Beschreibung

+ +

Alle {{jsxref("TypeError")}} Instanzen erben von TypeError.prototype. Dem prototype können über alle Instanzen hinweg Eigenschaften und Methoden hinzugefügt werden.

+ +

Eigenschaften

+ +
+
TypeError.prototype.constructor
+
Spezifiziert die Instanz erstellende Funktion.
+
{{jsxref("Error.prototype.message", "TypeError.prototype.message")}}
+
Fehlermeldung. ECMA-262 spezifiziert, dass {{jsxref("TypeError")}} eine eigene message Eigenschaft zur Verfügung stellen soll. In SpiderMonkey jedoch, erbt es von {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "TypeError.prototype.name")}}
+
Fehlerbezeichnung. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "TypeError.prototype.fileName")}}
+
Pfad zur Datei, welche den Fehler verursachte. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "TypeError.prototype.lineNumber")}}
+
Zeile in welcher der Fehler verusacht wurde. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "TypeError.prototype.columnNumber")}}
+
Zeichennummer der Zeile in welcher der Fehler verursacht wurde. Geerbt von {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "TypeError.prototype.stack")}}
+
Stack trace. Geerbt von {{jsxref("Error")}}.
+
+ +

Methoden

+ +

Das {{jsxref("TypeError")}} prototype Objekt beinhaltet keine eigenen Methoden, jedoch erben {{jsxref("TypeError")}} Instanzen einige Methoden durch die Prototypenkette.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES3', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES3')}}Initiale Definition
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Definiert als NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Definiert als NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.TypeError")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/operators/index.html b/files/de/conflicting/web/javascript/reference/operators/index.html new file mode 100644 index 0000000000..598d43df68 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/operators/index.html @@ -0,0 +1,575 @@ +--- +title: Bitweise Operatoren +slug: Web/JavaScript/Reference/Operators/Bitwise_Operatoren +tags: + - JavaScript + - Operator + - Reference +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators +--- +
{{jsSidebar("Operators")}}
+ +

Bitweise Operatoren werden auf Sequenzen aus 32 bit (Nullen und Einsen) angewandt im Gegensatz zu Operatoren, die mit Dezimal-, Hexadezimal- oder Oktalzahlen (numbers) arbeiten. Beispielsweise hat die Dezimalzahl neun die binäre Darstellung 1001. Auch wenn Bitweise Operatoren mit Binärdarstellungen arbeiten, sind deren Ausgabewerte Javascript Standardzahlenwerte.

+ +
{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}
+ + + +

Die folgende Tabelle fasst Javascripts Bitweise Operatoren zusammen:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorEinsatzBeschreibung
Bitweises UNDa & bGibt 1 in jeder Bit Position zurück, an welcher beide Operanden 1 sind.
Bitweises ODERa | bGibt 1 in jeder Bit Position zurück, an welcher einer oder beide Operanden 1 sind.
Bitweises XORa ^ bGibt 1 in jeder Bit Position zurück, an welcher einer aber nicht beide Operanden 1 sind.
Bitweise Negation~ aInvertiert die Bits des Operanden
Linksverschiebunga << bVerschiebt a in binärer Repräsentation b (< 32) Bits nach links, von Rechts werden Nullen hereingeschoben.
Vorzeichen propagierende Rechtsverschiebunga >> bVerschiebt a in binärer Repräsentation b (< 32) Bits nach rechts, herausgeschobene Bits werden verworfen.
Null füllende Rechtsverschiebunga >>> bVerschiebt a in binärer Repräsentation b (< 32) Bits nach rechts, herausgeschobene Bits werden verworfen und Nullen werden von links hereingeschoben.
+ +

Vorzeichenbehaftete 32-Bit Integer

+ +

Die Operanden aller Bitweisen Operationen werden in vorzeichenbehaftete 32-Bit Integer im Zweierkomplementformat konvertiert. Zweierkomplementformat bedeutet, dass das Gegenstück einer negative Zahl alle Bits invertiert (Bitweise Negation einer Zahl oder auch Einerkomplement einer Zahl) plus eins ist. Zum Beispiel die codierte Integer 314:

+ +
00000000000000000000000100111010
+
+ +

Im Folgenden ist ~314 codiert, d. h. das Einerkomplement von 314:

+ +
11111111111111111111111011000101
+
+ +

Anschließend wird -314 codiert, d. h. das Zweierkomplement 314:

+ +
11111111111111111111111011000110
+
+ +

Das Zweierkomplement garantiert, dass das Bit ganz links 0 ist, wenn die Zahl Positiv ist und 1 ist, wenn die Zahl negativ ist. Dieses wird das Vorzeichenbit genannt.

+ +

Die Zahl 0 ist ein Integer, der komplett aus 0 Bits besteht.

+ +
0 (base 10) = 00000000000000000000000000000000 (base 2)
+
+ +

Die Zahl -1 ist ein Integer der komplett aus 1 Bits besteht.

+ +
-1 (base 10) = 11111111111111111111111111111111 (base 2)
+
+ +

Die Zahl -2147483648 (hexadezimale Repräsentation: -0x80000000) ist der Integer, welcher komplett aus 0 Bits besteht, außer dem ersten Bit (linkes Bit).

+ +
-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)
+
+ +

Die Zahl 2147483647 (hexadezimale Repräsentation: -0x7fffffff) ist der Integer, welcher komplett aus 1 Bits besteht, außer dem ersten Bit (linkes Bit).

+ +
2147483647 (base 10) = 01111111111111111111111111111111 (base 2)
+
+ +

Die Zahlen -2147483648 und 2147483647 sind die minimalen und Maximalen Integers, die mit 32-Bit vorzeichenbehafteten Zahlen repräsentiert werden können.

+ +

Bitweise logische Operatoren

+ +

Konzeptionell arbeiten die bitweisen logischen Operatoren wie folgt:

+ + + +

& (Bitweises UND)

+ +

Führt die UND Operation auf jedem Bitpaar durch. a UND b ergibt 1, wenn beide a und b 1 sind. Die Wahrheitstabelle für den UND Operator ist:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba UND b
000
010
100
111
+ +
.    9 (Basis 10) = 00000000000000000000000000001001 (Basis 2)
+    14 (Basis 10) = 00000000000000000000000000001110 (Basis 2)
+                    --------------------------------
+14 & 9 (Basis 10) = 00000000000000000000000000001000 (Basis 2) = 8 (Basis 10)
+
+ +

Bitweises verUNDen jeder Zahl x mit 0 ergibt 0. Bitweises verUNDen jeder Zahl x mit -1 ergibt x.

+ +

| (Bitweises ODER)

+ +

Führt die ODER Operation auf jedem Bitpaar durch. a ODER b ergibt 1, wenn einer, a oder b, 1 sind. Die Wahrheitstabelle für den ODER Operator ist:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba ODER b
000
011
101
111
+ +
.    9 (Basis 10) = 00000000000000000000000000001001 (Basis 2)
+    14 (Basis 10) = 00000000000000000000000000001110 (Basis 2)
+                    --------------------------------
+14 | 9 (Basis 10) = 00000000000000000000000000001111 (Basis 2) = 15 (Basis 10)
+
+ +

Bitweises verODERn jeder Zahl x mit 0 ergibt x. Bitweises verODERn jeder Zahl x mit -1 ergibt -1.

+ +

^ (Bitweises XOR)

+ +

Führt die XOR Operation auf jedem Bitpaar durch. a XOR b ergibt 1, wenn sich a und b, unterscheiden. Die Wahrheitstabelle für den XOR Operator ist:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba XOR b
000
011
101
110
+ +
.    9 (Basis 10) = 00000000000000000000000000001001 (Basis 2)
+    14 (Basis 10) = 00000000000000000000000000001110 (Basis 2)
+                    --------------------------------
+14 ^ 9 (Basis 10) = 00000000000000000000000000000111 (Basis 2) = 7 (Basis 10)
+
+ +

Bitweises verXORn jeder Zahl x mit 0 ergibt x. Bitweises verXORn jeder Zahl x mit -1 ergibt ~x.

+ +

~ (Bitweise Negation)

+ +

Führt die Negationsoperation auf jedem Bit durch. NICHT a ergibt ergibt den invertierten Wert (d. h. das Einerkomplement) von a. Die Wahrheitstabelle für den Negationsoperator ist:

+ + + + + + + + + + + + + + + + +
aNICHT a
01
10
+ +
 9 (Basis 10) = 00000000000000000000000000001001 (Basis 2)
+                --------------------------------
+~9 (Basis 10) = 11111111111111111111111111110110 (Basis 2) = -10 (Basis 10)
+
+ +

Bitweises Negieren jeder Zahl x ergibt -(x + 1). Zum Beispiel ergibt ~-5 4.

+ +

Beispiel mit indexOf:

+ +
var str = 'rawr';
+var searchFor = 'a';
+
+// Das ist eine alternativer Weg um if (-1*str.indexOf('a') <= 0) zu tippen
+if (~str.indexOf(searchFor)) {
+  // searchFor is in the string
+} else {
+  // searchFor is not in the string
+}
+
+// Hier die Werte, die von (~str.indexOf(searchFor)) zurück gegeben werden
+// r == -1
+// a == -2
+// w == -3
+
+ +

Bitweise Verschiebeoperatoren

+ +

Die bitweisen Verschiebeoperatoren (shift Operatoren) haben zwei Operanden: Der erste ist der Anteil, der verschoben werden soll und der zweite ist die Anzahl der Positionen, um die der erste Operand verschoben werden soll. Die Richtung der Verschiebung wird durch den eingesetzten Operator festgelegt.

+ +

Verschiebeoperatoren konvertieren ihre Operanden in 32-Bit Integers in Bit-Endian Reihenfolge und geben als Resultat den gleichen Typ des linken Operanden zurück. Der rechte Operand sollte kleiner als 32 sein, aber wenn das nicht so ist, werden nur die kleinsten fünf Bits verwendet.

+ +

<< (Linksverschiebung)

+ +

Dieser Operator verschiebt den ersten Operand um die spezifizierte Anzahl von Bits nach links. Überflüssige Bits, die nach links verschoben wurden, werden verworfen. Von rechts wird mit 0-Bits aufgefüllt.

+ +

Zum Beispiel ergibt 9 << 2 36:

+ +
.    9 (Basis 10): 00000000000000000000000000001001 (Basis 2)
+                   --------------------------------
+9 << 2 (Basis 10): 00000000000000000000000000100100 (Basis 2) = 36 (Basis 10)
+
+ +

Bitweises Verschieben jeder Zahl x nach links mit y Bits ergibt x * 2 ** y.

+ +

>> (Vorzeichen propagierende Rechtsverschiebung)

+ +

Dieser Operator verschiebt den ersten Operand um die spezifizierte Anzahl von Bits nach rechts. Überflüssige Bits, die nach rechts verschoben wurden, werden verworfen. Kopien des linken Bits (Vorzeichenbits) werden von links hereingeschoben. Weil das neue Vorzeichenbit immer das selbe wie das alte Vorzeichenbit ist, ändert sich das linke Bit nicht. Daher kommt der Name "Vorzeichen propagierend" her.

+ +

Zum Beispiel ergibt 9 >> 2 2:

+ +
.    9 (base 10): 00000000000000000000000000001001 (base 2)
+                  --------------------------------
+9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
+
+ +

Likewise, -9 >> 2 yields -3, because the sign is preserved:

+ +
.    -9 (Basis 10): 11111111111111111111111111110111 (Basis 2)
+                    --------------------------------
+-9 >> 2 (Basis 10): 11111111111111111111111111111101 (Basis 2) = -3 (Basis 10)
+
+ +

>>> (Null füllende Rechtsverschiebung)

+ +

Dieser Operator verschiebt den ersten Operand um die spezifizierte Anzahl von Bits nach rechts. Überflüssige Bits, die nach rechts verschoben wurden, werden verworfen. Von link wird mit 0-Bits aufgefüllt. Das Vorzeichenbit wird 0, so dass das Ergebnis nie negativ ist.

+ +

Für nicht negative Zahlen ist das Ergebnis bei der Null füllenden Rechtsverschiebung und bei der Vorzeichen propagierenden Rechtsverschiebung das selbe. Zum Beispiel ergibt 9 >>> 2 2, das selbe wie 9 >> 2:

+ +
.     9 (Basis 10): 00000000000000000000000000001001 (Basis 2)
+                    --------------------------------
+9 >>> 2 (Basis 10): 00000000000000000000000000000010 (Basis 2) = 2 (Basis 10)
+
+ +

Jedoch ist das nicht der Fall für negative Zahlen. Zum Beispiel ergibt -9 >>> 2 1073741821, was sich unterschiedet von -9 >> 2 (was -3 ergibt):

+ +
.     -9 (Basis 10): 11111111111111111111111111110111 (Basis 2)
+                     --------------------------------
+-9 >>> 2 (Basis 10): 00111111111111111111111111111101 (Basis 2) = 1073741821 (Basis 10)
+
+ +

Beispiele

+ +

Flags und Bitmasken

+ +

Die bitweisen logischen Operatoren werden häufig eingesetzt, um Sequenzen von Flags zu erstellen, zu manipulieren und zu lesen, welche wie binäre Variablen sind. Variablen können statt dieser Sequenzen genutzt werden, aber binäre Flags verbrauchen weniger Speicher (um den Faktor 32).

+ +

Angenommen es gibt 4 Flags:

+ + + +

Diese Flags sind durch eine Sequenz von Bits repräsentiert: DCBA. Wenn ein Flag gesetzt wird, hat es den Wert 1. Wenn ein Flag geleert wird, hat es den Wert 0. Angenommen eine Variable flags hat den binären Wert 0101:

+ +
var flags = 5;   // binär 0101
+
+ +

Dieser Wert zeigt an:

+ + + +

Weil Bitweise Operatoren mit 32-Bit arbeiten, ist 0101 eigentlich 00000000000000000000000000000101, aber die führenden nullen können vernachlässigt werden, weil sie keine Informationen enthalten.

+ +

Eine Bitmaske ist eine Sequenz von Bits, die Flags manipulieren und/oder lesen kann. Typisch ist es, dass eine "primitive" Bitmaske für jedes Flag definiert ist:

+ +
var FLAG_A = 1; // 0001
+var FLAG_B = 2; // 0010
+var FLAG_C = 4; // 0100
+var FLAG_D = 8; // 1000
+
+ +

Neue Bitmasken können erstellt werden, indem bitweise logische Operatoren auf den primitiven Bitmasken angewendet werden. Zum Beispiel kann die Bitmaske 1011 mit VerODERn von FLAG_A, FLAG_B und FLAG_D erstellt werden:

+ +
var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011
+
+ +

Individuelle Flagwerte können durch das VerUNDen mit einer Bitmaske extrahiert werden, wobei jedes Bit mit dem Wert eins das korrespondierende Flag extrahiert. Die Bitmaske wirft nicht relevante Flags heraus, indem Nullen verUNDet werden (daher der Begriff "Bitmaske"). Zum Beispiel kann die Bitmaske 0100 genutzt werden, um zu sehen, ob Flag C gesetzt ist:

+ +
// Wenn man eine Katze besitzt
+if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true
+   // tu irgendetwas
+}
+
+ +

Eine Bitmaske mit mehreren gesetzten Flags funktioniert wie ein "entweder/oder". Zum Beispiel sind die beiden folgenden Ansätze äquivalent:

+ +
// wenn man eine Fledermaus besitzt oder eine Katze besitzt
+// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
+if ((flags & FLAG_B) || (flags & FLAG_C)) {
+   // do stuff
+}
+
+ +
// wenn man eine Fledermaus oder eine Katze besitzt
+var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110
+if (flags & mask) { // 0101 & 0110 => 0100 => true
+   // do stuff
+}
+
+ +

Flags können mit VerODERung mit einer Bitmaske gesetzt werden, wobei jedes Bit in der Bitmaske mit dem Wert 1 wird das korrespondierende Flag setzen, wenn es noch nicht gesetzt ist. Zum Beispiel kann die Bitmaske 1100 benutzt werden, um die Flags C und D zu setze:

+ +
// ja, man besitzt eine Katze und eine Ente
+var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100
+flags |= mask;   // 0101 | 1100 => 1101
+
+ +

Flags können mit VerUNDung mit einer Bitmaske geleert werden, wobei jedes Bit in der Bitmaske mit dem Wert 0 wird das korrespondierende Flag geleert, wenn es noch nicht geleert ist. Die Bitmaske dafür kann mit Negation primitiver Bitmasken erstellt werden Zum Beispiel kann die Bitmaske 1010 benutzt werden, um die Flags A und C zu leeren:

+ +
// no, we don't have an ant problem or own a cat
+var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010
+flags &= mask;   // 1101 & 1010 => 1000
+
+ +

The mask could also have been created with ~FLAG_A & ~FLAG_C (De Morgan's law):

+ +
// nein, mat hat kein Problem mit Ameisen und man besitzt keine Katze
+var mask = ~FLAG_A & ~FLAG_C;
+flags &= mask;   // 1101 & 1010 => 1000
+
+ +

Flags können mit VerXORung mit einer Bitmaske umgeschaltet werden, wobei jedes Bit in der Bitmaske mit dem Wert 1 wird das korrespondierende Flag umschaltet. Zum Beispiel kann die Bitmaske 0110 benutzt werden, um die Flags B und C umzuschalten:

+ +
// wenn man keine Fledermaus besitzt und und jetzt eine bekommt
+// and wenn man eine hat und die Fledermaus verabschiedet
+// das gleiche für eine Katze
+var mask = FLAG_B | FLAG_C;
+flags = flags ^ mask;   // 1100 ^ 0110 => 1010
+
+ +

Alle Flags können mit dem Negationsoperator umgedreht werden:

+ +
// entering parallel universe...
+flags = ~flags;    // ~1010 => 0101
+
+ +

Konvertierungsbeispiele

+ +

Konvertierung eines binär String zu einer dezimal Number:

+ +
var sBinString = '1011';
+var nMyNumber = parseInt(sBinString, 2);
+alert(nMyNumber); // prints 11, i.e. 1011
+
+ +

Konvertierung einer dezimal Number zu einem binär String:

+ +
var nMyNumber = 11;
+var sBinString = nMyNumber.toString(2);
+alert(sBinString); // prints 1011, i.e. 11
+
+ +

Bitmaskenerstellung automatisieren

+ +

Man kann, wie folgt, mehrere Masken von einer Menge von Boolean Werten erstellen:

+ +
function createMask() {
+  var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;
+  for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
+  return nMask;
+}
+var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011
+var mask2 = createMask(false, false, true); // 4, i.e.: 0100
+var mask3 = createMask(true); // 1, i.e.: 0001
+// etc.
+
+alert(mask1); // prints 11, i.e.: 1011
+
+ +

Umgedrehter Algorithmus: Ein Array von Booleanen von einer Bitmaske

+ +

Wenn man ein Array mit Boolean Werten von einer Bitmaske haben möchte, kann man folgenden Code benutzen:

+ +
function arrayFromMask(nMask) {
+  // nMask must be between -2147483648 and 2147483647
+  if (nMask > 0x7fffffff || nMask < -0x80000000) {
+    throw new TypeError('arrayFromMask - out of range');
+  }
+  for (var nShifted = nMask, aFromMask = []; nShifted;
+       aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1);
+  return aFromMask;
+}
+
+var array1 = arrayFromMask(11);
+var array2 = arrayFromMask(4);
+var array3 = arrayFromMask(1);
+
+alert('[' + array1.join(', ') + ']');
+// prints "[true, true, false, true]", i.e.: 11, i.e.: 1011
+
+ +

Man kann beide Algorithmen gleichzeitig testen:

+ +
var nTest = 19; // our custom mask
+var nResult = createMask.apply(this, arrayFromMask(nTest));
+
+alert(nResult); // 19
+
+ +

Nur aus didaktischen Gründen (weil dort die Number.toString(2) Methode ist), zeigen wir, wie es möglich ist den arrayFromMask Algorithmus zu verändern, um einen String mit der Binärrepräsentation der Number statt eines Arrays von Booleanen:

+ +
function createBinaryString(nMask) {
+  // nMask must be between -2147483648 and 2147483647
+  for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32;
+       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
+  return sMask;
+}
+
+var string1 = createBinaryString(11);
+var string2 = createBinaryString(4);
+var string3 = createBinaryString(1);
+
+alert(string1);
+// prints 00000000000000000000000000001011, i.e. 11
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition.
{{SpecName('ES5.1', '#sec-11.7')}}{{Spec2('ES5.1')}}Definiert in verschiedenen Abschnitten der Spezifikation: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators
{{SpecName('ES6', '#sec-bitwise-shift-operators')}}{{Spec2('ES6')}}Definiert in verschiedenen Abschnitten der Spezifikation: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators
{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}{{Spec2('ESDraft')}}Definiert in verschiedenen Abschnitten der Spezifikation: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.operators.bitwise")}}

+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/operators/spread_syntax/index.html b/files/de/conflicting/web/javascript/reference/operators/spread_syntax/index.html new file mode 100644 index 0000000000..ee125663f4 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/operators/spread_syntax/index.html @@ -0,0 +1,220 @@ +--- +title: Spread-Operator +slug: Web/JavaScript/Reference/Operators/Spread_operator +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators/Spread_syntax +translation_of_original: Web/JavaScript/Reference/Operators/Spread_operator +--- +
{{jsSidebar("Operators")}}
+ +

Mit der Spread-Syntax kann ein einzelner Ausdruck dort expandiert werden, wo mehrere Argumente (bei Funktionsaufrufen), mehrere Elemente (für Array-Literale) oder mehrere Variablen (für destrukturierende Anweisungen) erwartet werden.

+ +

Syntax

+ +

Für Funktionsaufrufe:

+ +
myFunction(...iterableObj);
+
+ +

Für Array-Literale:

+ +
[...iterableObj, 4, 5, 6]
+ +

Beispiele

+ +

Ein besseres "apply"

+ +

Beispiel: Für gewöhnlich wird {{jsxref( "Function.prototype.apply")}} verwendet, wenn man die Elemente eines Arrays als Argumente eines Funktionsaufrufs nutzen möchte:

+ +
function myFunction(x, y, z) { }
+var args = [0, 1, 2];
+myFunction.apply(null, args);
+ +

Mit dem ES2015 Spread-Operator kann das nun wie folgt geschrieben werden:

+ +
function myFunction(x, y, z) { }
+var args = [0, 1, 2];
+myFunction(...args);
+ +

Die Spread-Syntax kann für jedes beliebige Argument der Argumentliste verwendet werden, und sie kann auch mehrmals verwendet werden:

+ +
function myFunction(v, w, x, y, z) { }
+var args = [0, 1];
+myFunction(-1, ...args, 2, ...[3]);
+ +

Ein mächtigeres Array-Literal

+ +

Beispiel: Wenn man ohne den Spread-Operator ein neues Array erstellen will, bei dem ein Teil davon ein bereits bestehendes Array sein soll, dann ist die Array-Literal-Syntax nicht mehr ausreichend und man muss auf imperative Programmierung mit einer Kombination aus push, splice, concat, etc. zurückgreifen. Mit der Spread-Syntax jedoch kann das viel prägnanter ausgedrückt werden:

+ +
var parts = ['shoulders', 'knees'];
+var lyrics = ['head', ...parts, 'and', 'toes']; // ["head", "shoulders", "knees", "and", "toes"]
+
+ +

Genau wie der Spread-Operator für Argumentlisten kann ... überall im Array-Literal verwendet werden, auch mehrmals.

+ +

"Apply" für "new"

+ +

Beispiel: In ES5 kann new nicht mit apply kombiniert werden (nach den ES5-Regeln führt apply einen [[Call]] aus, keinen [[Construct]]). Die Spread-Syntax von ES2015 unterstützt dies auf ganz natürliche Weise:

+ +
var dateFields = readDateFields(database);
+var d = new Date(...dateFields);
+ +

Ein Array kopieren

+ +
var arr = [1,2,3];
+var arr2 = [...arr]; // wie arr.slice()
+arr2.push(4);        // arr2 wird [1,2,3,4], arr bleibt unverändert.
+ +

Ein besseres "push"

+ +

Beispiel: {{jsxref("Global_Objects/Array/push", "push")}} wird oft verwendet um alle Elemente eines Arrays an das Ende eines bestehenden Arrays anzuhängen. Das wird in ES5 oft wie folgt umgesetzt:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+// Append all items from arr2 onto arr1
+Array.prototype.push.apply(arr1, arr2);
+ +

Mit dem Spread-Operator von ES2015 wird daraus:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+arr1.push(...arr2);
+ +

Nur "apply" für iterables

+ +
var obj = {"key1":"value1"};
+function myFunction(x) {
+    console.log(x) // undefined
+}
+myFunction(...obj);
+var args = [...obj];
+console.log(args, args.length); // [] 0
+ +

Rest-Syntax (Parameter)

+ +

Rest-Syntax sieht genauso aus wie die Spread-Syntax und wird für das Destrukturieren von Arrays und Objekten eingesetzt. Rest-Syntax ist sozusagen das Gegenteil von Spread-Syntax:  Spread klappt die einzelnen Bestandteile eines Arrays aus, während Rest verschiedene einzelne Elemente zu einem Array zusammenfasst.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-array-initializer')}}{{Spec2('ES2015')}}Definiert in verschiedenen Abschnitten der Spezifikation: Array Initializer, Argument Lists
{{SpecName('ESDraft', '#sec-array-initializer')}}{{Spec2('ESDraft')}} 
+ +

Browser-Kompatibilität

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Spread-Operation innerhalb von Array-Literalen{{CompatChrome("46")}}{{CompatGeckoDesktop("16")}}{{CompatIE("Edge")}}{{CompatNo}}7.1
Spread-Operation innerhalb von Funktionsaufrufen{{CompatChrome("46")}}{{CompatGeckoDesktop("27")}}{{CompatIE("Edge")}}{{CompatNo}}7.1
Spread-Operation beim Destrukturieren ("destructuring"){{CompatChrome("49")}}{{CompatGeckoDesktop("34")}}{{CompatNo}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Spread-Operation innerhalb von Array-Literalen{{CompatNo}}{{CompatChrome("46")}}{{CompatGeckoMobile("16")}}{{CompatNo}}{{CompatNo}}8{{CompatChrome("46")}}
Spread-Operation innerhalb von Funktionsaufrufen{{CompatNo}}{{CompatChrome("46")}}{{CompatGeckoMobile("27")}}{{CompatNo}}{{CompatNo}}8{{CompatChrome("46")}}
Spread-Operation beim Destrukturieren ("destructuring"){{CompatNo}}{{CompatNo}}{{CompatGeckoDesktop("34")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatNo}}
+
+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/operators_5b3986b830cf68059c03079ef10ff039/index.html b/files/de/conflicting/web/javascript/reference/operators_5b3986b830cf68059c03079ef10ff039/index.html new file mode 100644 index 0000000000..ceedd1eb07 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/operators_5b3986b830cf68059c03079ef10ff039/index.html @@ -0,0 +1,244 @@ +--- +title: Vergleichsoperatoren +slug: Web/JavaScript/Reference/Operators/Vergleichsoperatoren +tags: + - JavaScript + - Operator + - Reference +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators +--- +
{{jsSidebar("Operators")}}
+ +

JavaScript kennt sowohl den strikten als auch den Typ konvertierenden Vergleich. Ein strikter Vergleich (z. B. ===) gibt nur true zurück, wenn der gleiche Typ und der gleiche Wert vorhanden sind. Der häufiger verwendete abstrakte Vergleich (z. B. ==) wandelt die Operanden in den gleichen Typen um, bevor sie verglichen werden. Bei relationalen Vergleichsoperatoren (z. B. <=) werden die Operanden vor dem Vergleich zuerst in elementare Datentypen konvertiert und dann in gleiche Typen umgewandelt.

+ +

Strings werden entsprechend der lexikographischen Ordnung, basierend auf den Unicode, verglichen.

+ +
{{EmbedInteractiveExample("pages/js/expressions-comparisonoperators.html")}}
+ + + +

Merkmale von Vergleichen:

+ + + +

Gleichheitsoperatoren

+ +

Gleichheit (==)

+ +

Der Gleichheitsoperator konvertiert die Operanden, wenn sie nicht vom gleichen Typs sind und prüft dann auf strikte Gleichheit. Sind beide Operanden Objekte, vergleicht JavaScript die Referenzen; Referenzen gelten als gleich, wenn sie auf das gleiche Objekt im Speicher zeigen.

+ +

Syntax

+ +
x == y
+
+ +

Beispiele

+ +
1    ==  1     // true
+'1'  ==  1     // true
+1    == '1'    // true
+0    == false  // true
+0    == null   // false
+var object1 = {'key': 'value'}, object2 = {'key': 'value'}
+object1 == object2 // false
+0    == undefined  // false
+null == undefined  // true
+
+ +

Ungleichheit (!=)

+ +

Der Ungleichheitsoperator gibt true zurück, wenn die Operanden nicht gleich sind. Wenn die beiden Operanden nicht vom gleichen Typ sind, versucht JavaScript die Operanden in einen, für den Vergleich passenden Typ, umzuwandeln. Wenn beide Operanden Objekte sind, vergleicht JavaScript die Referenzen; Referenzen sind ungleich, wenn sie auf verschiedene Objekte im Speicher verweisen.

+ +

Syntax

+ +
x != y
+ +

Beispiele

+ +
1 !=   2     // true
+1 !=  "1"    // false
+1 !=  '1'    // false
+1 !=  true   // false
+0 !=  false  // false
+
+ +

Identität / strikte Gleichheit (===)

+ +

Der Identitätsoperator gibt true zurück, wenn die Operanden strikt gleich sind (siehe oben) ohne eine Typkonvertierung

+ +

Syntax

+ +
x === y
+ +

Beispiele

+ +
3 === 3   // true
+3 === '3' // false
+var object1 = {'key': 'value'}, object2 = {'key': 'value'}
+object1 === object2 // false
+
+ +

Nicht identisch / Strikte Ungleichheit (!==)

+ +

Der strikte Ungleichheitsoperator gibt true zurück, wenn die Operanden nicht vom gleichen Typ sind bzw. ungleich sind.

+ +

Syntax

+ +
x !== y
+ +

Beispiele

+ +
3 !== '3' // true
+4 !== 3   // true
+
+ +

Relationale Operatoren

+ +

Jeder dieser Operatoren wird die valueOf() Funktion aufrufen, bevor ein Vergleich durchgeführt wird.

+ +

Größer-als-Operator (>)

+ +

Der Größer-als-Operator gibt true zurück, wenn der linke Operand größer als der rechte Operand ist.

+ +

Syntax

+ +
x > y
+ +

Beispiele

+ +
4 > 3 // true
+
+ +

Größer-oder-gleich-Operator (>=)

+ +

Der Größer-oder-gleich-Operator gibt true zurück, wenn der linke Operand größer als oder gleich dem rechten Operanden ist.

+ +

Syntax

+ +
 x >= y
+ +

Beispiele

+ +
4 >= 3 // true
+3 >= 3 // true
+
+ +

Kleiner-als-Operator (<)

+ +

Der Kleiner-als-Operator gibt true zurück, wenn der linke Operand kleiner als der rechte Operand ist.

+ +

Syntax

+ +
 x < y
+ +

Beispiele

+ +
3 < 4 // true
+
+ +

Kleiner-oder-gleich-Operator (<=)

+ +

Der Kleiner-oder-gleich-Operator gibt true zurück, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist.

+ +

Syntax

+ +
 x <= y
+ +

Beispiele

+ +
3 <= 4 // true
+
+ +

Die Gleichheitsoperatoren anwenden

+ +

Die Standard-Gleichheitsoperatoren (== und !=) benutzen den Abstract Equality Comparison Algorithmus, um zwei Operanden zu vergleichen. Sind die Operanden unterschiedlichen Typs, wird vor dem Vergleich zuerst versucht sie in gleiche Typen umzuwandeln; z.B. wird beim Ausdruck 5 == '5'  das Zeichen auf der rechten Seite in eine Zahl konvertiert.

+ +

Die strikten Gleichheitsoperatoren (=== und !==) benutzen den Strict Equality Comparison Algorithmus und sind dafür gedacht, Operanden des gleichen Typs zu vergleichen. Wenn die Operanden von unterschiedlichen Typen sind, ist das Ergebnis immer false, wie 5 !== '5'.

+ +

Strikte Gleichheitsoperatoren sollten verwendet werden, wenn die Operanden sowohl einen bestimmten Typen als auch Wert haben sollen. Ansonsten benutzt man die abstrakten Gleichheitsoperatoren, die es einem erlauben Operanden unterschiedlicher Typen zu vergleichen.

+ +

Wenn beim Vergleich eine Typkonvertierung vorgenommen wird (z.B. beim nicht-strikten Vergleich), konvertiert JavaScript in die Typen {{jsxref("String")}}, {{jsxref("Number")}}, {{jsxref("Boolean")}} und {{jsxref("Object")}} und führt den Vergleich dann aus:

+ + + +
Hinweis: String Objekte sind vom Typ Objekte, nicht String! String Objekte werden selten eingesetzt, so dass das folgende Ergebnis überraschend sein kann:
+ +
// true, da beide Operanden vom Typ String sind (string primitives)
+'foo' === 'foo'
+
+var a = new String('foo');
+var b = new String('foo');
+
+// false, da a und b auf verschiedene Objekte zeigen
+a == b
+
+// false, da a und b auf verschiedene Objekte zeigen
+a === b
+
+// true, da a und 'foo' verschiedene Typen sind und das Objekt (a)
+// vor dem Vergleich zum String 'foo' umgewandelt wird
+a == 'foo'
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial Definition. Implementiert in JavaScript 1.0
{{SpecName('ES3')}}{{Spec2('ES3')}}Fügt === und !== Operatoren hinzu. Implementiert in JavaScript 1.3
{{SpecName('ES5.1', '#sec-11.8')}}{{Spec2('ES5.1')}}In verschiedenen Kapiteln der Spezifikation definiert: Relational Operators, Equality Operators
{{SpecName('ES6', '#sec-relational-operators')}}{{Spec2('ES6')}}In verschiedenen Kapiteln der Spezifikation definiert: Relational Operators, Equality Operators
{{SpecName('ESDraft', '#sec-relational-operators')}}{{Spec2('ESDraft')}}In verschiedenen Kapiteln der Spezifikation definiert: Relational Operators, Equality Operators
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.operators.comparison")}}

+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/operators_8b4515dbed18a24ecb01bfe0755ca163/index.html b/files/de/conflicting/web/javascript/reference/operators_8b4515dbed18a24ecb01bfe0755ca163/index.html new file mode 100644 index 0000000000..6a20e85b79 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/operators_8b4515dbed18a24ecb01bfe0755ca163/index.html @@ -0,0 +1,247 @@ +--- +title: Logische Operatoren +slug: Web/JavaScript/Reference/Operators/Logische_Operatoren +tags: + - JavaScript + - Logic + - Logical Operators + - Not + - Operator + - Reference + - and + - or +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators +--- +
{{jsSidebar("Operators")}}
+ +

Logische Operatoren werden typischerweise im Zusammenhang mit {{jsxref("Boolean")}} (logischen) Werten verwendet. Die Operatoren && (Logisches UND) und || (Logisches ODER) geben dabei den Wert von einem der Operanden zurück. Sind die Operanden mit nicht-booleschen Werten belegt, geben diese Operatoren entsprechend nicht-boolesche Werte zurück.

+ +
{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}
+ + + +

Beschreibung

+ +

In der folgenden Tabelle werden die logischen Operatoren erläutert.

+ + + + + + + + + + + + + + + + + + + + + + + + +
OperatorVerwendungBeschreibung
Logisches UND (&&)ausdruck1 && ausdruck2Gibt ausdruck1 zurück, wenn er zu false konvertiert werden kann; anderfalls wird ausdruck2 zurückgegeben. Sind beide Operanden true, gibt && true zurück, Andernfalls false.
Logisches ODER (||)ausdruck1 || ausdruck2Gibt ausdruck1 zurück, wenn er zu true konvertiert werden kann; andernfalls wird ausdruck2 zurückgegeben. Ist einer der Operanden true, gibt || true zurück.
Logisches NICHT (!)!ausdruckGibt false zurück, wenn der Operand zu true konvertiert werden kann. Andernfalls wird true zurückgegeben.
+ +

Wenn ein Wert zu true konvertiert werden kann, wird er {{Glossary("truthy")}} genannt. Wenn ein Wert zu false konvertiert werden kann, wird er {{Glossary("falsy")}} genannt.

+ +

Beispiele für Ausdrücke, die zu false konvertiert werden können:

+ + + +

Auch wenn die Operatoren && und || mit nichtbooleschen Operanden verwendet werden können, gehören sie trotzdem zur Gruppe der logischen Operatoren, da ihre Rückgabewerte immer zu booleschen Werten konvertiert werden können.

+ +

Kurschlussauswertung (Short-Circuit Evaluation)

+ +

Logische Ausdrücke werden von links nach rechts ausgewertet und hierbei wird anhand der folgenden Regeln getestet, ob Kurzschlussauswertungen möglich sind:

+ + + +

Die Regeln der Logik garantieren, dass diese Auswertungen immer korrekt sind. Zu beachten ist, dass der irgendwas Teil nicht ausgewertet wird, so dass keine Seiteneffekte die von diesem Teil ausgehen ausgeführt werden. Zu beachten ist zudem, dass der irgendwas Teil ein einzelner Ausdruck ist (wie die Klammern anzeigen).

+ +

Beispielhaft betrachten wir die folgenden äquivalenten Funktionen:

+ +
function shortCircuitEvaluation() {
+  // Logisches ODER (||)
+  doSomething() || doSomethingElse();
+
+  // Logisches UND (&&)
+  doSomething() && doSomethingElse();
+}
+
+function equivalentEvaluation() {
+
+  // Logisches ODER (||)
+  var orFlag = doSomething();
+  if (!orFlag) {
+    doSomethingElse();
+  }
+
+  // Logisches UND (&&)
+  var andFlag = doSomething();
+  if (andFlag) {
+    doSomethingElse();
+  }
+}
+
+ +

Die folgenden Ausdrücke sind aufgrund der Operatorrangfolgen nicht äquivalent und betont, wie wichtig es ist, dass der rechte Operand ein einzelner Ausdruck ist (gruppiert, falls in Klammern erforderlich).

+ +
false &&  true || true      // wird zu true
+false && (true || true)     // wird zu false
+ +

Logisches UND (&&)

+ +

Im Folgenden sind Beispiele des && (logisches UND) Operators zu sehen.

+ +
a1 = true  && true      // t && t wird zu true
+a2 = true  && false     // t && f wird zu false
+a3 = false && true      // f && t wird zu false
+a4 = false && (3 == 4)  // f && f wird zu false
+a5 = 'Cat' && 'Dog'     // t && t wird zu "Dog"
+a6 = false && 'Cat'     // f && t wird zu false
+a7 = 'Cat' && false     // t && f wird zu false
+a8 = ''    && false     // f && f wird zu ""
+a9 = false && ''        // f && f wird zu false
+
+ +

Logisches ODER (||)

+ +

Im Folgenden sind Beispiele des || (logisches ODER) Operators zu sehen.

+ +
o1 = true  || true       // t || t wird zu true
+o2 = false || true       // f || t wird zu true
+o3 = true  || false      // t || f wird zu true
+o4 = false || (3 == 4)   // f || f wird zu false
+o5 = 'Cat' || 'Dog'      // t || t wird zu "Cat"
+o6 = false || 'Cat'      // f || t wird zu "Cat"
+o7 = 'Cat' || false      // t || f wird zu "Cat"
+o8 = ''    || false      // f || f wird zu false
+o9 = false || ''         // f || f wird zu ""
+
+ +

Logisches NICHT (!)

+ +

Im Folgenden sind Beispiele des ! (logisches NICHT) Operators zu sehen.

+ +
n1 = !true              // !t wird zu false
+n2 = !false             // !f wird zu true
+n3 = !"Cat"             // !t wird zu false
+
+ +

Konvertierungsregeln

+ +

Konvertierung von UND zu ODER

+ +

Die folgende Operation nutzt Booleane:

+ +
bCondition1 && bCondition2
+ +

ist äquivalent zum folgenden Ausdruck:

+ +
!(!bCondition1 || !bCondition2)
+ +

Konvertierung von ODER zu UND

+ +

Die folgende Operation nutzt Booleane:

+ +
bCondition1 || bCondition2
+ +

ist äquivalent zu folgendem Ausdruck:

+ +
!(!bCondition1 && !bCondition2)
+ +

Negierung des logischen NICHT

+ +

Die folgende Operation nutzt Booleane:

+ +
!!bCondition
+ +

ist äquivalent mit:

+ +
bCondition
+ +

Klammern in logischen Ausdrücken auflösen

+ +

Ein logischer Ausdruck wird von links nach rechts ausgewertet. Es ist immer möglich runde Klammern von einem komplexen Ausdruck zu entfernen, wenn einige Regeln beachtet werden.

+ +

Geschachteltes AND entfernen

+ +

Die folgende Operation nutzt Booleane:

+ +
bCondition1 || (bCondition2 && bCondition3)
+ +

ist äquivalent mit:

+ +
bCondition1 || bCondition2 && bCondition3
+ +

Geschachteltes OR entfernen

+ +

Die folgende Operation nutzt Booleane:

+ +
bCondition1 && (bCondition2 || bCondition3)
+ +

ist äquivalent mit:

+ +
!(!bCondition1 || !bCondition2 && !bCondition3)
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition.
{{SpecName('ES5.1', '#sec-11.11')}}{{Spec2('ES5.1')}}Definiert in mehreren Kapiteln der Spezifikation: Logical NOT Operator, Binary Logical Operators
{{SpecName('ES6', '#sec-binary-logical-operators')}}{{Spec2('ES6')}}Definiert in mehreren Kapiteln der Spezifikation: Logical NOT Operator, Binary Logical Operators
{{SpecName('ESDraft', '#sec-binary-logical-operators')}}{{Spec2('ESDraft')}}Definiert in mehreren Kapiteln der Spezifikation: Logical NOT Operator, Binary Logical Operators
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.operators.logical")}}

+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/operators_bf514126b51a6e9b7591809ecc554076/index.html b/files/de/conflicting/web/javascript/reference/operators_bf514126b51a6e9b7591809ecc554076/index.html new file mode 100644 index 0000000000..5df33bfe62 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/operators_bf514126b51a6e9b7591809ecc554076/index.html @@ -0,0 +1,413 @@ +--- +title: Zuweisungsoperator +slug: Web/JavaScript/Reference/Operators/Zuweisungsoperator +tags: + - JavaScript + - Operator +translation_of: Web/JavaScript/Reference/Operators#Assignment_operators +translation_of_original: Web/JavaScript/Reference/Operators/Assignment_Operators +--- +
{{jsSidebar("Operators")}}
+ +

Ein Zuweisungsoperator weist dem linken Operanten einen Wert auf Basis des rechten Operanten zu.

+ +
{{EmbedInteractiveExample("pages/js/expressions-assignment.html")}}
+ + + +

Überblick

+ +

Der Basiszuweisungsoperator ist das Gleich (=), welches den Wert des rechten Operanten dem linken Operanten zuweist. So wird bei x = y der Wert von y x zugewiesen. Die anderen Zuweisungsoperatoren sind Kurzformen für Standardoperationen, wie es in den folgenden Definition und Beispielen gezeigt wird.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameKurzformoperatorBedeutung
Zuweisungx = yx = y
Additionszuweisungx += yx = x + y
Subtraktionszuweisungx -= yx = x - y
Multiplikationszuweisungx *= yx = x * y
Divisionszuweisungx /= yx = x / y
Restzuweisungx %= yx = x % y
Potenzierungszuweisungx **= yx = x ** y
Links verschiebende Zuweisungx <<= yx = x << y
Rechts verschiebende Zuweisungx >>= yx = x >> y
Vorzeichenlose rechts verschiebende Zuweisungx >>>= yx = x >>> y
Bitweise AND Zuweisungx &= yx = x & y
Bitweise XOR Zuweisungx ^= yx = x ^ y
Bitweise OR Zuweisungx |= yx = x | y
+ +

Zuweisung

+ +

Einfacher Zuweisungsoperator, welcher den Wert zu einer Variablen zuweist. Der Zuweisungsoperator gibt den zugewiesenen Wert zurück. Eine Verkettung der Zuweisungsoperatoren ist möglich, um einen Wert mehreren Variablen zuzuweisen. Sie in den Beispielen.

+ +

Syntax

+ +
Operator: x = y
+
+ +

Beispiele

+ +
// Folgende Variablen sind vorausgesetzt
+//  x = 5
+//  y = 10
+//  z = 25
+
+x = y     // x ist 10
+x = y = z // x, y und z sind alle 25
+
+ +

Additionszuweisung

+ +

Der Additionszuweisungsoperator addiert den Wert des rechten Operanten zu einer Variablen und weist das Ergebnis der Variablen zu. Die Typen der Operanten entscheiden über das Verhalten des Additionszuweisungsoperator. Addition oder Konkatination sind möglich. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Additionsoperator", "#Addition", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x += y
+Bedeutung: x  = x + y
+
+ +

Beispiele

+ +
// Die folgenden Variablen werden vorausgesetzt
+//  foo = 'foo'
+//  bar = 5
+//  baz = true
+
+
+// Number + Number -> Addition
+bar += 2 // 7
+
+// Boolean + Number -> Addition
+baz += 1 // 2
+
+// Boolean + Boolean -> Addition
+baz += false // 1
+
+// Number + String -> Konkationation
+bar += 'foo' // "5foo"
+
+// String + Boolean -> Konkatination
+foo += false // "foofalse"
+
+// String + String -> Konkationation
+foo += 'bar' // "foobar"
+
+ +

Subtraktionszuweisung

+ +

Der Subtraktionszuweisungsoperator subtahiert den Wert des rechten Operanten von einer Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Subraktionsoperator", "#Subtraction", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x -= y
+Bedeutung: x  = x - y
+
+ +

Beispiele

+ +
// Die folgenden Variablen werden vorausgesetzt
+//  bar = 5
+
+bar -= 2     // 3
+bar -= 'foo' // NaN
+
+ +

Multiplikationszuweisung

+ +

Der Multiplikationszuweisungsoperator multipliziert den Wert des rechten Operanten zu einer Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Multiplikationsoperator", "#Multiplication", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x *= y
+Bedeutung: x  = x * y
+
+ +

Beispiele

+ +
// Die folgenden Variablen werden vorausgesetzt
+//  bar = 5
+
+bar *= 2     // 10
+bar *= 'foo' // NaN
+
+ +

Divisionszuweisung

+ +

Der Divisionszuweisungsoperator dividiert eine Variable durch den rechten Operanten zu und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Divisionsoperator", "#Division", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x /= y
+Bedeutung: x  = x / y
+
+ +

Beispiele

+ +
// Die folgenden Variablen werden vorausgesetzt
+//  bar = 5
+
+bar /= 2     // 2.5
+bar /= 'foo' // NaN
+bar /= 0     // Infinity
+
+ +

Restzuweisung

+ +

Der Restzuweisungsoperator dividiert einer Variable durch den rechten Operanten und weist den Rest des Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Restoperator", "#Remainder", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x %= y
+Bedeutung: x  = x % y
+
+ +

Beispiele

+ +
// Die folgenden Variablen werden vorausgesetzt
+//  bar = 5
+
+bar %= 2     // 1
+bar %= 'foo' // NaN
+bar %= 0     // NaN
+
+ +

Potenzierungszuweisung

+ +

Der Potenzierungszuweisungsoperator potenziert einer Variable mit den rechten Operanten und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Arithmetic_Operators", "Exponentialoperator", "#Exponentiation", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x **= y
+Bedeutung: x  = x ** y
+
+ +

Beispiele

+ +
// Die folgenden Variablen werden vorausgesetzt
+//  bar = 5
+
+bar **= 2     // 25
+bar **= 'foo' // NaN
+ + + +

Der links verschiebende Zuweisungsoperator verschiebt um die Anzahl Bits im rechten Operanten in der Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Bitwise_Operators", "links verschiebenden Operator", "#Left_shift", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x <<= y
+Bedeutung: x   = x << y
+
+ +

Beispiele

+ +
var bar = 5; //  (00000000000000000000000000000101)
+bar <<= 2; // 20 (00000000000000000000000000010100)
+
+ +

Rechts verschiebende Zuweisung

+ +

Der rechts verschiebende Zuweisungsoperator verschiebt um die Anzahl Bits im rechten Operanten in der Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Bitwise_Operators", "rechts verschiebenden Operator", "#Right_shift", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x >>= y
+Bedeutung: x   = x >> y
+
+ +

Beispiele

+ +
var bar = 5; //   (00000000000000000000000000000101)
+bar >>= 2;   // 1 (00000000000000000000000000000001)
+
+var bar -5; //    (-00000000000000000000000000000101)
+bar >>= 2;  // -2 (-00000000000000000000000000000010)
+
+ +

Vorzeichenlose rechts verschiebende Zuweisung

+ +

Der vorzeichenlose rechts verschiebende Zuweisungsoperator verschiebt um die Anzahl Bits im rechten Operanten in der Variablen und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Bitwise_Operators", "vorzeichenlose rechts verschiebenden Operator", "#Unsigned_right_shift", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x >>>= y
+Bedeutung: x    = x >>> y
+
+ +

Beispiele

+ +
var bar = 5; //   (00000000000000000000000000000101)
+bar >>>= 2;  // 1 (00000000000000000000000000000001)
+
+var bar = -5; // (-00000000000000000000000000000101)
+bar >>>= 2; // 1073741822 (00111111111111111111111111111110)
+ +

Bitweise UND Zuweisung

+ +

Der bitweise UND Zuweisungsoperator nutzt die Bitrepräsentation beider Operanten, führt eine bitweises UND Operation aus und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Bitwise_Operators", "bitweisen UND Operator", "#Bitwise_AND", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x &= y
+Bedeutung: x  = x & y
+
+ +

Beispiele

+ +
var bar = 5;
+// 5:     00000000000000000000000000000101
+// 2:     00000000000000000000000000000010
+bar &= 2; // 0
+
+ +

Bitweise XOR Zuweisung

+ +

Der bitweise XOR Zuweisungsoperator nutzt die Bitrepräsentation beider Operanten, führt eine bitweises XOR Operation aus und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Bitwise_Operators", "bitweisen XOR Operator", "#Bitwise_XOR", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x ^= y
+Bedeutung: x  = x ^ y
+
+ +

Beispiele

+ +
var bar = 5;
+bar ^= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+
+ +

Bitweise ODER Zuweisung

+ +

Der bitweise ODER Zuweisungsoperator nutzt die Bitrepräsentation beider Operanten, führt eine bitweises ODER Operation aus und weist das Ergebnis der Variablen zu. Siehe beim {{jsxref("Operators/Bitwise_Operators", "bitweisen ODER Operator", "#Bitwise_OR", 1)}} für mehr Details nach.

+ +

Syntax

+ +
Operator:  x |= y
+Bedeutung: x  = x | y
+
+ +

Beispiele

+ +
var bar = 5;
+bar |= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+
+ +

Beispiele

+ +

Linker Operant mit anderem Zuweisungsoperator

+ +

In ungewöhnlichen Situationen kann ein Zuweisungsoperator (z. B. x += y) nicht identisch mit der äquivalenten Zuweisung (hier x = x + y). Wenn der linke Operant einer Zuweisung selbst eine Zuweisung enthält, wird der linke Operant nur einem ausgewertet. Zum Beispiel:

+ +
a[i++] += 5         // i wird einmal ausgewertet
+a[i++] = a[i++] + 5 // i wird zweimal ausgewertet
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}{{Spec2('ESDraft')}} 
{{SpecName('ES2015', '#sec-assignment-operators', 'Assignment operators')}}{{Spec2('ES2015')}} 
{{SpecName('ES5.1', '#sec-11.13', 'Assignment operators')}}{{Spec2('ES5.1')}} 
{{SpecName('ES1', '#sec-11.13', 'Assignment operators')}}{{Spec2('ES1')}}Initiale Definition.
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.operators.assignment")}}

+ +

Siehe auch

+ + diff --git a/files/de/conflicting/web/javascript/reference/statements/switch/index.html b/files/de/conflicting/web/javascript/reference/statements/switch/index.html new file mode 100644 index 0000000000..f8845c9591 --- /dev/null +++ b/files/de/conflicting/web/javascript/reference/statements/switch/index.html @@ -0,0 +1,121 @@ +--- +title: default +slug: Web/JavaScript/Reference/Statements/default +tags: + - JavaScript + - Keyword +translation_of: Web/JavaScript/Reference/Statements/switch +translation_of_original: Web/JavaScript/Reference/Statements/default +--- +
{{jsSidebar("Statements")}}
+ +

Das default Schlüsselwort kann in JavaScript in zwei Situationen verwendet werden: Innerhalb eines {{jsxref("Statements/switch", "switch")}} Statements, oder mit einem {{jsxref("Statements/export", "export")}} Statement.

+ +
{{EmbedInteractiveExample("pages/js/statement-default.html")}}
+ + + +

Syntax

+ +

Innerhalb eines {{jsxref("Statements/switch", "switch")}} Statements:

+ +
switch (expression) {
+  case value1:
+    // Das Statement wird ausgeführt, wenn das Ergebnis der expression mit value1 übereinstimmt
+    [break;]
+  default:
+    // Das Statement wird ausgeführt, wenn keiner Werte mit dem Wert der expression übereinstimmt
+    [break;]
+}
+ +

Mit dem {{jsxref("Statements/export", "export")}} Statement:

+ +
export default nameN
+ +

Beschreibung

+ +

Für mehr Informationen, siehe die

+ + + +

Beispiele

+ +

Verwenden von default in switch Statements

+ +

Wenn im folgenden Beispiel expr den Wert "Oranges" oder "Apples" hat, wird das Programm die jeweiligen Werte abgleichen und das dazugehörige Statement ausführen. Das default Schlüsselwort hilft, alle übrigen (nicht speziell behandelten) Fälle zu behandeln.

+ +
switch (expr) {
+  case 'Oranges':
+    console.log('Oranges are $0.59 a pound.');
+    break;
+  case 'Apples':
+    console.log('Apples are $0.32 a pound.');
+    break;
+  default:
+    console.log('Sorry, we are out of ' + expr + '.');
+}
+ +

Verwenden von default mit export

+ +

Wenn Sie einen einzelnen Wert oder einen "fallback" Wert für ein Modul brauchen, können Sie einen default export verwenden:

+ +
// module "my-module.js"
+let cube = function cube(x) {
+  return x * x * x;
+}
+export default cube;
+ +

Dann kann der default export in einem anderen Skript direkt importiert werden:

+ +
// module "my-module.js"
+import myFunction from 'my-module';
+console.log(cube(3)); // 27
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}{{Spec2('ES6')}} 
{{SpecName('ES6', '#sec-exports', 'Exports')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}{{Spec2('ESDraft')}} 
{{SpecName('ESDraft', '#sec-exports', 'Exports')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.statements.default")}}

+ +

Siehe auch

+ + -- cgit v1.2.3-54-g00ecf