diff options
Diffstat (limited to 'files/de/web/javascript/reference/errors')
77 files changed, 5380 insertions, 0 deletions
diff --git a/files/de/web/javascript/reference/errors/already_has_pragma/index.html b/files/de/web/javascript/reference/errors/already_has_pragma/index.html new file mode 100644 index 0000000000..d297d3fea9 --- /dev/null +++ b/files/de/web/javascript/reference/errors/already_has_pragma/index.html @@ -0,0 +1,42 @@ +--- +title: 'Warning: -file- is being assigned a //# sourceMappingURL, but already has one' +slug: Web/JavaScript/Reference/Fehler/Already_has_pragma +tags: + - Error + - JavaScript + - Source maps + - Warning +translation_of: Web/JavaScript/Reference/Errors/Already_has_pragma +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: -file- is being assigned a //# sourceMappingURL, but already has one.</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>Warnung. Die Ausführung von JavaScript wird nicht unterbrochen.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Eine Source Map wurde mehrere Male für eine JavaScript Quelle spezifiziert.</p> + +<p>JavaScript Quellen sind oft kombiniert und minimiert, um diesen auf einem Server effizienter zu gestalten. Mit <a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">Source Maps</a> ist es möglich den Quelltext, beim Debuggen, zu den originalen Quelldateien zu verfolgen. Es gibt zwei Möglichkeiten Source Maps zuzuweisen, einerseits mit einem Kommentar und andererseits mit dem setzen eines Headers in der JavaScriptdatei.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Setzen einer Source Map mit einem Kommentar in einer Datei:</p> + +<pre class="brush: js example-good">//# sourceMappingURL=http://example.com/path/to/your/sourcemap.map</pre> + +<p>Oder alternativ mit dem setzen eines Headers in einer JavaScriptdatei:</p> + +<pre class="brush: js example-good">X-SourceMap: /path/to/file.js.map</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Tools/Debugger/How_to/Use_a_source_map">Use a source map – Firefox Tools Dokumentation</a></li> + <li><a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">Introduction to JavaScript Source Maps – HTML5 rocks</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/array_sort_argument/index.html b/files/de/web/javascript/reference/errors/array_sort_argument/index.html new file mode 100644 index 0000000000..2826cbe4c0 --- /dev/null +++ b/files/de/web/javascript/reference/errors/array_sort_argument/index.html @@ -0,0 +1,47 @@ +--- +title: 'TypeError: invalid Array.prototype.sort argument' +slug: Web/JavaScript/Reference/Fehler/Array_sort_argument +tags: + - Error + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Array_sort_argument +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: invalid Array.prototype.sort argument (Firefox) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Das Argument von {{jsxref("Array.prototype.sort()")}} erwartet entweder {{jsxref("undefined")}} oder eine Funktion, welche die Operanden vergleicht.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_valide_Fälle">Nicht valide Fälle</h3> + +<pre class="brush: js example-bad">[1, 3, 2].sort(5); // TypeError + +var cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y }; +[1, 3, 2].sort(cmp[this.key] || 'asc'); // TypeError +</pre> + +<h3 id="Valide_Fälle">Valide Fälle</h3> + +<pre class="brush: js example-good">[1, 3, 2].sort(); // [1, 2, 3] + + +var cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y }; +[1, 3, 2].sort(cmp[this.key || 'asc']); // [1, 2, 3]</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.sort()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/bad_octal/index.html b/files/de/web/javascript/reference/errors/bad_octal/index.html new file mode 100644 index 0000000000..d021c0daa4 --- /dev/null +++ b/files/de/web/javascript/reference/errors/bad_octal/index.html @@ -0,0 +1,54 @@ +--- +title: 'Warning: 08/09 is not a legal ECMA-262 octal constant' +slug: Web/JavaScript/Reference/Fehler/Bad_octal +tags: + - Errors + - JavaScript + - SyntaxError + - Warning +translation_of: Web/JavaScript/Reference/Errors/Bad_octal +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: SyntaxError: 08 is not a legal ECMA-262 octal constant. +Warning: SyntaxError: 09 is not a legal ECMA-262 octal constant. +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>Warnung. Die Ausführung von JavaScript wird nicht gestoppt.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Dezimalliterale können mit einer Null (<code>0</code>) beginnen, gefolgt von anderen Dezimalziffern. en alle Ziffern nach der führenden <code>0</code> kleiner als 8 sind, wird die Zal als Oktalzahl interpretiert. Weil das nicht der Fall ist mit <code>08</code> und <code>09</code>, warnt JavaScript.</p> + +<p>Zu beachten ist, dass Oktalliterale und oktal maskierte Sequenzen veraltet sind und eine zusätzliche Veraltungswarnung enthalten. Mit ECMAScript 6 und später wird diese Syntak mit einer führenden Null gefolgt von einem großen oder kleinen lateinischen Buschstaben "O" (<code>0o</code> or <code>0O)</code> benutzt. Sie dazu die Seite <a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar#Octal">lexical grammar</a> für mehr Informationen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ungültige_Oktalzahlen">Ungültige Oktalzahlen</h3> + +<pre class="brush: js example-bad">08; +09; +// SyntaxError: 08 is not a legal ECMA-262 octal constant +// SyntaxError: "0"-prefixed octal literals and octal escape sequences +// are deprecated</pre> + +<h3 id="Gültige_Oktalzahlen">Gültige Oktalzahlen</h3> + +<p>Einsatz von einer führenden Null gefolgt von dem Buchstaben "o";</p> + +<pre class="brush: js example-good">0O755; +0o644; +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar#Octal">Lexical grammar</a></li> + <li> + <p><a href="/de/docs/Web/JavaScript/Reference/Errors/Deprecated_octal">SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated</a></p> + </li> +</ul> diff --git a/files/de/web/javascript/reference/errors/bad_radix/index.html b/files/de/web/javascript/reference/errors/bad_radix/index.html new file mode 100644 index 0000000000..25c473eb93 --- /dev/null +++ b/files/de/web/javascript/reference/errors/bad_radix/index.html @@ -0,0 +1,61 @@ +--- +title: 'RangeError: radix must be an integer' +slug: Web/JavaScript/Reference/Fehler/Bad_radix +tags: + - Errors + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Bad_radix +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">RangeError: radix must be an integer at least 2 and no greater than 36 (Firefox) +RangeError: toString() radix argument must be between 2 and 36 (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der optionale <code>radix</code> Parameter der {{jsxref("Number.prototype.toString()")}} Methode wurde spezifiziert. Dieser Wert muss eine ganze Zahl zwischen 2 und 36 sein, welche die Basis des Zahlensystems des repräsentierten Zahlwertes angibt. Zum Beispiel wird die Dezimalzahl (Basis 10) 169 im Hexadezimalsystem (Basis 16) als A9 repräsentiert.</p> + +<p>Warum ist der Parameterwert auf 36 limitiert? Eine Basis größer als 10 nutzt als Ziffern Buchstaben; deswegen kann der Parameter nicht größer als 36 sein, weil das Lateinische Alphabet (welches im Englischen und vielen anderen Sprachen verwendet wird) nur 26 Buchstaben hat.</p> + +<p>Die am meisten eingesetzten Basen sind:</p> + +<ul> + <li>2 für <a href="https://de.wikipedia.org/wiki/Dualsystem">Binärzahlen</a></li> + <li>8 für <a href="https://de.wikipedia.org/wiki/Oktalsystem">Oktalzahlen</a>,</li> + <li>10 für <a href="https://de.wikipedia.org/wiki/Dezimalsystem">Dezimalzahlen</a>,</li> + <li>16 für <a href="https://de.wikipedia.org/wiki/Hexadezimalsystem">Hexadezimalzahlen</a>.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_valide_Fälle">Nicht valide Fälle</h3> + +<pre class="brush: js example-bad">(42).toString(0); +(42).toString(1); +(42).toString(37); +(42).toString(150); +// You cannot use a string like this for formatting: +(12071989).toString('MM-dd-yyyy'); +</pre> + +<h3 id="Valide_Fälle">Valide Fälle</h3> + +<pre class="brush: js example-good">(42).toString(2); // "101010" (binary) +(13).toString(8); // "15" (octal) +(0x42).toString(10); // "66" (decimal) +(100000).toString(16) // "186a0" (hexadecimal) +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/bad_regexp_flag/index.html b/files/de/web/javascript/reference/errors/bad_regexp_flag/index.html new file mode 100644 index 0000000000..5bf381da53 --- /dev/null +++ b/files/de/web/javascript/reference/errors/bad_regexp_flag/index.html @@ -0,0 +1,105 @@ +--- +title: 'SyntaxError: invalid regular expression flag "x"' +slug: Web/JavaScript/Reference/Fehler/Bad_regexp_flag +tags: + - Error + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Bad_regexp_flag +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: invalid regular expression flag "x" (Firefox) +SyntaxError: Invalid regular expression flags (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt nicht valide Flags in regulären Ausdrücken im Code. In einem regulärem Ausdrucksliteral, welches aus eine Muster umschlossen von Schrägstrichen ist, kommen die Flags nach dem zweiten Schrägstrich. Sie können auch in der Konstruktorfunktion des {{jsxref("RegExp")}} Objektes angegeben werden (zweiter Parameter). Flags für reguläre Ausdrücke können einfach oder zusammen in beliebiger Reihenfolge benutzt werden, jedoch gibt es in ECMAScript nur fünf.</p> + +<p>Um ein Flag in regulären Ausdrücken einzufügen kann folgende Syntax benutzt werden:</p> + +<pre class="brush: js">var re = /pattern/flags; +</pre> + +<p>oder</p> + +<pre class="brush: js">var re = new RegExp('pattern', 'flags');</pre> + +<table class="standard-table"> + <caption>Flags von regulären Ausdrücken</caption> + <thead> + <tr> + <th scope="col">Flag</th> + <th scope="col">Beschreibung</th> + </tr> + </thead> + <tbody> + <tr> + <td>g</td> + <td>Globale Suche.</td> + </tr> + <tr> + <td>i</td> + <td>Groß- und Kleinschreibung nicht unterscheiden.</td> + </tr> + <tr> + <td>m</td> + <td>Suche über mehrere Zeilen.</td> + </tr> + <tr> + <td>u</td> + <td>Unicode; nimmt das Muster als eine Sequenz von Unicode Codepoints an.</td> + </tr> + <tr> + <td>y</td> + <td>Führt eine "sticky" Suche durch, welche zutrifft, wenn der String von der Startposition aus auf das Muster zutrifft. Siehe {{jsxref("RegExp.sticky", "sticky")}}.</td> + </tr> + </tbody> +</table> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Es gibt nur fünf valide Flags für reguläre Ausdrücke.</p> + +<pre class="brush: js example-bad">/foo/bar; + +// SyntaxError: invalid regular expression flag "b" +</pre> + +<p>Ist eine regulärer Ausdruck gewollt? Ein Ausdruck, der zwei Schrägstriche enthält wird als Literal für reguläre Ausdrücke interpretiert.</p> + +<pre class="brush: js example-bad">let obj = { + url: /docs/Web +}; + +// SyntaxError: invalid regular expression flag "W" +</pre> + +<p>Oder war stattdessen ein String gemeint? Füge einfache oder doppelte Anführungszeichen hinzu, um ein Stringliteral zu erstellen.</p> + +<pre class="brush: js example-good">let obj = { + url: '/docs/Web' +};</pre> + +<h3 id="Valide_Flags_für_reguläre_Ausdrücke">Valide Flags für reguläre Ausdrücke</h3> + +<p>Siehe in der Tabelle oben für die fünf in JavaScript erlaubten validen Flags für reguläre Ausdrücke</p> + +<pre class="brush: js example-good">/foo/g; +/foo/gim; +/foo/uy; +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Guide/Regular_Expressions">Reguläre Ausdrücke</a></li> + <li><a href="http://xregexp.com/flags/">XRegEx Flags</a> – Bibliothek für reguläre Ausdrücke, die vier weitere Flags unterstützt (<code>n</code>, <code>s</code>, <code>x</code>, <code>A</code>)</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/bad_return_or_yield/index.html b/files/de/web/javascript/reference/errors/bad_return_or_yield/index.html new file mode 100644 index 0000000000..e850455615 --- /dev/null +++ b/files/de/web/javascript/reference/errors/bad_return_or_yield/index.html @@ -0,0 +1,55 @@ +--- +title: 'SyntaxError: return not in function' +slug: Web/JavaScript/Reference/Fehler/Bad_return_or_yield +tags: + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Bad_return_or_yield +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: return not in function +SyntaxError: yield not in function +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Ein <code><a href="/de/docs/Web/JavaScript/Reference/Statements/return">return</a></code> oder <code><a href="/de/docs/Web/JavaScript/Reference/Operators/yield">yield</a></code> Statement wird außerhalb einer <a href="/de/docs/Web/JavaScript/Guide/Functions">Funktion</a> aufgerufen. Es kann sein, dass geschweifte Klammern fehlen. Die Statements <code>return</code> und <code>yield</code> müssen in einer Funktion sein, weil sie die Ausführung der Funktion beenden (oder pausieren und wieder starten) und dem Funktionsaufrufer einen spezifizierten Wert zurückgeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js example-bad">var cheer = function(score) { + if (score === 147) + return 'Maximum!'; + }; + if (score > 100) { + return 'Century!'; + } +} + +// SyntaxError: return not in function</pre> + +<p>Die geschweiften Klammern sehen auf den ersten Blick richtig aus, jedoch fehlt in dem Code eine <code>{</code> nach dem ersten <code>if</code> Statement. Korrekt währe es wir folgt:</p> + +<pre class="brush: js example-good">var cheer = function(score) { + if (score === 147) { + return 'Maximum!'; + } + if (score > 100) { + return 'Century!'; + } +};</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/return">return</a></code></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Operators/yield">yield</a></code></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/called_on_incompatible_type/index.html b/files/de/web/javascript/reference/errors/called_on_incompatible_type/index.html new file mode 100644 index 0000000000..1915e1b829 --- /dev/null +++ b/files/de/web/javascript/reference/errors/called_on_incompatible_type/index.html @@ -0,0 +1,64 @@ +--- +title: X.prototype.y called on incompatible type +slug: Web/JavaScript/Reference/Fehler/Called_on_incompatible_type +tags: + - Error + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Called_on_incompatible_type +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: Function.prototype.toString called on incompatible object (Firefox) +TypeError: Function.prototype.bind called on incompatible target (Firefox) +TypeError: Method Set.prototype.add called on incompatible receiver undefined (Chrome) +TypeError: Bind must be called on a function (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Wenn dieser Fehler auftritt, wird eine Funktion (auf eineem gegebenen Objekt) aufgerufen, wobei <code>this</code> nicht vom erwarteten Typ ist.</p> + +<p>Dieser Fehler kann auftreten, wenn die {{jsxref("Function.prototype.call()")}} oder {{jsxref("Function.prototype.apply()")}} Methode mit einem <code>this</code> Argument genutzt werden, welches nicht dem erwarteten Typ entspricht.</p> + +<p>Dieser Fehler kann auch auftreten, wenn eine Funktion (in einem Objekt gespeichert) als Argument in einer anderen Funktion genutzt wird. In diesem Fall ist das Objekt nicht <code>this</code> der Funktion. Um diesen Dall zu umgehen muss eine Lambda-Funktion unterstützt werden, welche den Aufruf markiert, oder die {{jsxref("Function.prototype.bind()")}} Funktion eingesetzt werden, um das richtige <code>this</code> Objekt zu nutzen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Fehlerfälle">Fehlerfälle</h3> + +<pre class="brush: js example-bad">var mySet = new Set; +['bar', 'baz'].forEach(mySet.add); +// mySet.add ist eine Funktion, aber "mySet" wird so nicht erfasst. + +var myFun = function () {}; +['bar', 'baz'].forEach(myFun.bind); +// myFun.bind ist eine Funktion, aber "myFun" wird nicht so erfasst. + +</pre> + +<h3 id="Gültiger_Fälle">Gültiger Fälle</h3> + +<pre class="brush: js example-good">var mySet = new Set; +['bar', 'baz'].forEach(mySet.add.bind(mySet)); +// Das funktioniert, weil "mySet" als this an die Funktion gebunden wird. + +var myFun = function () {}; +['bar', 'baz'].forEach(x => myFun.bind(x)); +// Das funktioniert durch die "bind" Funktion. Es wird eine Lambda-Funktion erstellt, die die Argumente weiterleitet.. + +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Function.prototype.apply()")}}</li> + <li>{{jsxref("Function.prototype.bind()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html b/files/de/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html new file mode 100644 index 0000000000..16b976aef6 --- /dev/null +++ b/files/de/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html @@ -0,0 +1,60 @@ +--- +title: 'ReferenceError: can''t access lexical declaration`X'' before initialization' +slug: Web/JavaScript/Reference/Fehler/Cant_access_lexical_declaration_before_init +tags: + - Errors + - JavaScript + - ReferenceError +translation_of: Web/JavaScript/Reference/Errors/Cant_access_lexical_declaration_before_init +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">ReferenceError: can't access lexical declaration `X' before initialization (Firefox) +ReferenceError: 'x' is not defined (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("ReferenceError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Auf eine lexikalische Variable wurde zugegriffen bevor sie deklariert wurde. Das passiert in Blockstatements, in denen auf <code><a href="/de/docs/Web/JavaScript/Reference/Statements/let">let</a></code> oder <code><a href="/de/docs/Web/JavaScript/Reference/Statements/const">const</a></code> Variablen zugegriffen wird, bevor sie definiert wurden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Falsche_Fälle">Falsche Fälle</h3> + +<p>In diesem Fall wird die Variable "foo" in einem Blockstatement mit <code>let</code> neu deklariert.</p> + +<pre class="brush: js example-bad">function test() { + let foo = 33; + if (true) { + let foo = (foo + 55); + // ReferenceError: can't access lexical + // declaration `foo' before initialization + } +} +test(); +</pre> + +<h3 id="Richtige_Fälle">Richtige Fälle</h3> + +<p>Um "foo" im if-Statement zu ändern, muss <code>let</code> entfernt werden, welche die Neudeklaration verursacht.</p> + +<pre class="brush: js example-good">function test(){ + let foo = 33; + if (true) { + foo = (foo + 55); + } +} +test(); +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Statements/let#Zeitweilig_tote_Zonen_und_Fehler_mit_let">Temporal Dead Zone and errors with let</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/cant_access_property/index.html b/files/de/web/javascript/reference/errors/cant_access_property/index.html new file mode 100644 index 0000000000..98471eb28e --- /dev/null +++ b/files/de/web/javascript/reference/errors/cant_access_property/index.html @@ -0,0 +1,59 @@ +--- +title: 'TypeError: can''t access property "x" of "y"' +slug: Web/JavaScript/Reference/Fehler/Cant_access_property +tags: + - Fehler + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Cant_access_property +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: Unable to get property {x} of undefined or null reference (Edge) +TypeError: can't access property {x} of {y} (Firefox) +TypeError: {y} is undefined, can't access property {x} of it (Firefox) +TypeError: {y} is null, can't access property {x} of it (Firefox) + +Beispiele: +TypeError: x is undefined, can't access property "prop" of it +TypeError: x is null, can't access property "prop" of it +TypeError: can't access property "prop" of undefined +TypeError: can't access property "prop" of null +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>The Attributzugriff erfolgte über einen {{jsxref("undefined")}} oder {{jsxref("null")}} Wert</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Invalide_Fälle">Invalide Fälle</h3> + +<pre class="brush: js example-bad">// undefined und null sind Fälle auf denen die Methode substring nicht aufgerufen werden kann +var foo = undefined; +foo.substring(1); // TypeError: x is undefined, can't access property "substring" of it + +var foo = null; +foo.substring(1); // TypeError: x is null, can't access property "substring" of it +</pre> + +<h3 id="Fehlerbehebung">Fehlerbehebung</h3> + +<p>Um den null pointer auf <code>undefined</code> oder <code>null</code> Werte zu beheben, kann beispielsweise der <a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a> Operator verwendet werden.</p> + +<pre class="brush: js">if (typeof foo !== 'undefined') { + // Hier wissen wir, dass foo definiert ist +}</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("undefined")}}</li> + <li>{{jsxref("null")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.html b/files/de/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.html new file mode 100644 index 0000000000..691924f427 --- /dev/null +++ b/files/de/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.html @@ -0,0 +1,64 @@ +--- +title: 'TypeError: can''t define property "x": "obj" is not extensible' +slug: Web/JavaScript/Reference/Fehler/Cant_define_property_object_not_extensible +tags: + - Error + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Cant_define_property_object_not_extensible +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: can't define property "x": "obj" is not extensible (Firefox) +TypeError: Cannot define property: "x", object is not extensible. (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Normalerweise ist ein Objekt erweiterbar und neue Eigenschaften können hinzugefügt werden. In diesem Fall markiert {{jsxref("Object.preventExtensions()")}} ein Objekt als nicht mehr erweiterbar, so dass ein Objekt nur noch die Eigenschaften haben kann, die es vor dem Aufruf hatte.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> wird ein <code>TypeError</code> erzeugt, wenn versucht wird eine Eigenschaft zu einem nicht erweiterbaren Objekt hinzuzufügen. Im normalen Modus wird das Hinzufügen einfach ignoriert.</p> + +<pre class="brush: js example-bad">'use strict'; + +var obj = {}; +Object.preventExtensions(obj); + +obj.x = 'foo'; +// TypeError: can't define property "x": "obj" is not extensible +</pre> + +<p>Im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> und normalen Modus wird ein Fehler erzeugt, wenn {{jsxref("Object.defineProperty()")}} benutzt wird, um eine Eigenschaft zu einem nicht erweiterbaren Objekt hinzuzufügen.</p> + +<pre class="brush: js example-bad">var obj = { }; +Object.preventExtensions(obj); + +Object.defineProperty(obj, + 'x', { value: "foo" } +); +// TypeError: can't define property "x": "obj" is not extensible +</pre> + +<p>Um diesen Fehler zu vermeiden muss entweder der Aufruf von {{jsxref("Object.preventExtensions()")}} entfernt werden oder die Position des Aufrufes so verschoben werden, dass das Hinzufügen von Eigenschaften davor passiert und das Objekt erst danach als nicht erweiterbar markiert wird. Natürlich kann auch die neue Eigenschaft entfernt werden, wenn sie nicht benötigt wird.</p> + +<pre class="brush: js example-good">'use strict'; + +var obj = {}; +obj.x = 'foo'; // add property first and only then prevent extensions + +Object.preventExtensions(obj);</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.preventExtensions()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/cant_delete/index.html b/files/de/web/javascript/reference/errors/cant_delete/index.html new file mode 100644 index 0000000000..fe09735071 --- /dev/null +++ b/files/de/web/javascript/reference/errors/cant_delete/index.html @@ -0,0 +1,58 @@ +--- +title: 'TypeError: property "x" is non-configurable and can''t be deleted' +slug: Web/JavaScript/Reference/Fehler/Cant_delete +tags: + - Errors + - JavaScript + - Strict Mode + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Cant_delete +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: property "x" is non-configurable and can't be deleted. (Firefox) +TypeError: Cannot delete property 'x' of #<Object> (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}} nur im strict mode.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es wurde versucht eine EIgenschaft zu löschen, obwohl die Eigenschaft nicht Konfigurierbar (<a href="/de/docs/Web/JavaScript/Data_structures#Properties">non-configurable</a>) ist. Das <code>configurable</code> Attribut gibt an, ob ein Eigenschaft von einem Objekt gelöscht werden kann und ob ein Attribut (anders als <code>writable</code>) geändert werden kann.</p> + +<p>Dieser Fehler ist nur tritt nur im <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> auf. In non-strict Quelltext, gibt die Operation <code>false</code> zurück.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Nicht Konfigurierbare Eigenschaften sind nicht sehr häufig, aber sie können mit {{jsxref("Object.defineProperty()")}} oder {{jsxref("Object.freeze()")}} erstellt werden.</p> + +<pre class="brush: js example-bad">'use strict'; +var obj = Object.freeze({name: 'Elsa', score: 157}); +delete obj.score; // TypeError + +'use strict'; +var obj = {}; +Object.defineProperty(obj, 'foo', {value: 2, configurable: false}); +delete obj.foo; // TypeError + +'use strict'; +var frozenArray = Object.freeze([0, 1, 2]); +frozenArray.pop(); // TypeError +</pre> + +<p>Es gibt auch einige nicht Konfigurierbare Eigenschaften, die in JavaScript eingebaut sind. Dazu zählen zum Beispiel die mathematischen Konstanten.</p> + +<pre class="brush: js example-bad">'use strict'; +delete Math.PI; // TypeError</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/delete">delete operator</a></li> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.freeze()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/cant_redefine_property/index.html b/files/de/web/javascript/reference/errors/cant_redefine_property/index.html new file mode 100644 index 0000000000..80ef1e384b --- /dev/null +++ b/files/de/web/javascript/reference/errors/cant_redefine_property/index.html @@ -0,0 +1,51 @@ +--- +title: 'TypeError: can''t redefine non-configurable property "x"' +slug: Web/JavaScript/Reference/Fehler/Cant_redefine_property +tags: + - Error + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Cant_redefine_property +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: can't redefine non-configurable property "x" (Firefox) +TypeError: Cannot redefine property: "x" (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es wurde versucht eine Eigenschaft erneut zu definieren, aber die Eigenschaft ist nicht konfigurierbar (<a href="/de/docs/Web/JavaScript/Data_structures#Properties">non-configurable</a>). Das <code>configurable</code> Attribut kontrolliert, ob eine Eigenschaft von einem Objekt gelöscht werden kann und seine Attribute (anders als <code>writable</code>) geändert werden können. Eigenschaften von einem Objekt, dass von einem <a href="/de/docs/Web/JavaScript/Reference/Operators/Object_initializer">Objekt-Initialisierer</a> erstellt wurden, sind konfigurierbar. Immer, wenn zum Beispiel {{jsxref("Object.defineProperty()")}} eingesetzt wird, ist die Eigenschaft nicht ohne weiteres konfigurierbar.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_konfigurierbare_Eigenschaften_mit_Object.defineProperty_erstellen">Nicht konfigurierbare Eigenschaften mit <code>Object.defineProperty</code> erstellen</h3> + +<p>Die {{jsxref("Object.defineProperty()")}} Funktion erstellt nicht konfiguriertbare Eigenschaften wenn sie nicht extra als konfigurierbar spezifiziert sind.</p> + +<pre class="brush: js example-bad">var obj = Object.create({}); +Object.defineProperty(obj, "foo", {value: "bar"}); + +Object.defineProperty(obj, "foo", {value: "baz"}); +// TypeError: can't redefine non-configurable property "foo" +</pre> + +<p>Die "foo" Eigenschaft muss als Konfigurierbar eingestellt werden, wenn diese später im Quelltext erneut definiert bzw. überschrieben werden soll.</p> + +<pre class="brush: js example-good">var obj = Object.create({}); +Object.defineProperty(obj, "foo", {value: "bar", configurable: true}); +Object.defineProperty(obj, "foo", {value: "baz", configurable: true});</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Data_structures#Properties">[[Configurable]]</a></li> + <li>{{jsxref("Object.defineProperty()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/cyclic_object_value/index.html b/files/de/web/javascript/reference/errors/cyclic_object_value/index.html new file mode 100644 index 0000000000..33bf4d508a --- /dev/null +++ b/files/de/web/javascript/reference/errors/cyclic_object_value/index.html @@ -0,0 +1,67 @@ +--- +title: 'TypeError: cyclic object value' +slug: Web/JavaScript/Reference/Fehler/Cyclic_object_value +tags: + - Error + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Cyclic_object_value +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: cyclic object value (Firefox) +TypeError: Converting circular structure to JSON (Chrome and Opera) +TypeError: Circular reference in value argument not supported (Microsoft Edge) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Wenn {{jsxref("JSON.stringify()")}} aufgerufen wird, kann eine zyklische Objektreferenzstruktur nicht zu eine String konvertiert werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>In eine zyklischen Struktur wie folgender</p> + +<pre class="brush: js">var <code class="language-js">circularReference</code> = {otherData: 123}; +<code class="language-js">circularReference</code>.myself = <code class="language-js">circularReference</code>; +</pre> + +<p>wird {{jsxref("JSON.stringify()")}} nicht funktionieren</p> + +<pre class="brush: js example-bad">JSON.stringify(a); +// TypeError: cyclic object value +</pre> + +<p>Um zyklische Referenzen zu serialisieren, kann man eine Bibliotheken benutzen (z. B. <a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a> von Douglas Crockford) oder eine eigene Lösung implementieren, welche zyklische Referenzen findet und mit serialisierbaren Werten ersetzt (oder diese entfernt).</p> + +<p>Das folgende Codebeispiel zeigt, wie man eine zyklische Referenz mit dem Einsatz des <code>replacer</code> Parameters von {{jsxref("JSON.stringify()")}} findet und filtert (das bedeutet, es gehen Daten verloren):</p> + +<pre class="brush: js">const getCircularReplacer = () => { + const seen = new WeakSet; + return (key, value) => { + if (typeof value === "object" && value !== null) { + if (seen.has(value)) { + return; + } + seen.add(value); + } + return value; + }; +}; + +JSON.stringify(<code class="language-js">circularReference</code>, getCircularReplacer()); +// {"otherData":123}</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("JSON.stringify")}}</li> + <li><a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a> – Führt zwei Funktionen ein, <code>JSON.decycle</code> und <code>JSON.retrocycle</code>, welche es ermöglichen zyklische Strukturen aufzulösen, diese in JSON unterzubringen und sie wieder zu erstellen.</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/dead_object/index.html b/files/de/web/javascript/reference/errors/dead_object/index.html new file mode 100644 index 0000000000..036e637ef4 --- /dev/null +++ b/files/de/web/javascript/reference/errors/dead_object/index.html @@ -0,0 +1,50 @@ +--- +title: 'TypeError: can''t access dead object' +slug: Web/JavaScript/Reference/Fehler/Dead_object +tags: + - Addon + - Error + - Errors + - JavaScript +translation_of: Web/JavaScript/Reference/Errors/Dead_object +--- +<div>{{JSSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: can't access dead object +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Um die Speichernutzung zu verbessern und Speicherlücken zu vermeiden, verbietet Firefox Add-Ons Referenzen in das DOM Objekt zu speichern, nachdem das Elterndokument zerstört wurde. Ein totes Objekt hält eine starke Referenz zu einem DOM-Element, welche nach nach dem Zerstören in DOM existiert. Um dieses Problem zu vermeiden, sollte statt der Referenz zu einem DOM-Knoten im fremden Dokument die Referenz in einem Objekt, welches im Dokument selbst spezifiziert ist gespeichert werden und gesäubert werden, wenn das Dokument nicht mehr geladen ist, oder als <a href="/de/docs/Mozilla/Tech/XPCOM/Language_Bindings/Components.utils.getWeakReference">weak Referenz</a> gespeichert werden.</p> + +<h2 id="Prüfen_ob_ein_Objekt_tot_ist">Prüfen, ob ein Objekt tot ist</h2> + +<p><a href="/de/docs/Mozilla/Tech/XPCOM/Language_Bindings/Components.utils">Components.utils</a> hat ein <code>isDeadWrapper()</code> Methode, welche in privilegiertem Quelltext verwendet werden sollte.</p> + +<pre class="brush: js">if (Components.utils.isDeadWrapper(window)) { + // dead +}</pre> + +<p>Nicht privilegierter Quelltext hat keinen Zugriff auf Component.utils und sollt deswegen einfach den Fehler abfangen.</p> + +<pre class="brush: js">try { + String(window); +} +catch (e) { + console.log("window is likely dead"); +}</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="https://blog.mozilla.org/addons/2012/09/12/what-does-cant-access-dead-object-mean/">What does “can’t access dead object” mean?</a></li> + <li><a href="/de/docs/Extensions/Common_causes_of_memory_leaks_in_extensions">Häufige Gründe für Speicherlöcher in Erweiterungen</a></li> + <li><a href="/de/docs/Mozilla/Tech/XPCOM/Language_Bindings/Components.utils">Components.utils</a></li> + <li><a href="/en-US/docs/Mozilla/Zombie_compartments">Zombie Abteilungen</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/delete_in_strict_mode/index.html b/files/de/web/javascript/reference/errors/delete_in_strict_mode/index.html new file mode 100644 index 0000000000..042505e066 --- /dev/null +++ b/files/de/web/javascript/reference/errors/delete_in_strict_mode/index.html @@ -0,0 +1,70 @@ +--- +title: >- + SyntaxError: applying the 'delete' operator to an unqualified name is + deprecated +slug: Web/JavaScript/Reference/Fehler/Delete_in_strict_mode +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Delete_in_strict_mode +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox) +SyntaxError: Delete of an unqualified identifier in strict mode. (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}} nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a>.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Normale Variablen können in JavaScript nicht mit dem <code><a href="/de/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code> Operator gelöscht werden. Im Strict Mode führt der Versuch des Löschens zu einem Fehler, weil es nicht erlaubt ist.</p> + +<p>Der <code>delete</code> Operator kann nur Eigenschaften eines Objektes löschen. Objekteigenschaften müssen dafür Konfigurierbar sein.</p> + +<p>Wie oft fälschlicherweise angenommen, hat die <code>delete</code> Operation <strong>nichts</strong> mit dem direkten freimachen von Speicher zu tun. Speicherverwaltung wird indirekt gemacht, mehr Informationen darüber auf den Seiten <a href="/de/docs/Web/JavaScript/Memory_Management">Speicherverwaltung</a> und <code><a href="/de/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code>.</p> + +<p>Der Fehler tritt nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a> auf. In normalem Code gibt die Operation einfach <code>false</code> zurück.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Der Versuch eine einfache Variable zu Löschen funktioniert in JavaScript nicht unf führt im Strict Mode zu einem Fehler:</p> + +<pre class="brush: js example-bad">'use strict'; + +var x; + +// ... + +delete x; + +// SyntaxError: applying the 'delete' operator to an unqualified name +// is deprecated +</pre> + +<p>Um den Inhalt einer Variable zu leeren, kann man sie auf {{jsxref("null")}} setzen:</p> + +<pre class="brush: js example-good">'use strict'; + +var x; + +// ... + +x = null; + +// x can be garbage collected +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code></li> + <li><a href="/de/docs/Web/JavaScript/Memory_Management">Speicherverwaltung</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Errors/Cant_delete">TypeError: property "x" is non-configurable and can't be deleted</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.html b/files/de/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.html new file mode 100644 index 0000000000..15bb0e68b6 --- /dev/null +++ b/files/de/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.html @@ -0,0 +1,75 @@ +--- +title: 'ReferenceError: deprecated caller or arguments usage' +slug: Web/JavaScript/Reference/Fehler/Deprecated_caller_or_arguments_usage +tags: + - Errors + - JavaScript + - Strict Mode + - Warning +translation_of: Web/JavaScript/Reference/Errors/Deprecated_caller_or_arguments_usage +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: ReferenceError: deprecated caller usage (Firefox) +Warning: ReferenceError: deprecated arguments usage (Firefox) +TypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>Eine {{jsxref("ReferenceError")}} Warnung, die nur im Strict Mode auftaucht. Die JavaScript-Ausführung wird dadurch nicht angehalten.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a> wurden die Eigenschaften {{jsxref("Function.caller")}} oder {{jsxref("Function.arguments")}} benutzt, was nicht getan werden sollte. Sie sind veraltet, da sie den Funktionsaufruf verlieren, nicht standardisiert sind, schwer zu optimieren sind und möglicherweise leistungsschädigend sein können.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Veraltete_function.caller_oder_arguments.callee.caller_Eigenschaft">Veraltete <code>function.caller</code> oder <code>arguments.callee.caller</code> Eigenschaft</h3> + +<p>{{jsxref("Function.caller")}} und <code><a href="/de/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee.caller</a></code> sind veraltet (in den Referenzartikeln sind mehr Informationen dazu enthalten).</p> + +<pre class="brush: js example-bad">'use strict'; + +function myFunc() { + if (myFunc.caller == null) { + return 'The function was called from the top!'; + } else { + return 'This function\'s caller was ' + myFunc.caller; + } +} + +myFunc(); +// Warning: ReferenceError: deprecated caller usage +// "The function was called from the top!"</pre> + +<h3 id="Function.arguments"><code>Function.arguments</code></h3> + +<p>{{jsxref("Function.arguments")}} ist veraltet (im Referenzartikel sind mehr Informationen dazu enthalten).</p> + +<pre class="brush: js example-bad">'use strict'; + +function f(n) { g(n - 1); } + +function g(n) { + console.log('before: ' + g.arguments[0]); + if (n > 0) { f(n); } + console.log('after: ' + g.arguments[0]); +} + +f(2); + +console.log('returned: ' + g.arguments); +// Warning: ReferenceError: deprecated arguments usage +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features">Veraltete and obsolete Funktionen</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a></li> + <li>{{jsxref("Function.arguments")}}</li> + <li>{{jsxref("Function.caller")}} und <code><a href="/de/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee.caller</a></code></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/deprecated_expression_closures/index.html b/files/de/web/javascript/reference/errors/deprecated_expression_closures/index.html new file mode 100644 index 0000000000..b8c6e7ced8 --- /dev/null +++ b/files/de/web/javascript/reference/errors/deprecated_expression_closures/index.html @@ -0,0 +1,78 @@ +--- +title: 'Warning: expression closures are deprecated' +slug: Web/JavaScript/Reference/Fehler/Deprecated_expression_closures +tags: + - JavaScript + - Warning +translation_of: Web/JavaScript/Reference/Errors/Deprecated_expression_closures +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: expression closures are deprecated +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>Warnung. Die Ausführung von JavaScript wird nicht angehalten.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Die nicht standardisierte <a href="/de/docs/Web/JavaScript/Reference/Operators/Expression_closures"> Ausdrucks Closure</a> Syntax (Kurzform der Funktionssyntax) ist veraltetet und sollte nicht mehr verwendet werden. Diese Syntax wird komplett entfernt ({{bug(1083458)}}) und Skripte die diese Benutzen erzeugen dann einen {{jsxref("SyntaxError")}}.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Veraltete_Syntax">Veraltete Syntax</h3> + +<p>Ausdrucks Closures vermeiden geschweifte Klammern oder return Anweisungen in Funktionsdeklarationen oder in Methodendefinitionen in Objekten.</p> + +<pre class="brush: js example-bad">var x = function() 1; + +var obj = { + count: function() 1 +}; +</pre> + +<h3 id="Standardsyntax">Standardsyntax</h3> + +<p>Um die nicht standardisierte Ausdrucks Closures Syntax zu Standard-ECMAScript Syntax zu konvertieren müssen geschweifte Klammern und ein return Statement hinzugefügt werden.</p> + +<pre class="brush: js example-good">var x = function() { return 1; } + +var obj = { + count: function() { return 1; } +}; +</pre> + +<h3 id="Standardsyntax_mit_Arrowfunktionen">Standardsyntax mit Arrowfunktionen</h3> + +<p>Alternativ können <a href="/de/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Arrow-Funktionen</a> genutzt werden:</p> + +<pre class="brush: js example-good">var x = () => 1;</pre> + +<h3 id="Standardsyntax_mit_Kurzformmethodensyntax">Standardsyntax mit Kurzformmethodensyntax</h3> + +<p>Anweisungs Closures können auch in Gettern und Settern gefunden werden:</p> + +<pre class="brush: js example-bad">var obj = { + get x() 1, + set x(v) this.v = v +}; +</pre> + +<p>Mit ES2015 <a href="/de/docs/Web/JavaScript/Reference/Functions/Method_definitions">Methodendefinitionen</a> können diese folgendermaßen konvertiert werden :</p> + +<pre class="brush: js example-good">var obj = { + get x() { return 1 }, + set x(v) { this.v = v } +}; +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Expression_closures">Ausdrucks Closures</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Arrow Funktionen</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Functions/Method_definitions">Methodendefinitionen</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/deprecated_octal/index.html b/files/de/web/javascript/reference/errors/deprecated_octal/index.html new file mode 100644 index 0000000000..e153038950 --- /dev/null +++ b/files/de/web/javascript/reference/errors/deprecated_octal/index.html @@ -0,0 +1,67 @@ +--- +title: 'SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated' +slug: Web/JavaScript/Reference/Fehler/Deprecated_octal +tags: + - Error + - JavaScript + - Strict Mode + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Deprecated_octal +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: +"0"-prefixed octal literals and octal escape sequences are deprecated; +for octal literals use the "0o" prefix instead +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}} nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a>.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Oktalliterale und oktal maskierte Sequenzen sind veraltet und führen zu einem {{jsxref("SyntaxError")}} im Strict Mode. Ab ECMAScript 2015 wird in der standardisierten Syntax eine führende null gefolgt von einem kleinen oder großen lateinischen Buchstaben "O" verwendet (<code>0o</code> oder <code>0O)</code>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Oktalliteral_mit_führender_0">Oktalliteral mit führender 0</h3> + +<pre class="brush: js example-bad">"use strict"; + +03; + +// SyntaxError: "0"-prefixed octal literals and octal escape sequences +// are deprecated</pre> + +<h3 id="Oktal_maskierte_Sequenz">Oktal maskierte Sequenz</h3> + +<pre class="brush: js example-bad">"use strict"; + +"\251"; + +// SyntaxError: "0"-prefixed octal literals and octal escape sequences +// are deprecated +</pre> + +<h3 id="Valide_Oktalzahlen">Valide Oktalzahlen</h3> + +<p>Einsatz einer führenden null gefolgt von "o" oder "O":</p> + +<pre class="brush: js example-good">0o3; +</pre> + +<p>Statt oktal maskierte Sequenzen können hexadezimal maskierte Sequenzen benutzt werden:</p> + +<pre class="brush: js example-good">'\xA9';</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar#Octal">Lexikalische Grammatik</a></li> + <li> + <p><a href="/de/docs/Web/JavaScript/Reference/Errors/Bad_octal">Warning: 08/09 is not a legal ECMA-262 octal constant</a></p> + </li> +</ul> diff --git a/files/de/web/javascript/reference/errors/deprecated_source_map_pragma/index.html b/files/de/web/javascript/reference/errors/deprecated_source_map_pragma/index.html new file mode 100644 index 0000000000..1f87b2bd2d --- /dev/null +++ b/files/de/web/javascript/reference/errors/deprecated_source_map_pragma/index.html @@ -0,0 +1,58 @@ +--- +title: >- + SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# + instead +slug: Web/JavaScript/Reference/Fehler/Deprecated_source_map_pragma +tags: + - Errors + - JavaScript + - Source maps +translation_of: Web/JavaScript/Reference/Errors/Deprecated_source_map_pragma +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead + +Warning: SyntaxError: Using //@ to indicate sourceMappingURL pragmas is deprecated. Use //# instead +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>Eine Warnung die als {{jsxref("SyntaxError")}} auftritt. Die Ausführung von JavaScript wird nicht unterbrochen.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt eine veraltete Source-Map-Syntax im JavaScript Code.</p> + +<p>JavaScript Code wird oft zusammengefügt und minimiert, um die Auslieferung durch einen Server effizienter zu machen. Mit <a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">Source-Maps</a> kann beim Debuggen der ausgeführte Code auf die Original Codedateien übertragen werden.</p> + +<p>Die Source-Map Spezifikation änderte die Syntax wegen eines Konflikts mit dem IE immer wenn die Seite nach <code>//@cc_on</code> war, interpretierte dieser es als bedingte Kompilierung in der IE JScript Umgebung. Der <a href="https://msdn.microsoft.com/en-us/library/8ka90k2e%28v=vs.94%29.aspx">bedingte Kompilations Kommentar</a> im IE ist eine relativ unbekannte Funktion, aber dieses machte Source-Maps von <a href="https://bugs.jquery.com/ticket/13274">jQuery</a> und anderen Bibliotheken kaputt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Veraltete_Syntax">Veraltete Syntax</h3> + +<p>Syntax mit dem veralteten "@" Zeichen.</p> + +<pre class="brush: js example-bad">//@ sourceMappingURL=http://example.com/path/to/your/sourcemap.map +</pre> + +<h3 id="Standard_Syntax">Standard Syntax</h3> + +<p>Benutzt stattdessen ein "#" Zeichen.</p> + +<pre class="brush: js example-good">//# sourceMappingURL=http://example.com/path/to/your/sourcemap.map</pre> + +<p>Alternativ kann ein {{HTTPHeader("SourceMap")}} Header zu der JavaScript Datei gesetzt werden, um einen solchen Kommentar zu vermeiden:</p> + +<pre class="brush: js example-good">SourceMap: /path/to/file.js.map</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Tools/Debugger/How_to/Use_a_source_map">Wie man eine Source-Map einsetzt – Firefox Werkzeug Dokumentation</a></li> + <li><a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">Einführung in Source-Maps – HTML5 rocks</a></li> + <li>{{HTTPHeader("SourceMap")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/deprecated_string_generics/index.html b/files/de/web/javascript/reference/errors/deprecated_string_generics/index.html new file mode 100644 index 0000000000..d495448759 --- /dev/null +++ b/files/de/web/javascript/reference/errors/deprecated_string_generics/index.html @@ -0,0 +1,104 @@ +--- +title: 'Warning: String.x is deprecated; use String.prototype.x instead' +slug: Web/JavaScript/Reference/Fehler/Deprecated_String_generics +tags: + - JavaScript + - Warning +translation_of: Web/JavaScript/Reference/Errors/Deprecated_String_generics +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: String.charAt is deprecated; use String.prototype.charAt instead +Warning: String.charCodeAt is deprecated; use String.prototype.charCodeAt instead +Warning: String.concat is deprecated; use String.prototype.concat instead +Warning: String.contains is deprecated; use String.prototype.contains instead +Warning: String.endsWith is deprecated; use String.prototype.endsWith instead +Warning: String.includes is deprecated; use String.prototype.includes instead +Warning: String.indexOf is deprecated; use String.prototype.indexOf instead +Warning: String.lastIndexOf is deprecated; use String.prototype.lastIndexOf instead +Warning: String.localeCompare is deprecated; use String.prototype.localeCompare instead +Warning: String.match is deprecated; use String.prototype.match instead +Warning: String.normalize is deprecated; use String.prototype.normalize instead +Warning: String.replace is deprecated; use String.prototype.replace instead +Warning: String.search is deprecated; use String.prototype.search instead +Warning: String.slice is deprecated; use String.prototype.slice instead +Warning: String.split is deprecated; use String.prototype.split instead +Warning: String.startsWith is deprecated; use String.prototype.startsWith instead +Warning: String.substr is deprecated; use String.prototype.substr instead +Warning: String.substring is deprecated; use String.prototype.substring instead +Warning: String.toLocaleLowerCase is deprecated; use String.prototype.toLocaleLowerCase instead +Warning: String.toLocaleUpperCase is deprecated; use String.prototype.toLocaleUpperCase instead +Warning: String.toLowerCase is deprecated; use String.prototype.toLowerCase instead +Warning: String.toUpperCase is deprecated; use String.prototype.toUpperCase instead +Warning: String.trim is deprecated; use String.prototype.trim instead +Warning: String.trimLeft is deprecated; use String.prototype.trimLeft instead +Warning: String.trimRight is deprecated; use String.prototype.trimRight instead +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>Warnung. JavaScript unterbricht die Ausführung nicht.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Die nicht standardisierten generischen {{jsxref("String")}} Methoden sind veraltet und werden in Zukunft gelöscht (keine Browserübergreifende Unterstützung, nur in Firefox verfügbar). <span id="result_box" lang="de"><span>String-Generics stellen String-Instanzmethoden für das String-Objekt bereit, wodurch String-Methoden auf jedes Objekt angewendet werden können.</span></span></p> + +<p>Firefox {{bug(1222552)}} dokumentiert das Entfernen von generischen String Methoden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Fehlerfälle">Fehlerfälle</h3> + +<pre class="brush: js example-bad">var num = 15; +String.replace(num, /5/, '2');</pre> + +<h3 id="Gültige_Fälle">Gültige Fälle</h3> + +<pre class="brush: js example-good">var num = 15; +String(num).replace(/5/, '2'); +</pre> + +<h2 id="Shim">Shim</h2> + +<p><span id="result_box" lang="de"><span>Das Folgende ist ein Shim zur Unterstützung nicht unterstützender Browser:</span></span></p> + +<pre class="brush: js">/*globals define*/ +// Assumes all supplied String instance methods already present +// (one may use shims for these if not available) +(function() { + 'use strict'; + + var i, + // We could also build the array of methods with the following, but the + // getOwnPropertyNames() method is non-shimable: + // Object.getOwnPropertyNames(String).filter(function(methodName) { + // return typeof String[methodName] === 'function'; + // }); + methods = [ + 'contains', 'substring', 'toLowerCase', 'toUpperCase', 'charAt', + 'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith', + 'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase', 'normalize', + 'toLocaleUpperCase', 'localeCompare', 'match', 'search', 'slice', + 'replace', 'split', 'substr', 'concat', 'localeCompare' + ], + methodCount = methods.length, + assignStringGeneric = function(methodName) { + var method = String.prototype[methodName]; + String[methodName] = function(arg1) { + return method.apply(arg1, Array.prototype.slice.call(arguments, 1)); + }; + }; + + for (i = 0; i < methodCount; i++) { + assignStringGeneric(methods[i]); + } +}());</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li>Es gibt ebenfalls {{jsxref("Global_Objects/Array", "Generische Array Methoden", "#Array_generic_methods", 1)}} (die auch veraltet sind).</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/deprecated_tolocaleformat/index.html b/files/de/web/javascript/reference/errors/deprecated_tolocaleformat/index.html new file mode 100644 index 0000000000..31cc81d9cc --- /dev/null +++ b/files/de/web/javascript/reference/errors/deprecated_tolocaleformat/index.html @@ -0,0 +1,90 @@ +--- +title: 'Warning: Date.prototype.toLocaleFormat is deprecated' +slug: Web/JavaScript/Reference/Fehler/Deprecated_toLocaleFormat +tags: + - JavaScript + - Warning +translation_of: Web/JavaScript/Reference/Errors/Deprecated_toLocaleFormat +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: Date.prototype.toLocaleFormat is deprecated; consider using Intl.DateTimeFormat instead +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>Warnung. JavaScript stoppt die ausführung nicht an.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Die nicht standardisierte Methode {{jsxref("Date.prototype.toLocaleFormat")}} ist veraltet und sollte nicht mehr benutzt werden. Sie benutzt einen Formatstring mit dem selben Format, wie dei der C Funktion <code>strftime()</code>. <strong>Diese Funktion ist seit Firefox 58+ nicht mehr vorhanden</strong>.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Veraltete_Syntax">Veraltete Syntax</h3> + +<p>Die {{jsxref("Date.prototype.toLocaleFormat")}} Methode ist veraltet und wird entfernt werden (keine browserübergreifende Unterstützung, nur in Firefox verfügbar).</p> + +<pre class="brush: js example-bad">var today = new Date(); +var date = today.toLocaleFormat('%A, %e. %B %Y'); + +console.log(date); +// In German locale +// "Freitag, 10. März 2017"</pre> + +<h3 id="Alternative_Standardsyntax_mit_der_ECMAScript_Intl_API">Alternative Standardsyntax mit der ECMAScript Intl API</h3> + +<p>Der ECMA-402 Standard spezifiziert Standardobjekte und Methoden (ECMAScript Intl API), die sprachabhängige Datums- und Zeitformatierung erlauben (verfügbar in Chrome 24+, Firefox 29+, IE11+, Safari10+).</p> + +<p>Man kan jetzt die {{jsxref("Date.prototype.toLocaleDateString")}} Methode einsetzen, um einen Zeitpunkt zu formatieren.</p> + +<pre class="brush: js example-good">var today = new Date(); +var options = { weekday: 'long', year: 'numeric', + month: 'long', day: 'numeric' }; +var date = today.toLocaleDateString('de-DE', options); + +console.log(date); +// "Freitag, 10. März 2017" +</pre> + +<p>Oder man kann das {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} Objekt einsetzen, welches die meisten Berechnungen zwischenspeichert, so dass das Formatieren schneller ist. Dieses ist nützlich, wenn Zeitpunkte in einer Schleife formatiert werden.</p> + +<pre class="brush: js example-good">var options = { weekday: 'long', year: 'numeric', + month: 'long', day: 'numeric' }; +var dateFormatter = new Intl.DateTimeFormat('de-DE', options) + +var dates = [Date.UTC(2012, 11, 20, 3, 0, 0), + Date.UTC(2014, 04, 12, 8, 0, 0)]; + +dates.forEach(date => console.log(dateFormatter.format(date))); + +// "Donnerstag, 20. Dezember 2012" +// "Montag, 12. Mai 2014" +</pre> + +<h3 id="Alternative_Standardsyntax_mit_Date_Methoden">Alternative Standardsyntax mit Date Methoden</h3> + +<p>Das {{jsxref("Date")}} Objekt enthält einige Methoden, um einen Benutzerdefinierten Datumsstring zu erhalten.</p> + +<pre class="brush: js example-bad">(new Date()).toLocaleFormat("%Y%m%d"); +// "20170310" +</pre> + +<p>Dieses kan konvertiert werde:</p> + +<pre class="brush: js example-good">let now = new Date(); +let date = now.getFullYear() * 10000 + + (now.getMonth() + 1) * 100 + now.getDate(); + +console.log(date); +// "20170310"</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString")}}</li> + <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/equal_as_assign/index.html b/files/de/web/javascript/reference/errors/equal_as_assign/index.html new file mode 100644 index 0000000000..dbe5e55b02 --- /dev/null +++ b/files/de/web/javascript/reference/errors/equal_as_assign/index.html @@ -0,0 +1,54 @@ +--- +title: 'SyntaxError: test for equality (==) mistyped as assignment (=)?' +slug: Web/JavaScript/Reference/Fehler/Equal_as_assign +tags: + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Equal_as_assign +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: SyntaxError: test for equality (==) mistyped as assignment (=)? +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}} Warnung nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt eine Zuweisung (<code>=</code>) an der eigentlich ein Gleichheitsprüfung (<code>==</code>) erwartet wird. Um das Debuggen zu unterstützen, warnt JavaScript diesen Fakt (im strict mode).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Zuweisung_in_bedingten_Ausdrücken">Zuweisung in bedingten Ausdrücken</h3> + +<p>Es ist ratsam in bedingten Ausdrücken (wie z. B. <code><a href="/de/docs/Web/JavaScript/Reference/Statements/if...else">if...else</a></code>) keine einfachen Zuweisungen zu verwenden, weil beim lesen des Codes eine Zuweisung mit einer Gleichheitsprüfung verwechselt werden kann. Zum Beispiel sollte folgender Code nicht verwendet werden:</p> + +<pre class="brush: js example-bad">if (x = y) { + // do the right thing +} +</pre> + +<p>Wenn es notwendig ist eine Zuweisung in einem bedingten Ausdruck einzusetzen, ist es verbreitet, diese mit runden Klammern einzuklammern. Zum Beispiel:</p> + +<pre class="brush: js">if ((x = y)) { + // do the right thing +}</pre> + +<p>Andernfalls kann es sein, dass eigentliche eine Vergleichsoperation gemeint war (z. B. <code>==</code> oder <code>===</code>):</p> + +<pre class="brush: js">if (x == y) { + // do the right thing +}</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict mode</a></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/if...else">if...else</a></code></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Vergleichsoperatoren</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html b/files/de/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html new file mode 100644 index 0000000000..2651ea45ba --- /dev/null +++ b/files/de/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html @@ -0,0 +1,168 @@ +--- +title: 'Warning: JavaScript 1.6''s for-each-in loops are deprecated' +slug: Web/JavaScript/Reference/Fehler/For-each-in_loops_are_deprecated +tags: + - JavaScript + - Warning +translation_of: Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: JavaScript 1.6's for-each-in loops are deprecated; consider using ES6 for-of instead +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>Warnung</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Das {{jsxref("Statements/for_each...in", "for each (variable in obj)")}} Statement aus JavaScript 1.6 ist veraltet und wird in naher Zukunft entfernt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Objektiteration">Objektiteration</h3> + +<p>{{jsxref("Statements/for_each...in", "for each...in")}} wurde eingesetzt, um über spezifizierte Objektwerte zu iterieren.</p> + +<h4 id="Veraltete_Syntax">Veraltete Syntax</h4> + +<pre class="brush: js example-bad">var object = { a: 10, b: 20 }; + +for each (var x in object) { + console.log(x); // 10 + // 20 +} +</pre> + +<h4 id="Alternative_Standardsyntax">Alternative Standardsyntax</h4> + +<p>Man kann die Standardschleife {{jsxref("Statements/for...in", "for...in")}} benutzen, um über spezifizierte Objektschlüssel zu iterieren und jeden Wert in der Schleife auszulesen:</p> + +<pre class="brush: js example-good">var object = { a: 10, b: 20 }; + +for (var key in object) { + var x = object[key]; + console.log(x); // 10 + // 20 +} +</pre> + +<p>Oder man benutzt {{jsxref("Statements/for...of", "for...of")}} (ES2015) und {{jsxref("Object.values")}} (ES2017), um ein Array von spezifizerten Werten zu bekommen und über diese zu iterieren:</p> + +<pre class="brush: js example-good">var object = { a: 10, b: 20 }; + +for (var x of Object.values(object)) { + console.log(x); // 10 + // 20 +} +</pre> + +<h3 id="Arrayiteration">Arrayiteration</h3> + +<p>{{jsxref("Statements/for_each...in", "for each...in")}} wurde eingesetzt, um über spezifizierte Arrayelemente zu iterieren.</p> + +<h4 id="Veraltete_Syntax_2">Veraltete Syntax</h4> + +<pre class="brush: js example-bad">var array = [10, 20, 30]; + +for each (var x in array) { + console.log(x); // 10 + // 20 + // 30 +} +</pre> + +<h4 id="Alternative_Standardsyntax_2">Alternative Standardsyntax</h4> + +<p>Dieses ist mit der {{jsxref("Statements/for...of", "for...of Schleife")}} (ES2015) möglich.</p> + +<pre class="brush: js example-good">var array = [10, 20, 30]; + +for (var x of array) { + console.log(x); // 10 + // 20 + // 30 +} +</pre> + +<h3 id="Iterieren_über_ein_Arrays_oder_null">Iterieren über ein Arrays oder null</h3> + +<p>{{jsxref("Statements/for_each...in", "for each...in")}} tut nichts, wenn der übergebene Wert <code>null</code> oder <code>undefined</code> ist. {{jsxref("Statements/for...of", "for...of")}} erzeugt in diesem Fall einen Fehler.</p> + +<h4 id="Veraltete_Syntax_3">Veraltete Syntax</h4> + +<pre class="brush: js example-bad">function func(array) { + for each (var x in array) { + console.log(x); + } +} +func([10, 20]); // 10 + // 20 +func(null); // prints nothing +func(undefined); // prints nothing +</pre> + +<h4 id="Alternative_Standardsyntax_3">Alternative Standardsyntax</h4> + +<p>Um das {{jsxref("Statements/for_each...in", "for each...in")}} Statement neu zu schreibe, so dass <code>null</code> oder <code>undefined</code> mit {{jsxref("Statements/for...of", "for...of")}} funktionieren, muss eine Bedingung um {{jsxref("Statements/for...of", "for...of")}} verfasst werden.</p> + +<pre class="brush: js example-good">function func(array) { + if (array) { + for (var x of array) { + console.log(x); + } + } +} +func([10, 20]); // 10 + // 20 +func(null); // prints nothing +func(undefined); // prints nothing +</pre> + +<h3 id="Über_Objekt-Schlüssel-Werte-Paare_iterieren">Über Objekt-Schlüssel-Werte-Paare iterieren</h3> + +<h4 id="Veraltete_Syntax_4">Veraltete Syntax</h4> + +<p>Es gibt eine veraltete Dialekt, der das Iterieren über Objekt-Schlüssel-Werte-Paare mit {{jsxref("Statements/for_each...in", "for each...in")}} und mit dem veralteten {{jsxref("Iterator")}} Objekt erlaubt.</p> + +<pre class="brush: js example-bad">var object = { a: 10, b: 20 }; + +for each (var [key, value] in Iterator(object)) { + console.log(key, value); // "a", 10 + // "b", 20 +} +</pre> + +<h4 id="Alternative_Standardsyntax_4">Alternative Standardsyntax</h4> + +<p>Man kann die Standardschleife {{jsxref("Statements/for...in", "for...in")}} benutzen, um über spezifizierte Objektschlüssel zu iterieren und jeden Wert in der Schleife auszulesen:</p> + +<pre class="brush: js example-good">var object = { a: 10, b: 20 }; + +for (var key in object) { + var value = object[key]; + console.log(key, value); // "a", 10 + // "b", 20 +} +</pre> + +<p>Oder man benutzt {{jsxref("Statements/for...of", "for...of")}} (ES2015) und {{jsxref("Object.values")}} (ES2017), um ein Array von spezifizerten Werten zu bekommen und über diese zu iterieren:</p> + +<pre class="brush: js example-good">var object = { a: 10, b: 20 }; + +for (var [key, value] of Object.entries(object)) { + console.log(key, value); // "a", 10 + // "b", 20 +} +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Statements/for...of", "for...of")}}</li> + <li>{{jsxref("Object.values")}}</li> + <li>{{jsxref("Object.entries")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/getter_only/index.html b/files/de/web/javascript/reference/errors/getter_only/index.html new file mode 100644 index 0000000000..268ee0cbf1 --- /dev/null +++ b/files/de/web/javascript/reference/errors/getter_only/index.html @@ -0,0 +1,83 @@ +--- +title: 'TypeError: setting getter-only property "x"' +slug: Web/JavaScript/Reference/Fehler/Getter_only +tags: + - Error + - Errors + - JavaScript + - Strict Mode + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Getter_only +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: setting getter-only property "x" (Firefox) +TypeError: Cannot set property "prop" of #<Object> which has only a getter (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}} nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Wenn versucht wird einen neuen Wert einer Wichenschaft zuzuweisen, welche nur als <a href="/de/docs/Web/JavaScript/Reference/Functions/get">Getter</a> spezifiziert wurde. Wenn kein strict mode verwendet wird, wird dieses stillschweigend ignoriert, während im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> ein {{jsxref("TypeError")}} erzeugt wird.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Das folgende Beispiel zeigt, wie eine Eigenschaft als Getter eingestellt wird. Es wird kein <a href="/de/docs/Web/JavaScript/Reference/Functions/set">Setter</a> definiert, so dass ein <code>TypeError</code> erzeugt wird, wenn die <code>temperature</code> Eigenschaft mit dem Wert <code>30</code> beschrieben werden soll. Für mehr Details siehe auf der {{jsxref("Object.defineProperty()")}} Seite.</p> + +<pre class="brush: js example-bad">"use strict"; + +function Archiver() { + var temperature = null; + Object.defineProperty(this, 'temperature', { + get: function() { + console.log('get!'); + return temperature; + } + }); +} + +var arc = new Archiver(); +arc.temperature; // 'get!' + +arc.temperature = 30; +// TypeError: setting getter-only property "temperature"</pre> + +<p>Um den Fehler zu beheben, muss einefach die Zeile 16 entfernt werden, weil dort der Versuch ist die <code>temperature</code> Eigenschaft zu beschreiben, oder es muss ein <a href="/de/docs/Web/JavaScript/Reference/Functions/set">Setter</a> definiert werden, wie zum Beispiel dieser:</p> + +<pre class="brush: js example-good highlight[12]">"use strict"; + +function Archiver() { + var temperature = null; + var archive = []; + + Object.defineProperty(this, 'temperature', { + get: function() { + console.log('get!'); + return temperature; + }, + set: function(value) { + temperature = value; + archive.push({ val: temperature }); + } + }); + + this.getArchive = function() { return archive; }; +} + +var arc = new Archiver(); +arc.temperature; // 'get!' +arc.temperature = 11; +arc.temperature = 13; +arc.getArchive(); // [{ val: 11 }, { val: 13 }]</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.defineProperties()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/identifier_after_number/index.html b/files/de/web/javascript/reference/errors/identifier_after_number/index.html new file mode 100644 index 0000000000..64cb9cdfe3 --- /dev/null +++ b/files/de/web/javascript/reference/errors/identifier_after_number/index.html @@ -0,0 +1,53 @@ +--- +title: 'SyntaxError: identifier starts immediately after numeric literal' +slug: Web/JavaScript/Reference/Fehler/Identifier_after_number +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Identifier_after_number +--- +<div>{{JSSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: identifier starts immediately after numeric literal (Firefox) +SyntaxError: Unexpected number (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Die Namen von Variablen, {{Glossary("Identifier", "Bezeichner")}} genannt, haben einige Regeln, die der Code erfüllen muss.</p> + +<p>Ein Bezeichner in JavaScript muss mit einem Buchstaben, einem Unterstrich (_) oder einem Dollarzeichen ($) starten. Er kann nicht mit einer Ziffer beginnen. Nur nachfolgende Zeichen sind Ziffern (0-9).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Variablenname_der_mit_einer_Ziffer_beginnt">Variablenname der mit einer Ziffer beginnt</h3> + +<p>Variablennamen dürfen in JavaScript nicht mit einer Zahl beginnen. Das folgende wird nciht funktionieren:</p> + +<pre class="brush: js example-bad">var 1life = 'foo'; +// SyntaxError: identifier starts immediately after numeric literal + +var foo = 1life; +// SyntaxError: identifier starts immediately after numeric literal +</pre> + +<p>Man muss die Variable neu benenne, um die führende Zahl im Namen zu vermeiden.</p> + +<pre class="brush: js example-good">var life1 = 'foo'; +var foo = life1; +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar">Lexikalische Grammatik</a></li> + <li><a href="/de/docs/Web/JavaScript/Guide/Grammar_and_types#Variablen">Variablen</a> im <a href="/de/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/illegal_character/index.html b/files/de/web/javascript/reference/errors/illegal_character/index.html new file mode 100644 index 0000000000..e0c083022c --- /dev/null +++ b/files/de/web/javascript/reference/errors/illegal_character/index.html @@ -0,0 +1,80 @@ +--- +title: 'SyntaxError: illegal character' +slug: Web/JavaScript/Reference/Fehler/Illegal_character +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Illegal_character +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: illegal character (Firefox) +SyntaxError: Invalid or unexpected token (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt ein nicht valides oder nicht erwartetes Token, welches nicht an eine Position im Code passt. Man sollte einen Editor mit Syntaxhighlighting benutzten und vorsichtig nach Verwechselungen suchen, wie einem Minuszeichen (<code> - </code>) und einem Dashzeichen (<code> – </code>) oder einfachen Anführungszeichen (<code> " </code>) und anderen Anführungszeichen (<code> “ </code>).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Verwechseltes_Zeichen">Verwechseltes Zeichen</h3> + +<p>Einige Zeichen sehen sehr ähnlich aus, aber führen dazu, dass der Code nicht interpretiert werden kann. Bekannte Beispiele dafür sind Anführungszeichen, das Minus oder das Semikolon (<a href="https://de.wikipedia.org/wiki/Fragezeichen#Weitere_Schriftsysteme">griechisches Fragezeichen (U+37e)</a> sieht genauso aus)</p> + +<pre class="brush: js example-bad line-numbers language-js">“This looks like a string”; // SyntaxError: illegal character + // “ und ” sind nicht ", aber sehen so aus + +42 – 13; // SyntaxError: illegal character + // – sind nicht -, aber sieht so aus + +var foo = 'bar'; <code class="language-js"><span class="comment token">// SyntaxError: illegal character + </span></code>// <37e> sind nicht ;, aber sieht so aus +</pre> + +<p>Das funktioniert:</p> + +<pre class="brush: js example-good">"This is actually a string"; +42 - 13; +var foo = 'bar'; +</pre> + +<p>Einige Editoren und IDEs werden darauf hinweisen oder dieses anderes hervorheben, aber nicht alle. Wenn manchmal so etwas im Code passiert und man in der Lage ist das Problem zu finden, ist es oft das beste die Zeile zu löschen und sie neu einzutippen.</p> + +<h3 id="Vergessene_Zeichen">Vergessene Zeichen</h3> + +<p>Es passiert schnell, dass man ein Zeichen vergisst.</p> + +<pre class="brush: js example-bad">var colors = ['#000', #333', '#666']; +// SyntaxError: illegal character +</pre> + +<p>Man muss das fehlende Anführungszeichen ergänzen <code><strong>'</strong>#333'</code>.</p> + +<pre class="brush: js example-good">var colors = ['#000', '#333', '#666'];</pre> + +<h3 id="Nicht_sichtbare_Zeichen">Nicht sichtbare Zeichen</h3> + +<p>Beim Kopieren und Einfügen von Code aus externen Quellen kann es nicht valide Zeichen geben. Zum Beispiel:</p> + +<pre class="brush: js example-bad">var foo = 'bar'; +// SyntaxError: illegal character +</pre> + +<p>Wenn man den Code in einem Editor wie Vim anschaut, bemerkt man, dass ein<a href="https://de.wikipedia.org/wiki/Breitenloses_Leerzeichen"> breitenloses Leerzeichen (ZWSP) (U+200B)</a> benutzt wird.</p> + +<pre class="brush: js">var foo = 'bar';<200b></pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar">Lexikalische Grammatik</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/in_operator_no_object/index.html b/files/de/web/javascript/reference/errors/in_operator_no_object/index.html new file mode 100644 index 0000000000..6bace66437 --- /dev/null +++ b/files/de/web/javascript/reference/errors/in_operator_no_object/index.html @@ -0,0 +1,72 @@ +--- +title: 'TypeError: cannot use ''in'' operator to search for ''x'' in ''y''' +slug: Web/JavaScript/Reference/Fehler/in_operator_no_object +tags: + - Error + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/in_operator_no_object +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: right-hand side of 'in' should be an object, got 'x' (Firefox) +TypeError: cannot use 'in' operator to search for 'x' in 'y' (Firefox, Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der <a href="/de/docs/Web/JavaScript/Reference/Operators/in"><code>in</code> Operator</a> kan nur für das Prüfen von Eigenschaften in Objekten genutzt werden. Man kann nicht in Strings, Nummern oder anderen primitiven Typen suchen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Suchen_in_Strings">Suchen in Strings</h3> + +<p>Im Vergleich zu anderen Programmiersprachen (z. B. Python) kann in Strings nicht mit dem <a href="/de/docs/Web/JavaScript/Reference/Operators/in"><code>in</code> Operator</a> gesucht werden.</p> + +<pre class="brush: js example-bad">"Hello" in "Hello World"; +// TypeError: cannot use 'in' operator to search for 'Hello' in 'Hello World'</pre> + +<p>Stattdessen kann zum Beispiel {{jsxref("String.prototype.indexOf()")}} eingesetzt werden.</p> + +<pre class="brush: js example-good">"Hello World".indexOf("Hello") !== -1; +// true</pre> + +<h3 id="Der_Operand_kann_nicht_null_oder_undefined_sein">Der Operand kann nicht <code>null</code> oder <code>undefined</code> sein</h3> + +<p>Man muss sicherstellen, dass der Operand nicht {{jsxref("null")}} oder {{jsxref("undefined")}} ist.</p> + +<pre class="brush: js example-bad">var foo = null; +"bar" in foo; +// TypeError: cannot use 'in' operator to search for 'bar' in 'foo' (Chrome) +// TypeError: right-hand side of 'in' should be an object, got null (Firefox) +</pre> + +<p>Der <code>in</code> Operator erwartet immer ein Objekt.</p> + +<pre class="brush: js example-good">var foo = { baz: "bar" }; +"bar" in foo; // false + +"PI" in Math; // true +"pi" in Math; // false +</pre> + +<h3 id="Suchen_in_Arrays">Suchen in Arrays</h3> + +<p>Man muss vorsichtig sein, wenn der <code>in</code> Operator in {{jsxref("Array")}} Objekten genutzt wird. Der <code>in</code> Operator prüft die Indexnummern, aber nicht die Werte des Indizes.</p> + +<pre class="brush: js">var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple']; +3 in trees; // true +"oak" in trees; // false</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/in"><code>in</code> Operator</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/index.html b/files/de/web/javascript/reference/errors/index.html new file mode 100644 index 0000000000..67809031e7 --- /dev/null +++ b/files/de/web/javascript/reference/errors/index.html @@ -0,0 +1,29 @@ +--- +title: JavaScript Fehler Referenz +slug: Web/JavaScript/Reference/Fehler +tags: + - Debugging + - Error + - Errors + - Exception + - JavaScript + - exceptions +translation_of: Web/JavaScript/Reference/Errors +--- +<p>{{jsSidebar("Errors")}}</p> + +<p>Unten ist eine Liste von Fehlern, die in JavaScript auftauchen können. Diese Fehler können beim Debuggen hilfreich sein, jedoch sind die Probleme nicht immer so klar. Die untenstehenden Seiten enthalten Details zu diesen Fehlern. Jeder Fehler ist ein Objekt, welches auf dem {{jsxref("Error")}} Objekt basieren und haben einen <code>name</code> und eine Fehlermeldung (<code>message</code>).</p> + +<p>Fehler die in der Webconsole angezeigt werden enthalten manchmal einen Link zu einer der untenstehenden Seiten, um die Lösung von Problemen zu beschleunigen.</p> + +<h2 id="Liste_von_Fehlern">Liste von Fehlern</h2> + +<p>In dieser Liste ist jede Seite mit einem Namen (der Typ des Fehlers) und einer Fehlermeldung (eine detailliertere, verständlichere Meldung) aufgeführt. Diese beiden Eigenschaften eines Fehlers sind ein Einstiegspunkt für das Verständnis und das Lösen des Fehlers. Für mehr Informationen folge den folgenden Links!</p> + +<p>{{ListSubPages("/en-US/docs/Web/JavaScript/Reference/Errors")}}</p> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Learn/JavaScript/First_steps/What_went_wrong">Was ist falsch gelaufen? Fehlerbehandlung in JavaScript</a>: Tutorial für Anfänger, welches das beheben von Fehlern zeigt.</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/invalid_array_length/index.html b/files/de/web/javascript/reference/errors/invalid_array_length/index.html new file mode 100644 index 0000000000..34edeb2969 --- /dev/null +++ b/files/de/web/javascript/reference/errors/invalid_array_length/index.html @@ -0,0 +1,77 @@ +--- +title: 'RangeError: invalid array length' +slug: Web/JavaScript/Reference/Fehler/Invalid_array_length +tags: + - Errors + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Invalid_array_length +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">RangeError: invalid array length (Firefox) +RangeError: Invalid array length (Chrome) +RangeError: Invalid array buffer length (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>entweder:</p> + +<ul> + <li>ein {{jsxref("Array")}} oder ein {{jsxref("ArrayBuffer")}} wurde mit einer negativen oder einer Zahl größer gleich 2<sup>32</sup> erzeugt, oder</li> + <li>die {{jsxref("Array.length")}} Eigenschaft wurde auf eine negative oder eine Zahl größer gleich 2<sup>32</sup> gesetzt.</li> +</ul> + +<p>Warum ist die Länge von Array and <code>ArrayBuffer</code> limitiert? Die <code>length</code> Eigenschaft von <code>Array </code>und <code>ArrayBuffer </code>ist mit einem vorzeichenlosen 32-bit Integer definiert, sodass nur Werte von 0 bis 2<sup>32</sup>-1 gültig sind.</p> + +<p>Wenn man ein Array mit dem Konstruktor erzeugen möchte, statt mit der Literalnotation, sollte man aufpassem, dass das erste Argument als Länge des Arrays interpretiert wird.</p> + +<p>Man sollte die Länge festlegen, bevor man die <code>length</code> Eigenschaft setzt, oder mit dem ersten Argument im Konstruktor.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ungültige_Fälle">Ungültige Fälle</h3> + +<pre class="brush: js example-bad">new Array(Math.pow(2, 40)) +new Array(-1) +new ArrayBuffer(Math.pow(2, 32)) +new ArrayBuffer(-1) + +let a = []; +a.length = a.length - 1; // length Eigenschaft auf -1 gesetzt + +let b = new Array(Math.pow(2, 32) - 1); +b.length = b.length + 1; // length Eigenschaft auf 2^32 gesetzt +</pre> + +<h3 id="Gültige_Fälle">Gültige Fälle</h3> + +<pre class="brush: js example-good">[ Math.pow(2, 40) ] // [ 1099511627776 ] +[ -1 ] // [ -1 ] +new ArrayBuffer(Math.pow(2, 32) - 1) +new ArrayBuffer(0) + +let a = []; +a.length = Math.max(0, a.length - 1); + +let b = new Array(Math.pow(2, 32) - 1); +b.length = Math.min(0xffffffff, b.length + 1); + +// 0xffffffff ist die hexadecimal Notation für 2^32 - 1 +// kann auch als (-1 >>> 0) geschrieben werden +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.length")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html b/files/de/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html new file mode 100644 index 0000000000..6e727fb9a2 --- /dev/null +++ b/files/de/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html @@ -0,0 +1,53 @@ +--- +title: 'ReferenceError: invalid assignment left-hand side' +slug: Web/JavaScript/Reference/Fehler/Invalid_assignment_left-hand_side +tags: + - Errors + - JavaScript + - ReferenceError +translation_of: Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">ReferenceError: invalid assignment left-hand side +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("ReferenceError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt irgendwo eine unerwartete Zuweisung. Das kann zum Beispiel durch eine nicht Übereinstimmung des <a href="/de/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Zuweisungsoperators</a> und eines <a href="/de/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Vergleichsoperators</a> hervorgerufen werden. Während ein einzelnes "<code>=</code>" Zeichen einer Variable einen Wert zuweist, vergleichen "<code>==</code>" und "<code>===</code>" zwei Werte.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js example-bad">if (Math.PI = 3 || Math.PI = 4) { + console.log('no way!'); +} +// ReferenceError: invalid assignment left-hand side + +var str = 'Hello, ' ++= 'is it me ' ++= 'you\'re looking for?'; +// ReferenceError: invalid assignment left-hand side</pre> + +<p>In dem <code>if</code> Statement wird ein Vergleichsoperator ("==") und für die Stringverkettung ein plus ("+") Operator benötigt.</p> + +<pre class="brush: js example-good">if (Math.PI == 3 || Math.PI == 4) { + console.log('no way!'); +} + +var str = 'Hello, ' ++ 'from the ' ++ 'other side!'; +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Zuweisungsoperatoren</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Vergleichsoperatoren</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/invalid_const_assignment/index.html b/files/de/web/javascript/reference/errors/invalid_const_assignment/index.html new file mode 100644 index 0000000000..812577360a --- /dev/null +++ b/files/de/web/javascript/reference/errors/invalid_const_assignment/index.html @@ -0,0 +1,90 @@ +--- +title: 'TypeError: invalid assignment to const "x"' +slug: Web/JavaScript/Reference/Fehler/Invalid_const_assignment +tags: + - Error + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Invalid_const_assignment +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: invalid assignment to const "x" (Firefox) +TypeError: Assignment to constant variable. (Chrome) +TypeError: Redeclaration of const 'x' (IE/Edge) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Eine Konstante ist ein Wert, der nicht von einem Programm während der normalen Ausführung, geändert werden kann. Sie kann nicht durch erneutes Zuweisen und Neudeklarationen geändert werden. In JavaScript werden Konstanten mit dem <code><a href="/de/docs/Web/JavaScript/Reference/Statements/const">const</a></code> Schlüsselwort deklariert.</p> + +<h2 id="Beispiel">Beispiel</h2> + +<h3 id="Nicht_valide_Neudeklaration">Nicht valide Neudeklaration</h3> + +<p>Weist eine Konstanten erneut einen Wert zu. Führt zu einem Fehler.</p> + +<pre class="brush: js example-bad">const COLUMNS = 80; + +// ... + +COLUMNS = 120; // TypeError: invalid assignment to const `COLUMNS'</pre> + +<h3 id="Den_Fehler_auflösen">Den Fehler auflösen</h3> + +<p>Es gibt mehrere Optionen, um den Fehler zu vermeiden. <span id="result_box" lang="de"><span>Überprüfen Sie, was mit der betreffenden Konstante erreicht werden sollte.</span></span></p> + +<h4 id="Umbenennen">Umbenennen</h4> + +<p><span id="result_box" lang="de"><span>Wenn Sie eine andere Konstante deklarieren möchten, wählen Sie einen anderen Namen und benennen Sie ihn um.</span> <span>Dieser konstante Name ist dann in diesem Bereich vergeben.</span></span></p> + +<pre class="brush: js example-good">const COLUMNS = 80; +const WIDE_COLUMNS = 120;</pre> + +<h4 id="const_let_or_var"><code>const</code>, <code>let</code> or <code>var</code>?</h4> + +<p><span id="result_box" lang="de"><span>Verwenden Sie nicht <code>const</code>, wenn Sie keine Konstante deklarieren wollten. Vielleicht soll eine Blockvariable mit </span></span><code><a href="/de/docs/Web/JavaScript/Reference/Statements/let">let</a></code> oder eine globale Variable mit <code><a href="/de/docs/Web/JavaScript/Reference/Statements/var">var</a></code> deklariert werden.</p> + +<pre class="brush: js example-good">let columns = 80; + +// ... + +let columns = 120; +</pre> + +<h4 id="Gültigkeitsbereich">Gültigkeitsbereich</h4> + +<p>Prüfen Sie, ob Sie im richtigen Gültigkeitsbereich sind. Sollte diese Konstante in diesen Gültigkeitsbereich oder sollte diese zum Beispiel in eine Funktion.</p> + +<pre class="brush: js example-good">const COLUMNS = 80; + +function setupBigScreenEnvironment() { + const COLUMNS = 120; +}</pre> + +<h3 id="const_und_Unveränderlichkeit"><code>const</code> und Unveränderlichkeit</h3> + +<p>Die <code>const</code> Deklaration erstellt eine nur lesbare Referenz zu einem Wert. Das bedeutet nicht, dass der enthaltene Wert Unveränderbar ist, sondern nur, dass der Bezeichner nicht neu definiert werden kann. Wenn die Konstante zum Beispiel ein Objekt ist, kann das Objekt selbst verändert werden. Es bedeutet nur, dass der Wert in der Variable nicht verändert werden kann.</p> + +<pre class="brush: js example-bad">const obj = {foo: 'bar'}; +obj = {foo: 'baz'}; // TypeError: invalid assignment to const `obj' +</pre> + +<p>Aber man kann die Eigenschaften der Variable verändern:</p> + +<pre class="brush: js example-good">obj.foo = 'baz'; +obj; // Object { foo: "baz" }</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/const">const</a></code></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/let">let</a></code></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/invalid_date/index.html b/files/de/web/javascript/reference/errors/invalid_date/index.html new file mode 100644 index 0000000000..04954fe28f --- /dev/null +++ b/files/de/web/javascript/reference/errors/invalid_date/index.html @@ -0,0 +1,54 @@ +--- +title: 'RangeError: invalid date' +slug: Web/JavaScript/Reference/Fehler/Invalid_date +tags: + - Errors + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Invalid_date +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">RangeError: invalid date (Firefox) +RangeError: invalid time value (Chrome) +RangeError: Provided date is not in valid range (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="Was_ist_schief_gelaufen">Was ist schief gelaufen?</h2> + +<p><span id="result_box" lang="de"><span>Eine Zeichenfolge, die ein ungültiges Datum enthält, wurde </span></span> {{jsxref("Date")}} oder {{jsxref("Date.parse()")}} übergeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_valide_Fälle">Nicht valide Fälle</h3> + +<p>Nicht erkennbare Strings oder Daten, welche nicht erlaubte Elementewerte im ISO formatierten String enthalten, geben gewöhnlich {{jsxref("NaN")}} zurück. Abhängig von der Implementierung kann es auch sein, dass nicht valide ISO Formate, einen <code>RangeError: invalid date</code> erzeugen, wie die folgenden Fällen in Firefox:</p> + +<pre class="brush: js example-bad">new Date('foo-bar 2014'); +new Date('2014-25-23').toISOString(); +new Date('foo-bar 2014').toString(); +</pre> + +<p>Das folgende gibt in Firefox {{jsxref("NaN")}} zurück.</p> + +<pre class="brush: js example-bad">Date.parse('foo-bar 2014'); // NaN</pre> + +<p>Für mehr Details, sollte die {{jsxref("Date.parse()")}} Dokumentation angesehen werden.</p> + +<h3 id="Valide_Fälle">Valide Fälle</h3> + +<pre class="brush: js example-good">new Date('05 October 2011 14:48 UTC');</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Date")}}</li> + <li>{{jsxref("Date.prototype.parse()")}}</li> + <li>{{jsxref("Date.prototype.toISOString()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/invalid_for-in_initializer/index.html b/files/de/web/javascript/reference/errors/invalid_for-in_initializer/index.html new file mode 100644 index 0000000000..bc4bf80c70 --- /dev/null +++ b/files/de/web/javascript/reference/errors/invalid_for-in_initializer/index.html @@ -0,0 +1,74 @@ +--- +title: 'SyntaxError: for-in loop head declarations may not have initializers' +slug: Web/JavaScript/Reference/Fehler/Invalid_for-in_initializer +tags: + - Error + - JavaScript + - Strict Mode + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Invalid_for-in_initializer +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: for-in loop head declarations may not have initializers (Firefox) + +SyntaxError: for-in loop variable declaration may not have an initializer. (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}} nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a>.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der Kopf einer <a href="/de/docs/Web/JavaScript/Reference/Statements/for...in"> for...in</a> Schleife enthält einen Initialisierungsausdruck. Das ist, wenn eine Variable deklariert und mit einem Wert initialisiert wird (<code>for(var i = 0 in obj)</code>). Ohne Strict Mode wird die Initialisierung still ignoriert und verhält sich wie <code>for(var i in obj)</code>. Im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a> wird ein <code>SyntaxError</code> erzeugt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Das Beispiel erzeugt einen <code>SyntaxError</code>:</p> + +<pre class="brush: js example-bad">"use strict"; + +var obj = {a: 1, b: 2, c: 3 }; + +for (var i = 0 in obj) { + console.log(obj[i]); +} + +// SyntaxError: for-in loop head declarations may not have initializers +</pre> + +<h3 id="Valide_for-in_Schleife">Valide for-in Schleife</h3> + +<p>Man kann die Initialisierung (<code>i = 0</code>) im Kopf der for-in Schleife entfernen.</p> + +<pre class="brush: js example-good">"use strict"; + +var obj = {a: 1, b: 2, c: 3 }; + +for (var i in obj) { + console.log(obj[i]); +} +</pre> + +<h3 id="Array_Iteration">Array Iteration</h3> + +<p>Die for...in Schleife <a href="/de/docs/Web/JavaScript/Reference/Statements/for...in#Array_Iteration_und_for...in">sollte nicht für Array Iterationen benutzt werden</a>. Zum Iterieren von durch ein {{jsxref("Array")}} sollte eine <code><a href="/de/docs/Web/JavaScript/Reference/Statements/for">for</a></code> Schleife statt einer <code>for-in</code> Schleife benutzt werden. Die <code>for</code> Schleife erlaubt es dann auch eine Initialisierung vorzunehmen:</p> + +<pre class="brush: js example-good">var arr = [ "a", "b", "c" ] + +for (var i = 2; i < arr.length; i++) { + console.log(arr[i]); +} + +// "c"</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></code></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code> – ebenfalls keine Initialisierung erlaubt (im Strict und normalen Mode).</li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/for">for</a></code> – Präferiert für das Iterieren über ein Array. Erlaubt das Initialisieren.</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/invalid_for-of_initializer/index.html b/files/de/web/javascript/reference/errors/invalid_for-of_initializer/index.html new file mode 100644 index 0000000000..3270387357 --- /dev/null +++ b/files/de/web/javascript/reference/errors/invalid_for-of_initializer/index.html @@ -0,0 +1,63 @@ +--- +title: >- + SyntaxError: a declaration in the head of a for-of loop can't have an + initializer +slug: Web/JavaScript/Reference/Fehler/Invalid_for-of_initializer +tags: + - Error + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Invalid_for-of_initializer +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: a declaration in the head of a for-of loop can't have an initializer (Firefox) + +SyntaxError: for-of loop variable declaration may not have an initializer. (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_falsch_gelaufen_ist">Was falsch gelaufen ist?</h2> + +<p>Der Kopf einer <a href="/de/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a> Schleife enthält einen Initialisierungsausdruck. Das ist eine Variable die deklariert und initialisiert wird |<code>for (var i = 0 of iterable)</code>|. Dieses ist nicht erlaubt in for...of Schleifen. Manchmal ist eine <code><a href="/de/docs/Web/JavaScript/Reference/Statements/for">for</a></code> Schleife gemeint, die eine Initialisierung erlaubt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_valide_for...of_Schleife">Nicht valide <code>for...of</code> Schleife</h3> + +<pre class="brush: js example-bad">let iterable = [10, 20, 30]; + +for (let value = 50 of iterable) { + console.log(value); +} + +// SyntaxError: a declaration in the head of a for-of loop can't +// have an initializer</pre> + +<h3 id="Valide_for...of_Schleife">Valide <code>for...of</code> Schleife</h3> + +<p>Man muss die Initialisierung (<code>value = 50</code>) im Kopf der <code>for...of</code> Schleife entfernen. Wenn 50 als Offset gedacht ist, kann man eine Addition in den Körper der Schleife verschieben, wie im folgenden Beispiel:</p> + +<pre class="brush: js example-good">let iterable = [10, 20, 30]; + +for (let value of iterable) { + value += 50; + console.log(value); +} +// 60 +// 70 +// 80 +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></code> – Verbietet ebenfalls eine Initialisierung im Strict Mode (<a href="/de/docs/Web/JavaScript/Reference/Errors/Invalid_for-in_initializer">SyntaxError: for-in loop head declarations may not have initializers</a>)</li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/for">for</a></code> – Erlaubt eine Initialisierung beim Iterieren.</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.html b/files/de/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.html new file mode 100644 index 0000000000..771838b428 --- /dev/null +++ b/files/de/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.html @@ -0,0 +1,62 @@ +--- +title: 'TypeError: invalid ''instanceof'' operand ''x''' +slug: Web/JavaScript/Reference/Fehler/invalid_right_hand_side_instanceof_operand +tags: + - Error + - Errors + - JavaScript + - Reference + - TypeError +translation_of: Web/JavaScript/Reference/Errors/invalid_right_hand_side_instanceof_operand +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: invalid 'instanceof' operand "x" (Firefox) +TypeError: "x" is not a function (Firefox) +TypeError: Right-hand side of 'instanceof' is not an object (Chrome) +TypeError: Right-hand side of 'instanceof' is not callable (Chrome)</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der <a href="/de/docs/Web/JavaScript/Reference/Operators/instanceof"><code>instanceof</code> Operator</a> erwartet als rechten Operand einen Konstruktorobjekt, z. B. ein Objekt, welches eine <code>prototype</code> Eigenschaft hat und aufrufbar ist.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js example-bad">"test" instanceof ""; // TypeError: invalid 'instanceof' operand "" +42 instanceof 0; // TypeError: invalid 'instanceof' operand 0 + +function Foo() {} +var f = Foo(); // Foo() is called and returns undefined +var x = new Foo(); + +x instanceof f; // TypeError: invalid 'instanceof' operand f +x instanceof x; // TypeError: x is not a function +</pre> + +<p>Um diesen Fehler zu beheben, kann entweder der <a href="/de/docs/Web/JavaScript/Reference/Operators/instanceof"><code>instanceof</code> Operator</a> durch einen <a href="/de/docs/Web/JavaScript/Reference/Operators/typeof"><code>typeof</code> Operator</a> ersetzt werden, oder man muss sicher stellen, dass ein Funktionsname statt einem Resultat seines Aufrufes benutzt werden.</p> + +<pre class="brush: js example-good">typeof "test" == "string"; // true +typeof 42 == "number" // true + +function Foo() {} +var f = Foo; // Do not call Foo. +var x = new Foo(); + +x instanceof f; // true +x instanceof Foo; // true +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/instanceof"><code>instanceof</code> Operator</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/typeof"><code>typeof</code> Operator</a></li> +</ul> + +<p> </p> diff --git a/files/de/web/javascript/reference/errors/is_not_iterable/index.html b/files/de/web/javascript/reference/errors/is_not_iterable/index.html new file mode 100644 index 0000000000..21460882c7 --- /dev/null +++ b/files/de/web/javascript/reference/errors/is_not_iterable/index.html @@ -0,0 +1,103 @@ +--- +title: 'TypeError: ''x'' is not iterable' +slug: Web/JavaScript/Reference/Fehler/is_not_iterable +tags: + - Error + - JavaScript + - Reference + - TypeError +translation_of: Web/JavaScript/Reference/Errors/is_not_iterable +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: 'x' is not iterable (Firefox, Chrome) +TypeError: 'x' is not a function or its return value is not iterable (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der Wert, welcher auf der rechten Seite von <a href="/de/docs/Web/JavaScript/Guide/Loops_and_iteration#for...of_statement">for…of</a> oder als Argument einer Funktion wie {{jsxref("Promise.all")}} oder {{jsxref("TypedArray.from")}} ist kein <a href="/de/docs/Web/JavaScript/Reference/Iteration_protocols">iterierbares Objekt</a>. Ein iterierbares Objekt kann vom Standardtypen wie {{jsxref("Array")}}, {{jsxref("String")}} oder {{jsxref("Map")}} sein oder ein Objekt, welches das <a href="/de/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol">iterable Protokoll</a> implementiert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Über_Objekteigenschaften_iterieren">Über Objekteigenschaften iterieren</h3> + +<p>In JavaScript sind {{jsxref("Object", "Objekte")}} nicht iterierbar, außer sie implementieren das <a href="/de/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol">iterable Protokoll</a>. Demnach kann man <a href="/de/docs/Web/JavaScript/Guide/Loops_and_iteration#for...of_statement">for…of</a> nicht für das Iterieren von Objekteigenschaften benutzen.</p> + +<pre class="brush: js example-bad">var obj = { 'France': 'Paris', 'England': 'London' }; +for (let p of obj) { // TypeError: obj is not iterable + // … +} +</pre> + +<p>Stattdessen kann man {{jsxref("Object.keys")}} oder {{jsxref("Object.entries")}} benutzen, um über die Eigenschaften oder Einträge zu iterieren.</p> + +<pre class="brush: js example-good">var obj = { 'France': 'Paris', 'England': 'London' }; +// Iterate over the property names: +for (let country of obj.keys()) { + var capital = obj[country]; + console.log(country, capital); +} + +for (const [country, capital] of obj.entries()) + console.log(country, capital); +</pre> + +<p>Eine andere Option ist in diesem Fall der Einsatz einer {{jsxref("Map")}}:</p> + +<pre class="brush: js example-good">var map = new Map; +map.set('France', 'Paris'); +map.set('England', 'London'); +// Iterate over the property names: +for (let country of map.keys()) { + let capital = map[country]; + console.log(country, capital); +} + +for (let capital of map.values()) + console.log(capital); + +for (const [country, capital] of map.entries()) + console.log(country, capital); +</pre> + +<h3 id="Über_einen_Generator_iterieren">Über einen Generator iterieren</h3> + +<p><a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators">Generatoren</a> sind Funktionen welche aufgerufen werden, um ein iterierbares Objekt zu produzieren.</p> + +<pre class="brush: js example-bad">function* generate(a, b) { + yield a; + yield b; +} + +for (let x of generate) // TypeError: generate is not iterable + console.log(x); +</pre> + +<p>Wenn dieser nicht aufgerufen wird, ist das korrespondierende {{jsxref("Function")}} Objekt des Generators aufrufbar, aber nicht iterierbar. Aufrufen des Generators Produziert ein iterierbares Objekt, welche über die Werte iteriert, die während der Ausführung des Generators zurückgegeben werden.</p> + +<pre class="brush: js example-good">function* generate(a, b) { + yield a; + yield b; +} + +for (let x of generate(1,2)) + console.log(x); +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol">Iterable Protokoll</a></li> + <li>{{jsxref("Object.keys")}}</li> + <li>{{jsxref("Object.entries")}}</li> + <li>{{jsxref("Map")}}</li> + <li><a href="/de/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators">Generatoren</a></li> + <li><a href="/de/docs/Web/JavaScript/Guide/Loops_and_iteration#for...of_statement">for…of</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/json_bad_parse/index.html b/files/de/web/javascript/reference/errors/json_bad_parse/index.html new file mode 100644 index 0000000000..0aa5e6bdae --- /dev/null +++ b/files/de/web/javascript/reference/errors/json_bad_parse/index.html @@ -0,0 +1,112 @@ +--- +title: 'SyntaxError: JSON.parse: bad parsing' +slug: Web/JavaScript/Reference/Fehler/JSON_bad_parse +tags: + - Errors + - JSON + - JavaScript + - Method + - Property + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/JSON_bad_parse +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: JSON.parse: unterminated string literal +SyntaxError: JSON.parse: bad control character in string literal +SyntaxError: JSON.parse: bad character in string literal +SyntaxError: JSON.parse: bad Unicode escape +SyntaxError: JSON.parse: bad escape character +SyntaxError: JSON.parse: unterminated string +SyntaxError: JSON.parse: no number after minus sign +SyntaxError: JSON.parse: unexpected non-digit +SyntaxError: JSON.parse: missing digits after decimal point +SyntaxError: JSON.parse: unterminated fractional number +SyntaxError: JSON.parse: missing digits after exponent indicator +SyntaxError: JSON.parse: missing digits after exponent sign +SyntaxError: JSON.parse: exponent part is missing a number +SyntaxError: JSON.parse: unexpected end of data +SyntaxError: JSON.parse: unexpected keyword +SyntaxError: JSON.parse: unexpected character +SyntaxError: JSON.parse: end of data while reading object contents +SyntaxError: JSON.parse: expected property name or '}' +SyntaxError: JSON.parse: end of data when ',' or ']' was expected +SyntaxError: JSON.parse: expected ',' or ']' after array element +SyntaxError: JSON.parse: end of data when property name was expected +SyntaxError: JSON.parse: expected double-quoted property name +SyntaxError: JSON.parse: end of data after property name when ':' was expected +SyntaxError: JSON.parse: expected ':' after property name in object +SyntaxError: JSON.parse: end of data after property value in object +SyntaxError: JSON.parse: expected ',' or '}' after property value in object +SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal +SyntaxError: JSON.parse: property names must be double-quoted strings +SyntaxError: JSON.parse: expected property name or '}' +SyntaxError: JSON.parse: unexpected character +SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>{{jsxref("JSON.parse()")}} übersetzt einen String zu JSON. Dieser String muss eine gültiges JSON enthalten. Ist die Syntax fehlerhaft, wird dieser Error ausgegeben.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="JSON.parse()_erlaubt_keine_angehängten_Kommata"><code>JSON.parse()</code> erlaubt keine angehängten Kommata</h3> + +<p>Beide Zeilen werden einen SyntaxError erzeugen:</p> + +<pre class="brush: js example-bad">JSON.parse('[1, 2, 3, 4,]'); +JSON.parse('{"foo": 1,}'); +// SyntaxError JSON.parse: unexpected character +// at line 1 column 14 of the JSON data +</pre> + +<p>Das letzte trennende Komma muss in JSON vermieden werden:</p> + +<pre class="brush: js example-good">JSON.parse('[1, 2, 3, 4]'); +JSON.parse('{"foo": 1}');</pre> + +<h3 id="Eigenschaftsnamen_müssen_Strings_mit_doppelten_Anführungszeichen_sein">Eigenschaftsnamen müssen Strings mit doppelten Anführungszeichen sein</h3> + +<p>Man kann keine einfachen Anführungszeichen für Eigenschaften benutzen (wie 'foo').</p> + +<pre class="brush: js example-bad">JSON.parse("{'foo': 1}"); +// SyntaxError: JSON.parse: expected property name or '}' +// at line 1 column 2 of the JSON data</pre> + +<p>Stattdessen muss "foo" benutzt werden:</p> + +<pre class="brush: js example-good">JSON.parse('{"foo": 1}');</pre> + +<h3 id="Führende_Nullen_und_Dezimalpunkte">Führende Nullen und Dezimalpunkte</h3> + +<p>Man kann keine führenden Nullen (wie 01) benutzen. Nach Dezimalpunkten muss mindestens eine Stelle stehen.</p> + +<pre class="brush: js example-bad">JSON.parse('{"foo": 01}'); +// SyntaxError: JSON.parse: expected ',' or '}' after property value +// in object at line 1 column 2 of the JSON data + +JSON.parse('{"foo": 1.}'); +// SyntaxError: JSON.parse: unterminated fractional number +// at line 1 column 2 of the JSON data +</pre> + +<p>Stattdessen schreibe man nur 1, ohne eine Null (also 1, statt 01) und nutze mindestens eine Ziffer nach dem Dezimalpunkt:</p> + +<pre class="brush: js example-good">JSON.parse('{"foo": 1}'); +JSON.parse('{"foo": 1.0}'); +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("JSON")}}</li> + <li>{{jsxref("JSON.parse()")}}</li> + <li>{{jsxref("JSON.stringify()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/malformed_formal_parameter/index.html b/files/de/web/javascript/reference/errors/malformed_formal_parameter/index.html new file mode 100644 index 0000000000..65a89bb84a --- /dev/null +++ b/files/de/web/javascript/reference/errors/malformed_formal_parameter/index.html @@ -0,0 +1,61 @@ +--- +title: 'SyntaxError: Malformed formal parameter' +slug: Web/JavaScript/Reference/Fehler/Malformed_formal_parameter +tags: + - Error + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Malformed_formal_parameter +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: malformed formal parameter (Firefox) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es existiert ein <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Function">Function()</a></code> Konstruktor mit mindestend zwei übergebenen Parametern im Quelltext. Der letzte Parameter ist der Quelltext für die neu zu erstellende Funktion. Der ganze Rest bildet die liste der Parameter der neu zu erstellenden Funktion.</p> + +<p>Die Liste der Parameter ist manchmal nicht valide. Das kann passieren, wenn versehendlich ein Schlüsselword, wie <code>if</code> oder <code>var</code>, für die namen der Parameter verwendet werden. Ein andere Grund kann eine falsche Interpunktion in der Argumentenliste verwendet wird. Auch ein falscher Wert wie eine Zahl oder ein Objekt kann die Ursache sein.</p> + +<h2 id="OK_das_löst_mein_Problem._Aber_warum_hast_du_das_nicht_sofort_gesagt">OK, das löst mein Problem. Aber warum hast du das nicht sofort gesagt?</h2> + +<p><span id="result_box" lang="de"><span>Zugegeben, die</span> <span>Formulierung</span> <span>in der Fehlermeldung </span> <span>ist etwas</span> <span>seltsam.</span> </span> <span id="result_box" lang="de"> <span>"</span><span>formal</span><span> parameter</span><span>"</span> <span>ist</span> <span>eine andere Art</span> <span>"</span><span>Funktionsargument</span><span>" </span> oder "Funktionsparameter" <span>zu sagen</span><span>. </span></span><span id="result_box" lang="de"><span>Und wir</span> <span>verwenden das Wort</span> <span>"</span><span>malformed</span><span>"</span><span>, weil alle</span> <span>Firefox</span><span>-Ingenieure</span> sehr große Fans des<span> Romans </span><span>Gothic</span> <span>Horror</span><span> sind.</span></span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Invalide_Fälle">Invalide Fälle</h3> + +<pre class="brush: js example-bad">var f = Function('x y', 'return x + y;'); +// SyntaxError (missing a comma) + +var f = Function('x,', 'return x;'); +// SyntaxError (extraneous comma) + +var f = Function(37, "alert('OK')"); +// SyntaxError (numbers can't be argument names) +</pre> + +<h3 id="Valide_Fälle">Valide Fälle</h3> + +<pre class="brush: js example-good">var f = Function('x, y', 'return x + y;'); // correctly punctuated + +var f = Function('x', "return x;'); + +// if you can, avoid using Function - this is much faster +var f = function(x) { return x; }; +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Function">Function()</a></code></li> + <li><a href="/de/docs/Web/JavaScript/Guide/Functions">Über Funktionen</a></li> + <li><a href="https://www.gutenberg.org/ebooks/84"><em>Frankenstein</em> by Mary Wollstonecraft Shelley, voller E-Text</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/malformed_uri/index.html b/files/de/web/javascript/reference/errors/malformed_uri/index.html new file mode 100644 index 0000000000..cf831aa4a6 --- /dev/null +++ b/files/de/web/javascript/reference/errors/malformed_uri/index.html @@ -0,0 +1,66 @@ +--- +title: 'URIError: malformed URI sequence' +slug: Web/JavaScript/Reference/Fehler/Malformed_URI +tags: + - Error + - Errors + - JavaScript + - URIError +translation_of: Web/JavaScript/Reference/Errors/Malformed_URI +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">URIError: malformed URI sequence (Firefox) +URIError: URI malformed (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("URIError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Das URI-Kodieren oder -Dekodieren war nicht erfolgreich. Ein gegebenenes Argument der {{jsxref("decodeURI")}}-, {{jsxref("encodeURI")}}-, {{jsxref("encodeURIComponent")}}-, oder {{jsxref("decodeURIComponent")}}-Funktion ist nicht valide, wodurch die Funktion nicht richtig Kodieren oder Dekodieren kann.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Kodieren">Kodieren</h3> + +<p>Kodieren ersetzt bestimmte Zeichen durch eine Sequenz von einem, zwei, drei oder vier maskierten Zeichen, welche der UTF-8 Kodierung des Zeichens entsprechen. Ein {{jsxref("URIError")}} wird erzeugt, wenn versucht wird ein Zeichen zu kodieren, welches kein Teil des high-low-Paares ist, zum Beispiel:</p> + +<pre class="brush: js example-bad">encodeURI('\uD800'); +// "URIError: malformed URI sequence" + +encodeURI('\uDFFF'); +// "URIError: malformed URI sequence" +</pre> + +<p>Ein high-low Paar ist ok. Zum Beispiel:</p> + +<pre class="brush: js example-good">encodeURI('\uD800\uDFFF'); +// "%F0%90%8F%BF"</pre> + +<h3 id="Dekodieren">Dekodieren</h3> + +<p>Dekodieren ersetzt eine Sequenz maskierter Zeichen in einer URI-Komponente mit einem Zeichen, welches dieses repräsentiert. Wenn es kein solches Zeichen gibt, wird ein Fehler erzeugt:</p> + +<pre class="brush: js example-bad">decodeURIComponent('%E0%A4%A'); +// "URIError: malformed URI sequence" +</pre> + +<p>Mit richiger Eingabe sollte es wie folgendermaßen aussehen:</p> + +<pre class="brush: js example-good">decodeURIComponent('JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B'); +// "JavaScript_шеллы"</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("URIError")}}</li> + <li>{{jsxref("decodeURI")}}</li> + <li>{{jsxref("encodeURI")}}</li> + <li>{{jsxref("encodeURIComponent")}}</li> + <li>{{jsxref("decodeURIComponent")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_bracket_after_list/index.html b/files/de/web/javascript/reference/errors/missing_bracket_after_list/index.html new file mode 100644 index 0000000000..b5fe14ae14 --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_bracket_after_list/index.html @@ -0,0 +1,56 @@ +--- +title: 'SyntaxError: missing ] after element list' +slug: Web/JavaScript/Reference/Fehler/Missing_bracket_after_list +tags: + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_bracket_after_list +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing ] after element list +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der Syntax der Array-Initialisierung enthält einen Fehler. Wahrscheinlich fehlt eine schließende eckige Klammer ("<code>]</code>") oder ein Komma ("<code>,</code>").</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Unvollständige_Arrayinitialisierung">Unvollständige Arrayinitialisierung</h3> + +<pre class="brush: js example-bad">var list = [1, 2, + +var instruments = [ + 'Ukulele', + 'Guitar', + 'Piano' +}; + +var data = [{foo: 'bar'} {bar: 'foo'}]; +</pre> + +<p>Richtig wäre:</p> + +<pre class="brush: js example-good">var list = [1, 2]; + +var instruments = [ + 'Ukulele', + 'Guitar', + 'Piano' +]; + +var data = [{foo: 'bar'}, {bar: 'foo'}];</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_colon_after_property_id/index.html b/files/de/web/javascript/reference/errors/missing_colon_after_property_id/index.html new file mode 100644 index 0000000000..26d515a018 --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_colon_after_property_id/index.html @@ -0,0 +1,77 @@ +--- +title: 'SyntaxError: missing : after property id' +slug: Web/JavaScript/Reference/Fehler/Missing_colon_after_property_id +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing : after property id +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Wenn Objekte mit der <a href="/de/docs/Web/JavaScript/Reference/Operators/Object_initializer">Objektinitialisierungs</a>-Syntax erstellt werden, wird ein (<code>:</code>) eingesetzt, um bei Eiegenschaften Schlüssel und Werte zu trennen.</p> + +<pre class="brush: js">var obj = { propertyKey: 'value' }; +</pre> + +<h2 id="Examples">Examples</h2> + +<h3 id="Doppelpunkt_vs._Gleichzeichen">Doppelpunkt vs. Gleichzeichen</h3> + +<p>Der Code funktioniert nicht, weil das Gleichzeichen nicht in dieser Form in der Objektinitialisierungs-Syntax genutzt werden kann.</p> + +<pre class="brush: js example-bad">var obj = { propertyKey = 'value' }; +// SyntaxError: missing : after property id +</pre> + +<p>Richtig währe der Einsatz eines Doppelpunktes oder der Einsatz von eckigen Klammern, um eine Eigenschaft nach dem erstellen des Objektes zuzuweisen.</p> + +<pre class="brush: js example-good">var obj = { propertyKey: 'value' }; + +// or alternatively + +var obj = { }; +obj['propertyKey'] = 'value'; +</pre> + +<h3 id="Leere_Eigenschaften">Leere Eigenschaften</h3> + +<p>Man kann nicht wie im Beispiel leere Eigenschaften erzeugen:</p> + +<pre class="brush: js example-bad">var obj = { propertyKey; }; +// SyntaxError: missing : after property id +</pre> + +<p>Wenn eine Eigenschaft ohne Wert definiert werden soll, muss {{jsxref("null")}} als Wert genutzt werden.</p> + +<pre class="brush: js example-good">var obj = { propertyKey: null };</pre> + +<h3 id="Berechnete_Eigenschaften">Berechnete Eigenschaften</h3> + +<p>Wenn ein Eigenschaftsname aus einem Ausdruck berechnet wird, müssen eckige Klammern genutzt werden. Anderfalls kann der Eigenschaftname nicht errechnet werden:</p> + +<pre class="brush: js example-bad">var obj = { 'b'+'ar': 'foo' }; +// SyntaxError: missing : after property id +</pre> + +<p>Man muss den Ausdruck in <code>[]</code> setzen:</p> + +<pre class="brush: js example-good">var obj = { ['b'+'ar']: 'foo' };</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Object_initializer">Objektinitialisierung</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_curly_after_function_body/index.html b/files/de/web/javascript/reference/errors/missing_curly_after_function_body/index.html new file mode 100644 index 0000000000..b5e0239a2f --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_curly_after_function_body/index.html @@ -0,0 +1,67 @@ +--- +title: 'SyntaxError: missing } after function body' +slug: Web/JavaScript/Reference/Fehler/Missing_curly_after_function_body +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing } after function body +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt einen Syntaxfehler irgendwo beim erstellen von Funktionen. Man sollte prüfen, ob alle runden und geschweiften Klammern in der richtigen Reihenfolge sind. Einrückung und Formatierung des Codes hilft dabei den Fehler zu erkennen.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Schließende_geschweifte_Klammer_vergessen">Schließende geschweifte Klammer vergessen</h3> + +<p>Oftmals fehlt eine geschweifte Klammer im Funktionsocde:</p> + +<pre class="brush: js example-bad">var charge = function() { + if (sunny) { + useSolarCells(); + } else { + promptBikeRide(); +}; +</pre> + +<p>Richtig wäre:</p> + +<pre class="brush: js example-good">var charge = function() { + if (sunny) { + useSolarCells(); + } else { + promptBikeRide(); + } +};</pre> + +<p>Es kann deutlich verwirrender sein, wenn {{Glossary("IIFE")}}, <a href="/de/docs/Web/JavaScript/Closures">Closures</a>, oder andere Konstrukte, die viele verschiedene Klammern benutzt, eingesetzt werden, wie zum Beispiel:</p> + +<pre class="brush: js example-bad">(function() { if (true) { return false; } ); +</pre> + +<p>Oftmals hilft verschiedenes Einrücken oder doppeltes Prüfen der Einrückung, um den Fehler zu finden.</p> + +<pre class="brush: js example-good">(function() { + if (true) { + return false; + } +});</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Guide/Functions">Funktionen</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_curly_after_property_list/index.html b/files/de/web/javascript/reference/errors/missing_curly_after_property_list/index.html new file mode 100644 index 0000000000..41a82a9158 --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_curly_after_property_list/index.html @@ -0,0 +1,51 @@ +--- +title: 'SyntaxError: missing } after property list' +slug: Web/JavaScript/Reference/Fehler/Missing_curly_after_property_list +tags: + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_property_list +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing } after property list +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt irgendwo in der <a href="/de/docs/Web/JavaScript/Reference/Operators/Object_initializer">Objektinitialisierungs</a>-Syntax einen Fehler. Es könnte ein vergessenes Komma sein oder eine vergessene geschweifte Klammer. Es muss auch geprüft werden, die Reihenfolge der schließenden runden und geschweiften Klammern richtig ist. Den Code richtig einzurücken und zu formatieren hilft bei der Suche nach dem Fehler.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Vergessenes_Komma">Vergessenes Komma</h3> + +<p>Häufig wird ein Komma bei der Objektinitialisierung vergessen:</p> + +<pre class="brush: js example-bad">var obj = { + a: 1, + b: { myProp: 2 } + c: 3 +}; +</pre> + +<p>Richtig wäre:</p> + +<pre class="brush: js example-good">var obj = { + a: 1, + b: { myProp: 2 }, + c: 3 +}; +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Object_initializer">Objektinitialisierer</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_formal_parameter/index.html b/files/de/web/javascript/reference/errors/missing_formal_parameter/index.html new file mode 100644 index 0000000000..19813f9c47 --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_formal_parameter/index.html @@ -0,0 +1,80 @@ +--- +title: 'SyntaxError: missing formal parameter' +slug: Web/JavaScript/Reference/Fehler/Missing_formal_parameter +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_formal_parameter +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing formal parameter (Firefox) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>"Formaler Parameter" ist eine andere Bezeichnung für Funktionsparameter. Einer Funktion fehlen valide Parameter. In der Deklaration einer Funktion müssen die Parameternamen {{Glossary("Identifier", "Bezeichner")}}, kein Wert einer Nummer, eines Strings oder eines Objektes. Deklarieren und Aufrufen von Funktionen sind zwei verschiedene Schritte. Deklarieren setzt Bezeichner als Parametername voraus und beim Ausführen (Aufrufen) der Funktion müssen Werte für die Funktion benutzt werden.</p> + +<p>In {{glossary("JavaScript")}} können Bezeichner nur alphanumerische Zeichen (und "$" und "_") enthalten und können nicht mit einer Zahl beginnen. Ein Bezeichner unterscheidet sich von einem String, weil der String Daten sind und der Bezeichner teil des Codes.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Funktionsparameter müssen Bezeichner beim erstellen der Funktion sein. Alle diese Funktionsdeklarationen schlagen fehl, wenn ein Wert als Parameter benutzt wird:</p> + +<pre class="brush: js example-bad highlight:[1,6,11]">function square(3) { + return number * number; +}; +// SyntaxError: missing formal parameter + +function greet("Howdy") { + return greeting; +}; +// SyntaxError: missing formal parameter + +function log({ obj: "value"}) { + console.log(arg) +}; +// SyntaxError: missing formal parameter +</pre> + +<p>Man muss einen Bezeichner für die Funktionsdeklarationen benutzen:</p> + +<pre class="brush: js example-good highlight:[1,5,9]">function square(number) { + return number * number; +}; + +function greet(greeting) { + return greeting; +}; + +function log(arg) { + console.log(arg) +};</pre> + +<p>Danach kann man die Funktionen mit beliebigen Argumentwerten aufrufen:</p> + +<pre class="brush: js">square(2); // 4 + +greet("Howdy"); // "Howdy" + +log({obj: "value"}); // Object { obj: "value" } +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>Andere Fehler, die etwas mit formalen Parametern zu tun haben: + <ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Errors/Malformed_formal_parameter">SyntaxError: Malformed formal parameter</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Errors/Redeclared_parameter">SyntaxError: redeclaration of formal parameter "x"</a></li> + </ul> + </li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_initializer_in_const/index.html b/files/de/web/javascript/reference/errors/missing_initializer_in_const/index.html new file mode 100644 index 0000000000..49db779546 --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_initializer_in_const/index.html @@ -0,0 +1,58 @@ +--- +title: 'SyntaxError: missing = in const declaration' +slug: Web/JavaScript/Reference/Fehler/Missing_initializer_in_const +tags: + - Error + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_initializer_in_const +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing = in const declaration (Firefox) +SyntaxError: Missing initializer in const declaration (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Eine Konstante ist ein Wert, der während der normalen Ausführung des Programmes nicht geändert werden kann. Ihr kann kein neuer Wert zugewiesen werden und can nicht neu deklariert werden. In JavaScript werden Konstanten mit dem <code><a href="/de/docs/Web/JavaScript/Reference/Statements/const">const</a></code> Schlüsselwort deklariert. Ein Initialwert für eine Konstante wird benötigt, was bedeutet, dass der Wert im gleichen Statement wie bei der Deklaration zugewiesen werden muss (was Sinn ergibt, weil der Wert später nicht mehr geändert werden kann).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Fehlender_Initialwert_bei_const">Fehlender Initialwert bei const</h3> + +<p>Anders wie bei <code>var</code> or <code>let</code>, muss man bei <code>const</code> Deklarationen einen Initialwert angeben. Folgendes erzeugt einen Fehler:</p> + +<pre class="brush: js example-bad">const COLUMNS; +// SyntaxError: missing = in const declaration</pre> + +<h3 id="Den_Fehler_beheben">Den Fehler beheben</h3> + +<p>Es gibt mehrere Möglichkeiten den Fehler zu beheben. Es muss geprüft werden, was mit der Konstanten erreicht werden soll.</p> + +<h4 id="Hinzufügen_eines_konstanten_Wertes">Hinzufügen eines konstanten Wertes</h4> + +<p>Der Wert muss im gleichen Statement wie die Deklaration spezifiziert werden:</p> + +<pre class="brush: js example-good">const COLUMNS = 80;</pre> + +<h4 id="const_let_oder_var"><code>const</code>, <code>let</code> oder <code>var</code>?</h4> + +<p>Es sollte kein <code>const</code> verwendet werden, wenn keine Konstante gemeint ist. Vielleicht ist eine Variable für den Block (<code><a href="/de/docs/Web/JavaScript/Reference/Statements/let">let</a></code>) oder eine global Variable (<a href="/de/docs/Web/JavaScript/Reference/Statements/var"><code>var</code></a>) gemeint. Beide benötigen keinen Initialwert.</p> + +<pre class="brush: js example-good">let columns; +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/const">const</a></code></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/let">let</a></code></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_name_after_dot_operator/index.html b/files/de/web/javascript/reference/errors/missing_name_after_dot_operator/index.html new file mode 100644 index 0000000000..cb79bdcc03 --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_name_after_dot_operator/index.html @@ -0,0 +1,68 @@ +--- +title: 'SyntaxError: missing name after . operator' +slug: Web/JavaScript/Reference/Fehler/Missing_name_after_dot_operator +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_name_after_dot_operator +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing name after . operator +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der Punktoperator (<code>.</code>) wird für den <a href="/de/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Zugriff auf Eigenschaften</a> genutzt. Man muss den Namen der Eigenschaft spezifizieren, auf den man zugreifen möchte. Um berechnete Eigenschaftsnamen zu benutzen muss statt dem Punkt eckige Klammern genutzt werden. Das erlaubt es einen Ausdruck zu berechnen. Manchmal möchte man Konkatenation stattdessen erreichen. Dafür wird ein Plusoperator (<code>+</code>) genutzt werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Zugriff_auf_Eigenschaften">Zugriff auf Eigenschaften</h3> + +<p><a href="/de/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Zugriff auf Eigenschaften</a> wird in JavaScript entweder mit einem Punkt oder eckigen Klammern erreicht, aber nicht beides. Eckige Klammern erlauben es auch Eigenschaftsnamen zu berechnen.</p> + +<pre class="brush: js example-bad">var obj = { foo: { bar: "baz", bar2: "baz2" } }; +var i = 2; + +obj.[foo].[bar] +// SyntaxError: missing name after . operator + +obj.foo."bar"+i; +// SyntaxError: missing name after . operator +</pre> + +<p>Um das Problem zu lösen, muss auf das Objekt wie folgt zugegriffen werden:</p> + +<pre class="brush: js example-good">obj.foo.bar; // "baz" +// or alternatively +obj["foo"]["bar"]; // "baz" + +// computed properties require square brackets +obj.foo["bar" + i]; // "baz2" +</pre> + +<h3 id="Zugriff_auf_Eigenschaften_vs._Konkatenation">Zugriff auf Eigenschaften vs. Konkatenation</h3> + +<p>Wenn man aus einer anderen Programmiersprache kommt (z. B. {{Glossary("PHP")}}), ist es einfach den Punktoperator (<code>.</code>) und den Konkatenationsoperator (<code>+</code>) zu vermischen.</p> + +<pre class="brush: js example-bad">console.log("Hello" . "world"); + +// SyntaxError: missing name after . operator</pre> + +<p>Stattdessen muss man das Pluszeichen für Konkatenation benutzen:</p> + +<pre class="brush: js example-good">console.log("Hello" + "World");</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Zugriff auf Eigenschaften</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.html b/files/de/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.html new file mode 100644 index 0000000000..a3da4b9edf --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.html @@ -0,0 +1,42 @@ +--- +title: 'SyntaxError: missing ) after argument list' +slug: Web/JavaScript/Reference/Fehler/Missing_parenthesis_after_argument_list +tags: + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_argument_list +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing ) after argument list +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt einen Fehler mit der Art wie die Funktion aufgerufen wird. Es kann sich hier zum Beispiel um einen Tippfehler, einem fehlenden Operator oder einen nicht richtig abgeschlossenen String handeln. </p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Bei einem fehlenden "+" Operator, um zwei Strings zu konkatinieren,erwartet JavaScript , dass nur <code>"PI: " der Parameter </code>für die "log" Funktion ist. Darum sollte danach die Funktion mit einer abschliessenden Klammer abgeschlossen werden. </p> + +<pre class="brush: js example-bad">console.log("PI: " Math.PI); +// SyntaxError: missing ) after argument list +</pre> + +<p>Man kann den Fehler korrigieren, indem man den "<code>+</code>" Operator hinzufügt:</p> + +<pre class="brush: js example-good">console.log("PI: " + Math.PI); +// "PI: 3.141592653589793"</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Guide/Functions">Functions</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_parenthesis_after_condition/index.html b/files/de/web/javascript/reference/errors/missing_parenthesis_after_condition/index.html new file mode 100644 index 0000000000..295428a5b9 --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_parenthesis_after_condition/index.html @@ -0,0 +1,70 @@ +--- +title: 'SyntaxError: missing ) after condition' +slug: Web/JavaScript/Reference/Fehler/Missing_parenthesis_after_condition +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_condition +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing ) after condition +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt einen Fehler beim schreiben einer <code><a href="/de/docs/Web/JavaScript/Reference/Statements/if...else">if</a></code> Bedingung. In jeder Programmiersprache benötigt man Fallunterscheidungen abhängig von Eingaben. Das if Statement führt ein Statement auf, wenn eine Bedingung true wird. In JavaScript muss diese Bedingung in runden Klammern nach dem <code>if</code> Schlüsselwort geschrieben werden, wie dieses:</p> + +<pre class="brush: js">if (condition) { + // do something if the condition is true +}</pre> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Es könnte nur ein Versehen sein, weshalb man alle runden Klammern im Code gründlich überprüfen sollte.</p> + +<pre class="brush: js example-bad">if (3 > Math.PI { + console.log("wait what?"); +} + +// SyntaxError: missing ) after condition +</pre> + +<p>Um das Problem zu beheben, muss eine schließende runde Klammer nach der Bedingung geschrieben werden.</p> + +<pre class="brush: js example-good">if (3 > Math.PI) { + console.log("wait what?"); +}</pre> + +<p>Wenn man aus einer anderen Programmiersprache kommt, passiert es schnell, dass Schlüsselwörter benutzt werden, die in JavaScript eine andere oder garkeine Bedeutung haben.</p> + +<pre class="brush: js example-bad">if (done is true) { + console.log("we are done!"); +} + +// SyntaxError: missing ) after condition +</pre> + +<p>Stattdessen muss die richtige <a href="/de/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Vergleichsoperation</a> benutzt werden. Zum Beispiel:</p> + +<pre class="brush: js example-good">if (done === true) { + console.log("we are done!"); +}</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/if...else">if...else</a></code></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Vergleichsoperatoren</a></li> + <li> + <p><a href="/de/docs/Learn/JavaScript/Building_blocks/conditionals">Entscheidungen im Code treffen — Bedingungen</a></p> + </li> +</ul> diff --git a/files/de/web/javascript/reference/errors/missing_semicolon_before_statement/index.html b/files/de/web/javascript/reference/errors/missing_semicolon_before_statement/index.html new file mode 100644 index 0000000000..dcdf35ed94 --- /dev/null +++ b/files/de/web/javascript/reference/errors/missing_semicolon_before_statement/index.html @@ -0,0 +1,67 @@ +--- +title: 'SyntaxError: missing ; before statement' +slug: Web/JavaScript/Reference/Fehler/Missing_semicolon_before_statement +tags: + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing ; before statement +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es fehlt irgendwo ein Semikolon (<code>;</code>). <a href="/de/docs/Web/JavaScript/Reference/Statements">JavaScript Statements</a> müssen durch ein Semikolon beendet werden. Einige Statements sind von der <a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">automatischen Semikolon Einfügung (ASI)</a> betroffen, aber in diesem Fall muss man ein Semikolon geliefert werden, damit JavaScript den Quelltext korrekt lesen kann.</p> + +<p>Meistens ist dieser Fehler eine Folge aus einem anderen Fehler, wie ein nicht escaptes Zeichen in einem String oder der falsche Einsatz von <code>var</code>. Es kann auch sein, dass man zu viele runde Klammern benutzt. Wenn dieser Fehler auftritt, sollte die Syntax gründlich geprüft werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_escapte_Strings">Nicht escapte Strings</h3> + +<p>Dieser Fehler kann leicht auftreten, wenn ein String nicht richtig escapt wird und die JavaScript-Umgebung schon das Ende eines Strings erwartet. Zum Beispiel:</p> + +<pre class="brush: js example-bad">var foo = 'Tom's bar'; +// SyntaxError: missing ; before statement</pre> + +<p>Man kann doppelte Anführungszeichen benutzen oder das Apostroph escapen:</p> + +<pre class="brush: js example-good">var foo = "Tom's bar"; +var foo = 'Tom\'s bar'; +</pre> + +<h3 id="Eigenschaften_mit_var_deklarieren">Eigenschaften mit var deklarieren</h3> + +<p>Man kann Eigenschaften eines Objektes oder Arrays nicht mit einem <code>var</code> deklarieren.</p> + +<pre class="brush: js example-bad">var obj = {}; +var obj.foo = 'hi'; // SyntaxError missing ; before statement + +var array = []; +var array[0] = 'there'; // SyntaxError missing ; before statement +</pre> + +<p>Stattdessen muss das <code>var</code> Schlüsselwort vermieden werden:</p> + +<pre class="brush: js example-good">var obj = {}; +obj.foo = 'hi'; + +var array = []; +array[0] = 'there'; +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">Automatische Semikolon Einfügung (ASI)</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Statements">JavaScript Statements</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/more_arguments_needed/index.html b/files/de/web/javascript/reference/errors/more_arguments_needed/index.html new file mode 100644 index 0000000000..3707c5446f --- /dev/null +++ b/files/de/web/javascript/reference/errors/more_arguments_needed/index.html @@ -0,0 +1,48 @@ +--- +title: 'TypeError: More arguments needed' +slug: Web/JavaScript/Reference/Fehler/More_arguments_needed +tags: + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/More_arguments_needed +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: Object.create requires more than 0 arguments +TypeError: Object.setPrototypeOf requires more than 1 argument +TypeError: Object.defineProperties requires more than 0 arguments +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es ist ein Fehler beim Aufrufen einer Funktion aufgetaucht. Es müssen mehr Argumente übergeben werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Die {{jsxref("Object.create()")}} Methode benötigt mindestens ein Argument und die {{jsxref("Object.setPrototypeOf()")}} Methode benötigt mindestens zwei Argumente:</p> + +<pre class="brush: js example-bad">var obj = Object.create(); +// TypeError: Object.create requires more than 0 arguments + +var obj = Object.setPrototypeOf({}); +// TypeError: Object.setPrototypeOf requires more than 1 argument +</pre> + +<p>Dieser Fehler kann behoben werden, indem {{jsxref("null")}} als Eigenschaft gesetzt wird:</p> + +<pre class="brush: js example-good">var obj = Object.create(null); + +var obj = Object.setPrototypeOf({}, null);</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Guide/Functions">Functions</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/negative_repetition_count/index.html b/files/de/web/javascript/reference/errors/negative_repetition_count/index.html new file mode 100644 index 0000000000..53c153453f --- /dev/null +++ b/files/de/web/javascript/reference/errors/negative_repetition_count/index.html @@ -0,0 +1,44 @@ +--- +title: 'RangeError: repeat count must be non-negative' +slug: Web/JavaScript/Reference/Fehler/Negative_repetition_count +tags: + - Errors + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Negative_repetition_count +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">RangeError: repeat count must be non-negative (Firefox) +RangeError: Invalid count value (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Die {{jsxref("String.prototype.repeat()")}} Methode wurde benutzt. Sie hat einen <code>count</code> Parameter welche die Anzahl der Wiederholungen des Strings angibt. Dieser muss zwischen 0 und kleiner positiv {{jsxref("Infinity")}} sein und kann nicht negativ sein. Das erlaubte Intervall kann wie folgt beschrieben werden: [0, +∞).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Falsche_Fälle">Falsche Fälle</h3> + +<pre class="brush: js example-bad">'abc'.repeat(-1); // RangeError </pre> + +<h3 id="Richtige_Fälle">Richtige Fälle</h3> + +<pre class="brush: js example-good">'abc'.repeat(0); // '' +'abc'.repeat(1); // 'abc' +'abc'.repeat(2); // 'abcabc' +'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer) +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.repeat()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/no_non-null_object/index.html b/files/de/web/javascript/reference/errors/no_non-null_object/index.html new file mode 100644 index 0000000000..a2c897c5cd --- /dev/null +++ b/files/de/web/javascript/reference/errors/no_non-null_object/index.html @@ -0,0 +1,66 @@ +--- +title: 'TypeError: "x" is not a non-null object' +slug: Web/JavaScript/Reference/Fehler/No_non-null_object +tags: + - Error + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/No_non-null_object +--- +<div>{{JSSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: "x" is not a non-null object (Firefox) +TypeError: Property description must be an object: "x" (Chrome) +TypeError: Invalid value used in weak set (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Ein Objekt wird erwartete aber nicht übergeben. {{jsxref("null")}} ist kein Objekt und funktioniert nicht. In dieser Situation wird ein normales Objekt erwartet.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Eigehscgaftsbeschreibung_erwartet">Eigehscgaftsbeschreibung erwartet</h3> + +<p>Wenn Methoden wie {{jsxref("Object.create()")}} oder {{jsxref("Object.defineProperty()")}} und {{jsxref("Object.defineProperties()")}} eingesetzt werden, wird als optionale Beschreibung ein Beschreibungsobjekt erwartet. Wenn kein Objekt übergeben wird (z. B. eine Zahl), wird ein Fehler erzeugt:</p> + +<pre class="brush: js example-bad">Object.defineProperty({}, 'key', 1); +// TypeError: 1 is not a non-null object + +Object.defineProperty({}, 'key', null); +// TypeError: null is not a non-null object +</pre> + +<p>Ein valides Beschreibungsobjekt kann wie folgendes aussehen:</p> + +<pre class="brush: js example-good">Object.defineProperty({}, 'key', { value: 'foo', writable: false }); +</pre> + +<h3 id="WeakMap_und_WeakSet_Objekte_benötigen_Objektschlüssel"><code>WeakMap</code> und <code>WeakSet</code> Objekte benötigen Objektschlüssel</h3> + +<p>{{jsxref("WeakMap")}} und {{jsxref("WeakSet")}} Objekte speichern Objektschlüssel. Man kann keine anderen Schlüssel verwenden.</p> + +<pre class="brush: js example-bad">var ws = new WeakSet(); +ws.add('foo'); +// TypeError: "foo" is not a non-null object</pre> + +<p>Stattdessen sollte folgendes verwendet werden:</p> + +<pre class="brush: js example-good">ws.add({foo: 'bar'}); +ws.add(window); +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.create()")}}</li> + <li>{{jsxref("Object.defineProperty()")}}, {{jsxref("Object.defineProperties()")}}</li> + <li>{{jsxref("WeakMap")}}, {{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/no_properties/index.html b/files/de/web/javascript/reference/errors/no_properties/index.html new file mode 100644 index 0000000000..d5dc0328b6 --- /dev/null +++ b/files/de/web/javascript/reference/errors/no_properties/index.html @@ -0,0 +1,40 @@ +--- +title: 'TypeError: "x" has no properties' +slug: Web/JavaScript/Reference/Fehler/No_properties +tags: + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/No_properties +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: null has no properties +TypeError: undefined has no properties +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Weder {{jsxref("null")}} noch {{jsxref("undefined")}} besitzen Eigenschaften auf die man zugreifen könnte.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: js example-bad">null.foo; +// TypeError: null has no properties + +undefined.bar; +// TypeError: undefined has no properties +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("null")}}</li> + <li>{{jsxref("undefined")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/no_variable_name/index.html b/files/de/web/javascript/reference/errors/no_variable_name/index.html new file mode 100644 index 0000000000..a3b63df55d --- /dev/null +++ b/files/de/web/javascript/reference/errors/no_variable_name/index.html @@ -0,0 +1,84 @@ +--- +title: 'SyntaxError: missing variable name' +slug: Web/JavaScript/Reference/Fehler/No_variable_name +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/No_variable_name +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: missing variable name (Firefox) +SyntaxError: Unexpected token = (Chrome)</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Einer Variablen fehlt ein Name. Das wird zu einem {{jsxref("SyntaxError")}} im Code führen. Vermutlich ist ein Komma irgendwo falsch oder man kämpft mit einem Namen. Völlig verständlich! <span>Dinge zu benennen ist so schwer.</span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ein_Variablenname_fehlt">Ein Variablenname fehlt</h3> + +<pre class="brush: js example-bad">var = "foo"; +</pre> + +<p>Es ist schwer gute Variablennamen zu vergeben. Das geht allen so.</p> + +<pre class="brush: js example-good">var ohGodWhy = "foo";</pre> + +<h3 id="Reservierte_Schlüsselwörter_können_kein_Variablenname_sein">Reservierte Schlüsselwörter können kein Variablenname sein</h3> + +<p>Es gibt ein paar Namen, die <a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar#Schlüsselwörter">reservierte Schlüsselwörter</a> sind. Diese kann man nicht benutzen.</p> + +<pre class="brush: js example-bad">var debugger = "whoop"; +// SyntaxError: missing variable name +</pre> + +<h3 id="Deklarieren_von_mehreren_Variablen">Deklarieren von mehreren Variablen</h3> + +<p>Man muss beim Deklarieren von mehreren Variablen besonders auf Kommas aufpassen. Gibt es ein überflüssiges Komma? Wurde aus Versehen ein Komma statt eines Semikolons verwendet?</p> + +<pre class="brush: js example-bad">var x, y = "foo", +var x, = "foo" + +var first = document.getElementById('one'), +var second = document.getElementById('two'), + +// SyntaxError: missing variable name +</pre> + +<p>Die korrigierte Version:</p> + +<pre class="brush: js example-good">var x, y = "foo"; +var x = "foo"; + +var first = document.getElementById('one'); +var second = document.getElementById('two');</pre> + +<h3 id="Arrays">Arrays</h3> + +<p>{{jsxref("Array")}}-Literale in JavaScript benötigen eckige Klammern um die Werte. Folgendes funktioniert nicht:</p> + +<pre class="brush: js example-bad">var arr = 1,2,3,4,5; +// SyntaxError: missing variable name +</pre> + +<p>Richtig ist:</p> + +<pre class="brush: js example-good">var arr = [1,2,3,4,5];</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="http://wiki.c2.com/?GoodVariableNames">Gute Variablennamen</a></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li> + <li><a href="/de/docs/Web/JavaScript/Guide/Grammatik_und_Typen#Deklarationen">Variablendeklarationen im JavaScript Guide</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/non_configurable_array_element/index.html b/files/de/web/javascript/reference/errors/non_configurable_array_element/index.html new file mode 100644 index 0000000000..771f480dda --- /dev/null +++ b/files/de/web/javascript/reference/errors/non_configurable_array_element/index.html @@ -0,0 +1,83 @@ +--- +title: 'TypeError: can''t delete non-configurable array element' +slug: Web/JavaScript/Reference/Fehler/Non_configurable_array_element +tags: + - Error + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Non_configurable_array_element +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: can't delete non-configurable array element (Firefox) +TypeError: Cannot delete property '2' of [object Array] (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es wurde versucht die <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array/length#Verkürzung_eines_Arrays">Länge eines Arrays zu kürzen</a> obwohl eines der Arrayelemente nicht Konfigurierbar(<a href="/de/docs/Web/JavaScript/Data_structures#Properties">non-configurable</a>) ist. Beim Kürzen eines Arrays werden die Elemente hinter der neuen Länge gelöscht, was in dieser Situation nicht funktioniert.</p> + +<p>Das <code>configurable</code> Attribut kontrolliert, ob eine Eigenschaft von einem Objekt gelöscht werden kann und seine Attribute (anders als <code>writable</code>) geändert werden können.</p> + +<p>Eigenschaften von einem Objekt, dass von einem <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Array#Syntax">Array-Initialisierer</a> erstellt wurden, sind konfigurierbar. Immer, wenn zum Beispiel {{jsxref("Object.defineProperty()")}} eingesetzt wird, ist die Eigenschaft nicht ohne weiteres konfigurierbar.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_konfigurierbare_Eigenschaften_mit_Object.defineProperty_erstellen">Nicht konfigurierbare Eigenschaften mit <code>Object.defineProperty</code> erstellen</h3> + +<p>Die {{jsxref("Object.defineProperty()")}} Funktion erstellt nicht konfiguriertbare Eigenschaften wenn sie nicht extra als konfigurierbar spezifiziert sind.</p> + +<pre class="brush: js example-bad">var arr = []; +Object.defineProperty(arr, 0, {value: 0}); +Object.defineProperty(arr, 1, {value: "1"}); + +arr.length = 1; +// TypeError: can't delete non-configurable array element +</pre> + +<p>Die Elemente müssen als Konfigurierbar eingestellt werden, wenn das Array später im Quelltext gekürzt werden soll.</p> + +<pre class="brush: js example-good">var arr = []; +Object.defineProperty(arr, 0, {value: 0, configurable: true}); +Object.defineProperty(arr, 1, {value: "1", configurable: true}); + +arr.length = 1; +</pre> + +<h3 id="Ein_Array_versiegeln_(seal)">Ein Array versiegeln (<code>seal</code>)</h3> + +<p>Die {{jsxref("Object.seal()")}} Funktion markiert alle existirenden Elements als nicht Konfugurierbar.</p> + +<pre class="brush: js example-bad">var arr = [1,2,3]; +Object.seal(arr); + +arr.length = 1; +// TypeError: can't delete non-configurable array element +</pre> + +<p>Man muss den Aufruf von {{jsxref("Object.seal()")}} entfernen oder ein Kopie des Arrays machen. Im fall einer Kopie führt das Kürzen des kopierten Arrays zu keiner Änderung des Original Arrays.</p> + +<pre class="brush: js example-good">var arr = [1,2,3]; +Object.seal(arr); + +// Copy the initial array to shorten the copy +var copy = Array.from(arr); +copy.length = 1; +// arr.length == 3 +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Data_structures#Properties">[[Configurable]]</a></li> + <li>{{jsxref("Array.length")}}</li> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.seal()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/not_a_codepoint/index.html b/files/de/web/javascript/reference/errors/not_a_codepoint/index.html new file mode 100644 index 0000000000..8d72c3be4b --- /dev/null +++ b/files/de/web/javascript/reference/errors/not_a_codepoint/index.html @@ -0,0 +1,55 @@ +--- +title: 'RangeError: argument is not a valid code point' +slug: Web/JavaScript/Reference/Fehler/Not_a_codepoint +tags: + - Errors + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Not_a_codepoint +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">RangeError: {0} is not a valid code point (Firefox) +RangeError: Invalid code point {0} (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Die {{jsxref("String.fromCodePoint()")}} Methode erwartet gültige Codepoint.</p> + +<p>Ein <a href="https://de.wikipedia.org/wiki/Codepoint">Codepoint</a> ist ein Wert im Unicode Coderaum, der als Integer im Wertebereich zwischen <code>0</code> und <code>0x10FFFF liegt</code>.</p> + +<p>Die Verwendung von {{jsxref("NaN")}} , negativen Integern (<code>-1</code>), nicht Integern (<code>3.14</code>) und Werten die größer als <code>0x10FFFF</code> (<code>1114111</code>) sind, werden einen Fehler bei dieser Methode produzieren.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ungültige_Fälle">Ungültige Fälle</h3> + +<pre class="brush: js example-bad">String.fromCodePoint('_'); // RangeError +String.fromCodePoint(Infinity); // RangeError +String.fromCodePoint(-1); // RangeError +String.fromCodePoint(3.14); // RangeError +String.fromCodePoint(3e-2); // RangeError +String.fromCodePoint(NaN); // RangeError</pre> + +<h3 id="Gültige_Fälle">Gültige Fälle</h3> + +<pre class="brush: js example-good">String.fromCodePoint(42); // "*" +String.fromCodePoint(65, 90); // "AZ" +String.fromCodePoint(0x404); // "\u0404" +String.fromCodePoint(0x2F804); // "\uD87E\uDC04" +String.fromCodePoint(194564); // "\uD87E\uDC04" +String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07" +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/not_a_constructor/index.html b/files/de/web/javascript/reference/errors/not_a_constructor/index.html new file mode 100644 index 0000000000..42858cf706 --- /dev/null +++ b/files/de/web/javascript/reference/errors/not_a_constructor/index.html @@ -0,0 +1,97 @@ +--- +title: 'TypeError: "x" is not a constructor' +slug: Web/JavaScript/Reference/Fehler/Not_a_constructor +tags: + - Fehler + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Not_a_constructor +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: "x" is not a constructor + +TypeError: Math is not a constructor +TypeError: JSON is not a constructor +TypeError: Symbol is not a constructor +TypeError: Reflect is not a constructor +TypeError: Intl is not a constructor +TypeError: SIMD is not a constructor +TypeError: Atomics is not a constructor +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es wurde versucht auf ein Objekt oder eine Variable zuzugreifen welche kein Konstruktor ist. Mehr darüber, was ein Konstruktur ist, finden Sie unter {{Glossary("constructor")}} oder in der Beschreibung des <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> Operators</a>.</p> + +<p>Es gibt viele globale Objekte, wie {{jsxref("String")}} oder {{jsxref("Array")}}, welche mittels <code>new</code> erstellt werden können. Jedoch funktioniert das bei einigen Objekten nicht und deren Eigenschaften und Methoden sind statisch.</p> + +<p>Die folgenden Standard build-in Objekte sind keine Konstruktoren: {{jsxref("Math")}}, {{jsxref("JSON")}}, {{jsxref("Symbol")}}, {{jsxref("Reflect")}}, {{jsxref("Intl")}}, {{jsxref("SIMD")}}, {{jsxref("Atomics")}}.</p> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Statements/function*">Generelle Funktionen</a> können ebenso nicht als Konstruktor verwendet werden.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ungültige_Fälle">Ungültige Fälle</h3> + +<pre class="brush: js example-bad">var Car = 1; +new Car(); +// TypeError: Car is not a constructor + +new Math(); +// TypeError: Math is not a constructor + +new Symbol(); +// TypeError: Symbol is not a constructor + +function* f() {}; +var obj = new f; +// TypeError: f is not a constructor +</pre> + +<h3 id="Ein_car_Konstruktor">Ein car Konstruktor</h3> + +<p>Stellen Sie sich vor, Sie erstellen ein Objekt vom Typ vars. Sie wollen dieses Objekt als <code>Car</code> bezeichen und es soll Eigenschaften für make, model und year besitzt. Um dies zu erreichen, schreiben Sie die folgende Funktion:</p> + +<pre class="brush: js">function Car(make, model, year) { + this.make = make; + this.model = model; + this.year = year; +} +</pre> + +<p>Jetzt können Sie wie folgt ein Objekt mit dem Namen <code>mycar</code> erstellen:</p> + +<pre class="brush: js">var mycar = new Car('Eagle', 'Talon TSi', 1993);</pre> + +<h3 id="Promises">Promises</h3> + +<p>Bei Rückgabe eines Promises, welches sofort im Status resolved oder rejected ist, brauchen Sie kein neues Promise mit <em>new Promise(...)</em> erstellen und damit zu arbeiten. </p> + +<p>Folgendes ist nicht erlaubt (der <a href="/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm/Promise#Constructor">Promise Konstruktor</a> wird nicht korrekt aufgerufen) und wirft eine <code>TypeError: this is not a constructor</code> Exception.</p> + +<pre class="brush: js example-bad">return new Promise.resolve(true); +</pre> + +<p>Verwenden Sie stattdessen<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/resolve"> Promise.resolve()</a> oder die <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject">statische Methode Promise.reject()</a>:</p> + +<pre class="brush: js">// Das ist erlaubt, aber unnötig lang: +return new Promise((resolve, reject) => { resolve(true); }) + +// Alternative Verwendung der statische Methoden: +return Promise.resolve(true); +return Promise.reject(false); +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{Glossary("constructor","Konstruktor")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> Operator</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/not_a_function/index.html b/files/de/web/javascript/reference/errors/not_a_function/index.html new file mode 100644 index 0000000000..a8b66dff17 --- /dev/null +++ b/files/de/web/javascript/reference/errors/not_a_function/index.html @@ -0,0 +1,124 @@ +--- +title: 'TypeError: "x" is not a function' +slug: Web/JavaScript/Reference/Fehler/Not_a_function +tags: + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Not_a_function +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: "x" is not a function +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es wird versucht, ein Wert wie eine Funktion aufzurufen, da aber der Wert eigentlich keine Funktion ist, kommt es zu diesem Fehler. Manchmal erwartet das Programm, dass eine Funktion erstellt wird, was aber nicht der Fall ist.</p> + +<p>Vielleicht ist ein Tippfehler im Funktionsnamen. Manchmal besitzt das aufgerufene Objekt eine Funktion aber auch nicht. Zum Beispiel besitzen JavaScript Objekte keine <code>map</code> Funktion, aber JavaScript Arrays haben diese Funktion.</p> + +<p>Es gibt viele eingebaute Funktionen, die eine (Callback-) Funktion benötigen. Es muss eine Funktion bereitgestellt werden, damit diese Methoden normal funktionieren:</p> + +<ul> + <li>Wenn mit {{jsxref("Array")}} oder {{jsxref("TypedArray")}} Objekten gearbeitet wird: + <ul> + <li>{{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.forEach()")}}, {{jsxref("Array.prototype.map()")}}, {{jsxref("Array.prototype.filter()")}}, {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}}, {{jsxref("Array.prototype.find()")}}</li> + </ul> + </li> + <li>Wenn mit {{jsxref("Map")}} und {{jsxref("Set")}} Objekten gearbeitet wird: + <ul> + <li>{{jsxref("Map.prototype.forEach()")}} und {{jsxref("Set.prototype.forEach()")}}</li> + </ul> + </li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ein_Schreibfehler_im_Funktionsnamen">Ein Schreibfehler im Funktionsnamen</h3> + +<p>In diesem Fall passiert es viel zu oft, dass im Name ein Schreibfehler enthält:</p> + +<pre class="brush: js example-bad">var x = document.getElementByID('foo'); +// TypeError: document.getElementByID is not a function +</pre> + +<p>Der korrekte Funktionsname ist <code>getElementByI<strong>d</strong></code>:</p> + +<pre class="brush: js example-good">var x = document.getElementById('foo'); +</pre> + +<h3 id="Funktion_wird_auf_dem_falschen_Objekt_aufgerufen">Funktion wird auf dem falschen Objekt aufgerufen</h3> + +<p>Für bestimmte Methoden musst eine (callback) Funktion benutzt werden, die nur bei spezifizierten Objekten funktionieren. In diesem Beispiel wird {{jsxref("Array.prototype.map()")}} verwendet, welche nur mit {{jsxref("Array")}} Objekten funktioniert.</p> + +<pre class="brush: js example-bad">var obj = {a: 13, b: 37, c: 42}; + +obj.map(function(num) { + return num * 2; +}); + +// TypeError: "x" is not a function</pre> + +<p>Stattdessen muss ein Array verwendet werden:</p> + +<pre class="brush: js example-good">var numbers = [1, 4, 9]; + +numbers.map(function(num) { + return num * 2; +}); + +// Array [2, 8, 18] +</pre> + +<h3 id="Funktionen_teilen_einen_Namen_mit_einer_existierenden_Eigenschaft">Funktionen teilen einen Namen mit einer existierenden Eigenschaft</h3> + +<p>Manchmal, wenn eine Klasse geschrieben wird, haben eine Eigenschaft und eine Funktion den gleichen Namen. Nach dem Aufruf der Funktion denkt der Compiler, dass die Funktion nicht mehr existiert.</p> + +<pre class="brush: js example-bad">var Dog = function () { + this.age = 11; + this.color = "black"; + this.name = "Ralph"; + return this; +} + +Dog.prototype.name = function(name) { + this.name = name; + return this; +} + + +var myNewDog = new Dog(); +myNewDog.name("Cassidy"); //Uncaught TypeError: myNewDog.name is not a function +</pre> + +<p>Stattdessen kann ein anderer Eigenschaftsname benutzt werden:</p> + +<pre class="brush: js example-good">var Dog = function () { + this.age = 11; + this.color = "black"; + this.dogName = "Ralph"; //Using this.dogName instead of .name + return this; +} + +Dog.prototype.name = function(name) { + this.dogName = name; + return this; +} + + +var myNewDog = new Dog(); +myNewDog.name("Cassidy"); //Dog { age: 11, color: 'black', dogName: 'Cassidy' } +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Functions">Functions</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/not_defined/index.html b/files/de/web/javascript/reference/errors/not_defined/index.html new file mode 100644 index 0000000000..030c47536b --- /dev/null +++ b/files/de/web/javascript/reference/errors/not_defined/index.html @@ -0,0 +1,70 @@ +--- +title: 'ReferenceError: "x" is not defined' +slug: Web/JavaScript/Reference/Fehler/Not_defined +tags: + - Error + - JavaScript + - ReferenceError +translation_of: Web/JavaScript/Reference/Errors/Not_defined +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">ReferenceError: "x" is not defined +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("ReferenceError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt eine Referenz auf eine Variable, die nicht existiert. Diese Variable muss deklariert werden; oder man muss sicherstellen, dass sie im Skript zugänglich ist; oder sich im aktuellen {{Glossary("scope")}} befindet.</p> + +<div class="note"> +<p><strong>Hinweis:</strong> Wenn Sie eine Bibliothek nutzen (wie z.B. jQuery), stellen Sie sicher, dass diese tatsächlich geladen ist, bevor Sie auf dessen Variablen (z. B. "$") zugreifen. Schreiben Sie das {{HTMLElement("script")}} Element, welches die Bibliothek lädt vor den Code, der die Bibliothek verwendet.</p> +</div> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Variable_nicht_deklariert">Variable nicht deklariert</h3> + +<pre class="brush: js example-bad">foo.substring(1); // ReferenceError: foo is not defined +</pre> + +<p>Die "foo" Variable ist nirgends deklariert. Die Variable muss ein String sein, damit die Methode {{jsxref("String.prototype.substring()")}} funktioniert.</p> + +<pre class="brush: js example-good">var foo = "bar"; +foo.substring(1); // "ar"</pre> + +<h3 id="Falscher_Gültigkeitsbereich">Falscher Gültigkeitsbereich</h3> + +<p>Eine Variable muss im aktuellem Kontext verfügbar sein. Variablen, die innerhalb einer <a href="/de/docs/Web/JavaScript/Reference/Functions">Funktion</a> definiert sind, können nicht von außerhalb erreicht werden, da diese nur im Gültigkeitsbereich der Funktion existieren.</p> + +<pre class="brush: js example-bad">function numbers() { + var num1 = 2, + num2 = 3; + return num1 + num2; +} + +console.log(num1); // ReferenceError "num1" is not defined.</pre> + +<p>Wobei aus einer Methode kann man auf alle Variablen und Methoden zugreifen, die im gleichen Gültigkeitsbereich definiert worden sind. Kurz gesagt, eine Methode, die im globalen Gültigkeitsbereich definiert worden ist, kann auf alle Variablen zugreifen, die im globalen Gültigkeitsbereich definiert wurden.</p> + +<pre class="brush: js example-good">var num1 = 2, + num2 = 3; + +function numbers() { + return num1 + num2; +} + +console.log(numbers()); // 5</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{Glossary("Scope")}}</li> + <li><a href="/de/docs/Web/JavaScript/Guide/Grammatik_und_Typen#Deklarationen">Variablendeklaration im JavaScript Guide</a></li> + <li><a href="/de/docs/Web/JavaScript/Guide/Funktionen#Scopes_(G%C3%BCltigkeitsbereiche)_von_Funktionen">Methoden Gültigkeitsbereich im JavaScript Guide</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/precision_range/index.html b/files/de/web/javascript/reference/errors/precision_range/index.html new file mode 100644 index 0000000000..d03b4203c5 --- /dev/null +++ b/files/de/web/javascript/reference/errors/precision_range/index.html @@ -0,0 +1,96 @@ +--- +title: 'RangeError: precision is out of range' +slug: Web/JavaScript/Reference/Fehler/Precision_range +tags: + - Errors + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Precision_range +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">RangeError: precision {0} out of range (Firefox) +RangeError: toExponential() argument must be between 0 and 20 (Chrome) +RangeError: toFixed() digits argument must be between 0 and 20 (Chrome) +RangeError: toPrecision() argument must be between 1 and 21 (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Das übergebene Argument für die Genauigkeit ist, für einer der folgenden Funktionen, ausserhalb des gültigen Bereiches:</p> + +<ul> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> + +<p>Der gülitge Bereich für diese Methoden liegt im normal Fall zwischen 0 und 20 (oder 21). Wobei die ECMAScript Spezifikation erlaubt eine Erweiterung de Bereiches.</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Method</th> + <th scope="col">Firefox (SpiderMonkey)</th> + <th scope="col">Chrome, Opera (V8)</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{jsxref("Number.prototype.toExponential()")}}</td> + <td>0 bis 100</td> + <td>0 bis 20</td> + </tr> + <tr> + <td>{{jsxref("Number.prototype.toFixed()")}}</td> + <td>-20 bis100</td> + <td>0 bis 20</td> + </tr> + <tr> + <td>{{jsxref("Number.prototype.toPrecision()")}}</td> + <td>1 bis 100</td> + <td>1 bis 21</td> + </tr> + </tbody> +</table> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ungültige_Fälle">Ungültige Fälle</h3> + +<pre class="brush: js example-bad">77.1234.toExponential(-1); // RangeError +77.1234.toExponential(101); // RangeError + +2.34.toFixed(-100); // RangeError +2.34.toFixed(1001); // RangeError + +1234.5.toPrecision(-1); // RangeError +1234.5.toPrecision(101); // RangeError +</pre> + +<h3 id="Gültige_Fälle">Gültige Fälle</h3> + +<pre class="brush: js example-good">77.1234.toExponential(4); // 7.7123e+1 +77.1234.toExponential(2); // 7.71e+1 + +2.34.toFixed(1); // 2.3 +2.35.toFixed(1); // 2.4 (zu beachten ist, das in diesem Fall aufgerundet wird) + +5.123456.toPrecision(5); // 5.1235 +5.123456.toPrecision(2); // 5.1 +5.123456.toPrecision(1); // 5 +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/property_access_denied/index.html b/files/de/web/javascript/reference/errors/property_access_denied/index.html new file mode 100644 index 0000000000..d4feb4feb7 --- /dev/null +++ b/files/de/web/javascript/reference/errors/property_access_denied/index.html @@ -0,0 +1,47 @@ +--- +title: 'Error: Permission denied to access property "x"' +slug: Web/JavaScript/Reference/Fehler/Property_access_denied +tags: + - Error + - Errors + - JavaScript + - Security +translation_of: Web/JavaScript/Reference/Errors/Property_access_denied +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Error: Permission denied to access property "x" +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("Error")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p><span class="seoSummary">Es wurde versucht auf ein Objekt zuzugreifen, wofür man nicht ausreichend berechtig ist. In den meisten Fällen handelt es sich um ein {{HTMLElement("iframe")}} Element, das von einer anderen Domäne geladen wurde und die <a href="/de/docs/Web/Security/Same-origin_policy">Same-Origin Policy</a> verletzt.</span></p> + +<h2 id="Beispiele">Beispiele</h2> + +<pre class="brush: html"><!DOCTYPE html> +<html> + <head> + <iframe id="myframe" src="http://www1.w3c-test.org/common/blank.html"></iframe> + <script> + onload = function() { + console.log(frames[0].document); + // Error: Permission denied to access property "document" + } + </script> + </head> + <body></body> +</html></pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{HTMLElement("iframe")}}</li> + <li><a href="/de/docs/Web/Security/Same-origin_policy">Same-origin policy</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/read-only/index.html b/files/de/web/javascript/reference/errors/read-only/index.html new file mode 100644 index 0000000000..bb56305880 --- /dev/null +++ b/files/de/web/javascript/reference/errors/read-only/index.html @@ -0,0 +1,78 @@ +--- +title: 'TypeError: "x" is read-only' +slug: Web/JavaScript/Reference/Fehler/Read-only +tags: + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Read-only +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: "x" is read-only (Firefox) +TypeError: 0 is read-only (Firefox) +TypeError: Cannot assign to read only property 'x' of #<Object> (Chrome) +TypeError: Cannot assign to read only property '0' of [object Array] (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Die globale Variable oder Objekteigenschaften werden als nur lesbare Eigenschaften definiert (technisch wird das mit der <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#Writable_attribute"><code>writable</code> Eigenschaft</a> erreicht).</p> + +<p>Der Fehler tritt nur im <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> auf. Im normalen Modus wird eine Zuweisung still ignoriert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_valide_Fälle">Nicht valide Fälle</h3> + +<p>Nur lesbare Eigenschaften sind nicht sehr weit verbreitet, aber sie können mit {{jsxref("Object.defineProperty()")}} oder {{jsxref("Object.freeze()")}} erstellt werden.</p> + +<pre class="brush: js example-bad">'use strict'; +var obj = Object.freeze({name: 'Elsa', score: 157}); +obj.score = 0; // TypeError + +'use strict'; +Object.defineProperty(this, 'LUNG_COUNT', {value: 2, writable: false}); +LUNG_COUNT = 3; // TypeError + +'use strict'; +var frozenArray = Object.freeze([0, 1, 2]); +frozenArray[0]++; // TypeError +</pre> + +<p>Zudem gibt es ein paar standard Eigenschaft in JavaScript, die nicht überschrieben werden können. Da währen zum Beispiel mathematische Konstanten.</p> + +<pre class="brush: js example-bad">'use strict'; +Math.PI = 4; // TypeError +</pre> + +<p>Die globale Variable <code>undefined</code> ist auch nur lesbar, sodass der berüchtigte Fehler "undefined is not a function" nicht wie folgt umgangen werden kann:</p> + +<pre class="brush: js example-bad">'use strict'; +undefined = function() {}; // TypeError: "undefined" is read-only +</pre> + +<h3 id="Valide_Fälle">Valide Fälle</h3> + +<pre class="brush: js example-good">'use strict'; +var obj = Object.freeze({name: 'Score', points: 157}); +obj = {name: obj.name, points: 0}; // replacing it with a new object works + +'use strict'; +var LUNG_COUNT = 2; // a `var` works, because it's not read-only +LUNG_COUNT = 3; // ok (anatomically unlikely, though) +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.freeze()")}}</li> + <li><a href="https://www.answers.com/Q/Which_animals_have_three_lungs">"Which animals have three lungs?" on answers.com</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/redeclared_parameter/index.html b/files/de/web/javascript/reference/errors/redeclared_parameter/index.html new file mode 100644 index 0000000000..e80836e50f --- /dev/null +++ b/files/de/web/javascript/reference/errors/redeclared_parameter/index.html @@ -0,0 +1,61 @@ +--- +title: 'SyntaxError: redeclaration of formal parameter "x"' +slug: Web/JavaScript/Reference/Fehler/Redeclared_parameter +tags: + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Redeclared_parameter +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: redeclaration of formal parameter "x" (Firefox) +SyntaxError: Identifier "x" has already been declared (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der selbe Variablenname wird für einen Funktionsparameter benutzt und dann in einer <code><a href="/de/docs/Web/JavaScript/Reference/Statements/let">let</a></code> Zuweisung im Funktionskörper wieder neu deklariert. Das Neudeklarieren der gleichen Variablen in der selben Funktion oder im selben Block mit <code>let</code> ist in JavaScript nicht erlaubt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>In diesem Fall wird der Parameter "arg" neu deklariert.</p> + +<pre class="brush: js example-bad">function f(arg) { + let arg = 'foo'; +} + +// SyntaxError: redeclaration of formal parameter "arg" +</pre> + +<p>Wenn der Wert von "arg" im Funktionskörper geändert werden soll, kann das getan werden, aber ohne die selbe Variable neu zu deklarieren. Oder anders gesagt, man kann das <code>let</code> Schlüsselwort weg lassen. Wenn eine neue Variable erstellt werden soll, muss sie umbenannt werden, damit es keine Konflikte mit dem Funktionsparameter mehr gibt.</p> + +<pre class="brush: js example-good">function f(arg) { + arg = 'foo'; +} + +function f(arg) { + let bar = 'foo'; +} +</pre> + +<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2> + +<ul> + <li>Vor Firefox 49 {{geckoRelease(49)}}, wurde ein {{jsxref("TypeError")}} erzeugt ({{bug(1275240)}}).</li> +</ul> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/let">let</a></code></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/const">const</a></code></li> + <li><code><a href="/de/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li> + <li><a href="/de/docs/Web/JavaScript/Guide/Grammatik_und_Typen#Deklarationen">Deklarieren von Variablen</a> im <a href="/de/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.html b/files/de/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.html new file mode 100644 index 0000000000..a1a9a43748 --- /dev/null +++ b/files/de/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.html @@ -0,0 +1,88 @@ +--- +title: 'TypeError: Reduce of empty array with no initial value' +slug: Web/JavaScript/Reference/Fehler/Reduce_of_empty_array_with_no_initial_value +tags: + - Error + - JavaScript + - Reference + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Reduce_of_empty_array_with_no_initial_value +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: reduce of empty array with no initial value +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>In JavaScript gibt es einige Reduktionsfunktionen:</p> + +<ul> + <li>{{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}} und</li> + <li>{{jsxref("TypedArray.prototype.reduce()")}}, {{jsxref("TypedArray.prototype.reduceRight()")}}).</li> +</ul> + +<p>Diese Funktionen haben den optionalen <code>initialValue</code> Parameter (welcher als erster Parameter beim ersten Aufruf der <code>callback</code> Funktion benutzt wird). Immer, wenn dieser Wert nicht angegeben wird, wird das erste Element des {{jsxref("Array", "Arrays")}} oder {{jsxref("TypedArray", "TypedArrays")}} als Initialwert benutzt. Dieser Fehler tritt auf, wenn das Array leer ist, weil es in diesem Fall keinen Initialwert gibt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_valide_Fälle">Nicht valide Fälle</h3> + +<p>Dieses Problem tritt öfter bei einer Kombination mit einem Filter ({{jsxref("Array.prototype.filter()")}}, {{jsxref("TypedArray.prototype.filter()")}}), welcher Elemente aus der Liste entfernt. Dieser lässt kein Element als Initialwert in der Liste zurück.</p> + +<pre class="brush: js example-bad">var ints = [0, -1, -2, -3, -4, -5]; +ints.filter(x => x > 0) // Entfernt alle Elemente + .reduce((x, y) => x + y) // no more elements to use for the initial value.</pre> + +<p>Der gleiche Fehler kann bei einem Tippfehler passieren oder, bei einer unerwarteten Anzahl von Elementen in einer Liste.</p> + +<pre class="brush: js example-bad">var names = document.getElementsByClassName("names"); +var name_list = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name); +</pre> + +<h3 id="Valide_Fälle">Valide Fälle</h3> + +<p>Diese Problem kann mit zwei Wegen gelöst werden.</p> + +<p>Ein Weg ist es, einen <code>initialValue</code> als neutrales Element des Operators anzugeben, so wie 0 bei der Addition, 1 bei der Multiplikation oder ein leerer String bei einer Konkatination.</p> + +<pre class="brush: js example-good">var ints = [0, -1, -2, -3, -4, -5]; +ints.filter(x => x < 0) // removes all elements + .reduce((x, y) => x + y, 0) // the initial value is the neutral element of the addition +</pre> + +<p>Ein anderer Weg ist es den Fall eines leeren Arrays schon vor dem Aufruf von <code>reduce</code> zu behandeln oder einen Dummywert als Initialwert in der <code>callback</code>-Funktion zu benutzen.</p> + +<pre class="brush: js example-good">var names = document.getElementsByClassName("names"); + +var name_list1 = ""; +if (names1.length >= 1) + name_list1 = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name); +// name_list1 == "" when names is empty. + +var name_list2 = Array.prototype.reduce.call(names, (acc, name) => { + if (acc == "") // initial value + return name; + return acc + ", " + name; +}, ""); +// name_list2 == "" when names is empty. +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduce()")}}</li> + <li>{{jsxref("Array.prototype.reduceRight()")}}</li> + <li>{{jsxref("TypedArray.prototype.reduce()")}}</li> + <li>{{jsxref("TypedArray.prototype.reduceRight()")}}</li> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("TypedArray")}}</li> + <li>{{jsxref("Array.prototype.filter()")}}</li> + <li>{{jsxref("TypedArray.prototype.filter()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/reserved_identifier/index.html b/files/de/web/javascript/reference/errors/reserved_identifier/index.html new file mode 100644 index 0000000000..a483f4cd1a --- /dev/null +++ b/files/de/web/javascript/reference/errors/reserved_identifier/index.html @@ -0,0 +1,80 @@ +--- +title: 'SyntaxError: "x" is a reserved identifier' +slug: Web/JavaScript/Reference/Fehler/Reserved_identifier +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Reserved_identifier +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: "x" is a reserved identifier (Firefox) +SyntaxError: Unexpected reserved word (Chrome)</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p><a href="/de/docs/Web/JavaScript/Reference/Lexical_grammar#Schlüsselwörter">Reservierte Schlüsselwörter</a> führen zu einem Fehler, wenn sie als Bezeichner verwendet werden. Im Strict Mode und im Normalen Mode führen folgende Schlüsselwörter zu einem Fehler:</p> + +<ul> + <li><code>enum</code></li> +</ul> + +<p>Die folgenden Schlüsselwörter führen nur im Strict Mode zu einem Fehler:</p> + +<ul class="threecolumns"> + <li><code>implements</code></li> + <li><code>interface</code></li> + <li>{{jsxref("Statements/let", "let")}}</li> + <li><code>package</code></li> + <li><code>private</code></li> + <li><code>protected</code></li> + <li><code>public</code></li> + <li><code>static</code></li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Reservierte_Schlüsselwörter_im_Strict_und_Normalen_Mode">Reservierte Schlüsselwörter im Strict und Normalen Mode</h3> + +<p>Der<code>enum</code> Bezeichner ist generell reserviert.</p> + +<pre class="brush: js example-bad">var enum = { RED: 0, GREEN: 1, BLUE: 2 }; +// SyntaxError: enum is a reserved identifier +</pre> + +<p>Im Strict Mode sind weitere Bezeichner reserviert.</p> + +<pre class="brush: js example-bad">"use strict"; +var package = ["potatoes", "rice", "fries"]; +// SyntaxError: package is a reserved identifier +</pre> + +<p>Man muss die Variablen umbenennen.</p> + +<pre class="brush: js example-good">var colorEnum = { RED: 0, GREEN: 1, BLUE: 2 }; +var list = ["potatoes", "rice", "fries"];</pre> + +<h3 id="Ältere_Browser_aktualisieren">Ältere Browser aktualisieren</h3> + +<p>Wenn ein alter Browser eingesetzt wird, der zum Beispiel noch nicht <code><a href="/de/docs/Web/JavaScript/Reference/Statements/let">let</a></code> oder <code><a href="/de/docs/Web/JavaScript/Reference/Statements/class">class</a></code> implementiert, muss der Browser aktualisiert werden, so dass er diese neuen Sprachfunktionen unterstützt.</p> + +<pre class="brush: js">"use strict"; +class DocArchiver {} + +// SyntaxError: class is a reserved identifier +// (throws in older browsers only, e.g. Firefox 44 and older) +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="http://wiki.c2.com/?GoodVariableNames">Gute Variablennamen</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/resulting_string_too_large/index.html b/files/de/web/javascript/reference/errors/resulting_string_too_large/index.html new file mode 100644 index 0000000000..e3f0246d13 --- /dev/null +++ b/files/de/web/javascript/reference/errors/resulting_string_too_large/index.html @@ -0,0 +1,49 @@ +--- +title: 'RangeError: repeat count must be less than infinity' +slug: Web/JavaScript/Reference/Fehler/Resulting_string_too_large +tags: + - Errors + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Resulting_string_too_large +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">RangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox) + +RangeError: Invalid count value (Chrome) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Die {{jsxref("String.prototype.repeat()")}} Methode wurde benutzt. Sie hat einen <code>count</code> Parameter welche die Anzahl der Wiederholungen des Strings angibt. Dieser muss zwischen 0 und kleiner positiv {{jsxref("Infinity")}} sein und kann nicht negativ sein. Das erlaubte Intervall kann wie folgt beschrieben werden: [0, +∞).</p> + +<p>Der Ergebnisstring kann zudem nicht länger als die maximale Stringlänge sein, welche sich je nach JavaScript-Umgebung unterscheiden kann. In Firefox (SpiderMonkey) ist die maximale Stringlänge 2<sup>28</sup> -1 (<code>0xFFFFFFF</code>).</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Falsche_Fälle">Falsche Fälle</h3> + +<pre class="brush: js example-bad">'abc'.repeat(Infinity); // RangeError +'a'.repeat(2**28); // RangeError +</pre> + +<h3 id="Richtige_Fälle">Richtige Fälle</h3> + +<pre class="brush: js example-good">'abc'.repeat(0); // '' +'abc'.repeat(1); // 'abc' +'abc'.repeat(2); // 'abcabc' +'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer) +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String.prototype.repeat()")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/stmt_after_return/index.html b/files/de/web/javascript/reference/errors/stmt_after_return/index.html new file mode 100644 index 0000000000..be395c3b83 --- /dev/null +++ b/files/de/web/javascript/reference/errors/stmt_after_return/index.html @@ -0,0 +1,77 @@ +--- +title: 'Warning: unreachable code after return statement' +slug: Web/JavaScript/Reference/Fehler/Stmt_after_return +tags: + - JavaScript + - Warning +translation_of: Web/JavaScript/Reference/Errors/Stmt_after_return +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Warning: unreachable code after return statement (Firefox) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>Warnung</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Nicht erreichbarer Code nach einem return Statement tritt in folgenden Fällen auf:</p> + +<ul> + <li>Wenn eine weitere Anweisung nach einer {{jsxref("Statements/return", "return")}} Anweisung folgt oder</li> + <li>wenn man eine {{jsxref("Statements/return", "return")}} Anweisung ohne abschließendes Semikolon verwendet und anschließend eine weiteren Anweisung angibt.</li> +</ul> + +<p>Wenn eine Anweisung nach einer gültigen <code>return</code> Anweisung existiert, dann wird diese Warnmeldung ausgegeben, um aufzuzeigen, das der nachfolgende Quellcode nie ausgeführt wird.</p> + +<p>Warum sollte man Semikolons am Ende einer <code>return</code> Anweisung verwenden? Da im Falle einer <code>return</code> Anweisung ohne Semikolon, die Absicht des Entwicklers nicht klar ist. Es stellt sich die Frage, ob die Anweisung nach dem <code>return</code> als Rückgabewert der Methode zu sehen ist, oder sollte die Ausführung gleich beim <code>return</code> beendet werden. Hier zeigt die Warnung an, dass es sich um einen uneindeutige Situation handelt.</p> + +<p>Warnungen werden nicht erzeugt wenn nach einem semikolonlosen <code>return</code> folgende Anweisungen folgen:</p> + +<ul> + <li>{{jsxref("Statements/throw", "throw")}}</li> + <li>{{jsxref("Statements/break", "break")}}</li> + <li>{{jsxref("Statements/var", "var")}}</li> + <li>{{jsxref("Statements/function", "function")}}</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Fehlerfälle">Fehlerfälle</h3> + +<pre class="brush: js example-bad">function f() { + var x = 3; + x += 4; + return x; // die return Anweisung beendet die Methode sofort. + x -= 3; // somit ist dieser Code nicht erreichbar und wird nie ausgeführt +} + +function f() { + return // diese Zeile ist äquivalent zu `return;` + 3 + 4; // somit kann diese Code-Zeile nie erreicht werden +} +</pre> + +<h3 id="Gültige_Fälle">Gültige Fälle</h3> + +<pre class="brush: js example-good">function f() { + var x = 3; + x += 4; + x -= 3; + return x; // OK: return ist die letzte Anweisung in der Methode +} + +function f() { + return 3 + 4 // OK: return ohne Semikolon, aber mit einem Ausdruck auf der gleiche Zeile +} +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Statements/return", "Automatic Semicolon Insertion", "#Automatic_Semicolon_Insertion", 1)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/strict_non_simple_params/index.html b/files/de/web/javascript/reference/errors/strict_non_simple_params/index.html new file mode 100644 index 0000000000..a288a81a10 --- /dev/null +++ b/files/de/web/javascript/reference/errors/strict_non_simple_params/index.html @@ -0,0 +1,111 @@ +--- +title: 'SyntaxError: "use strict" not allowed in function with non-simple parameters' +slug: Web/JavaScript/Reference/Fehler/Strict_Non_Simple_Params +tags: + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Strict_Non_Simple_Params +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">Firefox: +SyntaxError: "use strict" not allowed in function with default parameter +SyntaxError: "use strict" not allowed in function with rest parameter +SyntaxError: "use strict" not allowed in function with destructuring parameter + +Chrome: +SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Eine <code>"use strict"</code> Direktive steht am Anfang einer Funktion, die einen der folgende Parameter hat:</p> + +<ul> + <li>{{jsxref("Functions/Default_parameters", "Standardparameter", "", 1)}}</li> + <li>{{jsxref("Functions/rest_parameters", "Rest Parameter", "", 1)}}</li> + <li>{{jsxref("Operators/Destructuring_assignment", "Destrukturierte Parameter", "", 1)}}</li> +</ul> + +<p>Eine <code>"use strict"</code> Direktive ist am Anfang solcher Funktionen durch die ECMAScript Spezifikation nicht erlaubt.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Funktionsstatement">Funktionsstatement</h3> + +<p>In diesem Fall hat die Funktion <code>sum</code> zwei Standardparameter <code>a=1</code> und <code>b=2</code>:</p> + +<pre class="brush: js example-bad">function sum(a = 1, b = 2) { + // SyntaxError: "use strict" not allowed in function with default parameter + 'use strict'; + return a + b; +} +</pre> + +<p>Wenn die Funktion im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a> sein soll und das Skript oder die umschließende FUnktion auch für den Strict Mode in Ordnung ist, kann man die <code>"use strict"</code> Direktive nach außen verschieben:</p> + +<pre class="brush: js example-good">'use strict'; +function sum(a = 1, b = 2) { + return a + b; +} +</pre> + +<h3 id="Funktionsausdruck">Funktionsausdruck</h3> + +<p>Bei eine Funktionsausdruck kann ein andere Workaround genutzt werden:</p> + +<pre class="brush: js example-bad">var sum = function sum([a, b]) { + // SyntaxError: "use strict" not allowed in function with destructuring parameter + 'use strict'; + return a + b; +}; +</pre> + +<p>Dieses kann zu folgendem Ausdruck konvertiert werden:</p> + +<pre class="brush: js example-good">var sum = (function() { + 'use strict'; + return function sum([a, b]) { + return a + b; + }; +})(); +</pre> + +<h3 id="Pfeilfunktionen">Pfeilfunktionen</h3> + +<p>Wenn eine Pfeilfunktion auf die <code>this</code> Variable zugreift, so kann eine umschließende Pfeilfunktion benutzt werden:</p> + +<pre class="brush: js example-bad">var callback = (...args) => { + // SyntaxError: "use strict" not allowed in function with rest parameter + 'use strict'; + return this.run(args); +}; +</pre> + +<p>Dieses kann zu folgendem Ausdruck konvertiert werden:</p> + +<pre class="brush: js example-good">var callback = (() => { + 'use strict'; + return (...args) => { + return this.run(args); + }; +})(); +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("Strict_mode", "Strict mode", "", 1)}}</li> + <li>{{jsxref("Statements/function", "function statement", "", 1)}}</li> + <li>{{jsxref("Operators/function", "function expression", "", 1)}}</li> + <li>{{jsxref("Functions/Default_parameters", "Default parameters", "", 1)}}</li> + <li>{{jsxref("Functions/rest_parameters", "Rest parameters", "", 1)}}</li> + <li>{{jsxref("Operators/Destructuring_assignment", "Destructuring parameters", "", 1)}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/too_much_recursion/index.html b/files/de/web/javascript/reference/errors/too_much_recursion/index.html new file mode 100644 index 0000000000..0010afd90a --- /dev/null +++ b/files/de/web/javascript/reference/errors/too_much_recursion/index.html @@ -0,0 +1,54 @@ +--- +title: 'InternalError: too much recursion' +slug: Web/JavaScript/Reference/Fehler/Too_much_recursion +tags: + - Errors + - InternalError + - JavaScript +translation_of: Web/JavaScript/Reference/Errors/Too_much_recursion +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">InternalError: too much recursion +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("InternalError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Eine Funktion, die sich selbst aufruft, wird rekursive Funktion genannt. In manchen Fällen ist Rekursion mit einer Schleife vergleichbar. Beide führen den gleichen Code mehrfach aus und beide brauchen eine Abbruchbedingung (um Endlosschleifen bzw. Endlosrekursion zu vermeiden). Wenn zu tiefe Rekursion oder Endlosrekursion auftritt, erzeugt JavaScript diesen Fehler.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Diese rekursive Methode wird bis zur Abbruchbedingung 10 mal durchlaufen.</p> + +<pre class="brush: js">function schleife(x) { + if (x >= 10) // "x >= 10" ist die Abbruchsbedingung + return; + // zu wiederholende Codezeilen + schleife(x + 1); // rekursiver Methodenaufruf +} +schleife(0);</pre> + +<p>Wird die Abbruchsbedingung auf eine zu hohe Wert gesetzt, ist die Rekursionstiefe zu hoch und es wird einen Fehler erzeugt:</p> + +<pre class="brush: js example-bad">function boeseSchleife(x) { + if (x >= 1000000000000) + return; + // zu wiederholende Codezeilen + boeseSchleife(x + 1); +} +boeseSchleife(0); + +// InternalError: too much recursion</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{Glossary("Recursion")}}</li> + <li><a href="/de/docs/Web/JavaScript/Guide/Funktionen">Rekursive Methoden</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/typed_array_invalid_arguments/index.html b/files/de/web/javascript/reference/errors/typed_array_invalid_arguments/index.html new file mode 100644 index 0000000000..2e7fa8f0b3 --- /dev/null +++ b/files/de/web/javascript/reference/errors/typed_array_invalid_arguments/index.html @@ -0,0 +1,77 @@ +--- +title: 'TypeError: invalid arguments' +slug: Web/JavaScript/Reference/Fehler/Typed_array_invalid_arguments +tags: + - Error + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Typed_array_invalid_arguments +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: invalid arguments (Firefox)</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der <a href="/de/docs/Web/JavaScript/Typed_arrays">Typed Array</a> Konstruktor erwartet entweder</p> + +<ul> + <li>eine Länge,</li> + <li>ein anderes Typed Array,</li> + <li>Array ähnliche Objete,</li> + <li>iterierbare Objekte oder</li> + <li>ein {{jsxref("ArrayBuffer")}} Objekt,</li> +</ul> + +<p>um ein neues Typed Array zu erstelltn. Andere Argumente im Konstruktor erstellen kein valides Typed Array.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<p>Typed Arrays, zum Beispiel ein {{jsxref("Uint8Array")}}, können nicht von einem String erstellt werden. <span class="short_text" id="result_box" lang="de"><span>Tatsächlich können String nicht in typisierten Arrays enthalten sein.</span></span></p> + +<pre class="brush: js example-bad">var ta = new Uint8Array("nope"); +// TypeError: invalid arguments +</pre> + +<p>Verschiedene Wege um ein valides {{jsxref("Uint8Array")}} Objekt zu erstellen:</p> + +<pre class="brush: js example-good">// From a length +var uint8 = new Uint8Array(2); +uint8[0] = 42; +console.log(uint8[0]); // 42 +console.log(uint8.length); // 2 +console.log(uint8.BYTES_PER_ELEMENT); // 1 + +// From an array +var arr = new Uint8Array([21,31]); +console.log(arr[1]); // 31 + +// From another TypedArray +var x = new Uint8Array([21, 31]); +var y = new Uint8Array(x); +console.log(y[0]); // 21 + +// From an ArrayBuffer +var buffer = new ArrayBuffer(8); +var z = new Uint8Array(buffer, 1, 4); + +// From an iterable +var iterable = function*(){ yield* [1,2,3]; }(); +var uint8 = new Uint8Array(iterable); +// Uint8Array[1, 2, 3] +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Typed_arrays">Typed arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("Uint8Array")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/undeclared_var/index.html b/files/de/web/javascript/reference/errors/undeclared_var/index.html new file mode 100644 index 0000000000..b7c8b09165 --- /dev/null +++ b/files/de/web/javascript/reference/errors/undeclared_var/index.html @@ -0,0 +1,67 @@ +--- +title: 'ReferenceError: assignment to undeclared variable "x"' +slug: Web/JavaScript/Reference/Fehler/Undeclared_var +tags: + - Errors + - JavaScript + - ReferenceError + - Strict Mode +translation_of: Web/JavaScript/Reference/Errors/Undeclared_var +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">ReferenceError: assignment to undeclared variable "x" (Firefox) +ReferenceError: "x" is not defined (Chrome) +ReferenceError: Variable undefined in strict mode (Edge) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("ReferenceError")}} Warnung nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict mode</a>.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Ein Wert wurde zu einer nicht deklarierten Variablen hinzugefügt. Oder mit anderen Worten, es gibt eine Zuweisung ohne das Schlüsselwort var. Es gibt einige Unterschiede zwischen deklarierten und nicht deklarierten Variablen, die zu unerwarteten Ergebnissen führen kann und weshalb der Fehler im Strict Mode erscheint.</p> + +<p>Drei Dinge über deklarierte und nicht deklarierte Variablen:</p> + +<ul> + <li>Deklarierte Variablen gehören zu dem Ausführungskontext, in dem sie deklariert werden. Nicht deklarierte Variablen sind immer global.</li> + <li>Deklarierte Variablen werden erstellt bevor Code ausgeführt wird. Nicht deklarierte Variablen existieren erst, wenn der zugehörige Code ausgeführt wird.</li> + <li>Deklarierte Variablen sind eine nicht konfigurierbare Eigenschaft des Ausführungskontextes (Funktion oder global). Nicht deklarierte Variablen sind konfigurierbar (sie können z. B. gelöscht werden).</li> +</ul> + +<p>Mehr Details und Beispiele findet man auf der <code><a href="/de/docs/Web/JavaScript/Reference/Statements/var">var</a></code> Referenzseite.</p> + +<p>Fehler mit nicht deklarierten Variablenzuweisungen gibt es nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode Code</a>. Außerhalb davon wird die Warnung einfach Ignoriert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Falsche_Fälle">Falsche Fälle</h3> + +<p>In diesem Fall ist die "bar" eine nicht deklarierte Variable.</p> + +<pre class="brush: js example-bad">function foo() { + 'use strict'; + bar = true; +} +foo(); // ReferenceError: assignment to undeclared variable bar +</pre> + +<h3 id="Richtige_Fälle">Richtige Fälle</h3> + +<p>Um "bar" zu einer deklarierten Variable zu machen, kann das Schlüsselwort <code><a href="/de/docs/Web/JavaScript/Reference/Statements/var">var</a></code> eingesetzt werden.</p> + +<pre class="brush: js example-good">function foo() { + 'use strict'; + var bar = true; +} +foo();</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict Mode</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/undefined_prop/index.html b/files/de/web/javascript/reference/errors/undefined_prop/index.html new file mode 100644 index 0000000000..fe83564f59 --- /dev/null +++ b/files/de/web/javascript/reference/errors/undefined_prop/index.html @@ -0,0 +1,63 @@ +--- +title: 'ReferenceError: reference to undefined property "x"' +slug: Web/JavaScript/Reference/Fehler/Undefined_prop +tags: + - Errors + - JavaScript + - ReferenceError + - Strict Mode +translation_of: Web/JavaScript/Reference/Errors/Undefined_prop +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">ReferenceError: reference to undefined property "x" (Firefox) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("ReferenceError")}} Fehlermeldung tritt nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strikten Modus</a> auf.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es wird versucht auf eine Eigenschaft zuzugreifen, die nicht existiert. Es gibt zwei Arten um auf Eigenschaften zuzugreifen, siehe <a href="/de/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Eigenschaften Zugriffsfunktionen</a> auf den Referenzseiten für weitere Details.</p> + +<p>Fehler aufgrund von leeren Eigenschaftsreferenzen treten nur im Quellcode auf, der im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strikten Modus</a> geschrieben ist. Im Quellcode der nicht im strikten Modus geschrieben ist, wird der Fehler ohne Meldung ignoriert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ungültige_Fälle">Ungültige Fälle</h3> + +<p>In diesem Fall ist die Eigenschaft "bar" undefiniert.</p> + +<pre class="brush: js example-bad">"use strict"; + +var foo = {}; +foo.bar; // ReferenceError: reference to undefined property "bar" +</pre> + +<h3 id="Gültige_Fälle">Gültige Fälle</h3> + +<p>Um Fehler zu vermeiden muss man eine Eigenschaft "bar" definieren oder überprüfen, ob die Eigenschaft "bar" existiert, bevor man auf diese zugreift. (z.B.: mit Hilfe der Funktion {{jsxref("Object.prototype.hasOwnProperty()")}}).</p> + +<pre class="brush: js example-good">"use strict"; + +var foo = {}; + +// Definiert die bar Eigenschaft + +foo.bar = "Mond"; +console.log(foo.bar); // "Mond" + +// Testet vor dem Zugriff, ob bar existiert. + +if (foo.hasOwnProperty("bar")) { + console.log(foo.bar); +}</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strikter Modus</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/unexpected_token/index.html b/files/de/web/javascript/reference/errors/unexpected_token/index.html new file mode 100644 index 0000000000..3aff253bfd --- /dev/null +++ b/files/de/web/javascript/reference/errors/unexpected_token/index.html @@ -0,0 +1,47 @@ +--- +title: 'SyntaxError: Unexpected token' +slug: Web/JavaScript/Reference/Fehler/Unexpected_token +tags: + - Fehler + - JavaScript + - Syntaxfehler +translation_of: Web/JavaScript/Reference/Errors/Unexpected_token +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: expected expression, got "x" +SyntaxError: expected property name, got "x" +SyntaxError: expected target, got "x" +SyntaxError: expected rest argument name, got "x" +SyntaxError: expected closing parenthesis, got "x" +SyntaxError: expected '=>' after argument list, got "x" +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es wurde eine bestimmte Sprachenstruktur erwartet, aber etwas anderes wurde übermittelt. Es kann sich dabei um einen einfachen Tippfehler handeln.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Expression_expected_(Ausdruck_erwartet)">Expression expected (Ausdruck erwartet)</h3> + +<p>Zum Beispiel sind Kommas am Ende eines Befehls nicht erlaubt.</p> + +<pre class="brush: js example-bad">for (let i = 0; i < 5,; i++) { + console.log(i); +} +// SyntaxError: expected expression, got ')' +</pre> + +<p>Richtig wäre das Komma auszulassen oder ein weiteren Ausdruck hinzuzufügen:</p> + +<pre class="brush: js example-good">for (let i = 0; i < 5; i++) { + console.log(i); +} +</pre> diff --git a/files/de/web/javascript/reference/errors/unexpected_type/index.html b/files/de/web/javascript/reference/errors/unexpected_type/index.html new file mode 100644 index 0000000000..601ec21d43 --- /dev/null +++ b/files/de/web/javascript/reference/errors/unexpected_type/index.html @@ -0,0 +1,67 @@ +--- +title: 'TypeError: "x" is (not) "y"' +slug: Web/JavaScript/Reference/Fehler/Unexpected_type +tags: + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Unexpected_type +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: "x" is (not) "y" + +Examples: +TypeError: "x" is undefined +TypeError: "x" is null +TypeError: "undefined" is not an object +TypeError: "x" is not an object or null +TypeError: "x" is not a symbol +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der Typ einer Variable ist unpassend. Dieser Fall tritt oft bei {{jsxref("undefined")}}- oder {{jsxref("null")}}-Werten auf.</p> + +<p>Außerdem benötigen bestimmte Metodhen wie {{jsxref("Object.create()")}} oder {{jsxref("Symbol.keyFor()")}} einen bestimmten Typ, der bereitgestellt werden muss.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Ungültige_Fälle">Ungültige Fälle</h3> + +<pre class="brush: js example-bad">// Undefinierte und null-Fälle, bei denen die Substring-Methode nicht funktioniert +var foo = ; +foo.substring(1); // TypeError: foo is undefined + +var foo = null; +foo.substring(1); // TypeError: foo is null + + +// Bestimmte Methoden erfordern einen bestimmten Typ +var foo = {} +Symbol.keyFor(foo); // TypeError: foo is not a symbol + +var foo = 'bar' +Object.create(foo); // TypeError: "foo" is not an object or null +</pre> + +<h3 id="Den_Fehler_beheben">Den Fehler beheben?</h3> + +<p><span lang="de">Um den Nullzeiger auf <code>undefined</code>- oder <code>null</code>-Werte zu beheben, kann z. B. der "typeof"-Operator verwendt werden.</span></p> + +<pre class="brush: js">if (typeof foo !== 'undefined') { + // Nun wissen wir, dass foo definiert ist, und können weitermachen. +}</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("undefined")}}</li> + <li>{{jsxref("null")}}</li> +</ul> diff --git a/files/de/web/javascript/reference/errors/unnamed_function_statement/index.html b/files/de/web/javascript/reference/errors/unnamed_function_statement/index.html new file mode 100644 index 0000000000..6c148b6ff0 --- /dev/null +++ b/files/de/web/javascript/reference/errors/unnamed_function_statement/index.html @@ -0,0 +1,115 @@ +--- +title: 'SyntaxError: function statement requires a name' +slug: Web/JavaScript/Reference/Fehler/Unnamed_function_statement +tags: + - Error + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Unnamed_function_statement +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: function statement requires a name [Firefox] +SyntaxError: Unexpected token ( [Chrome] +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt eine <a href="/de/docs/Web/JavaScript/Reference/Statements/function">Funktionsstatement</a> im Code, welches einen Namen benötigt. Man muss überprüfen, wie Funktionen definiert sind und ob diese einen Namen benötigen oder ob diese Funktion ein Funktionsausdruck ist (eine {{Glossary("IIFE")}}) oder ob die Funktion im richtigen Kontext geschrieben ist.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Statements_vs_Ausdrücke">Statements vs Ausdrücke</h3> + +<p>Ein <em><a href="/de/docs/Web/JavaScript/Reference/Statements/function">Funktionsstatement</a></em> (oder <em>Funktionsdeklaration</em>) benötigt einen Namen. Folgendes funktioniert nicht:</p> + +<pre class="brush: js example-bad">function () { + return 'Hello world'; +} +// SyntaxError: function statement requires a name +</pre> + +<p>Man kann stattdessen ein <a href="/de/docs/Web/JavaScript/Reference/Operators/function">Funktionsausdruck</a> (Zuweisung) nutzen:</p> + +<pre class="brush: js example-good">var greet = function() { + return 'Hello world'; +};</pre> + +<p>Manchmal soll auch eine auch eine <a href="https://en.wikipedia.org/wiki/Immediately-invoked_function_expression">IIFE</a> (Immediately Invoked Function Expression) sein, welche eine Funktion ist, die nach der Definition direkt ausgeführt wird. Dafür müssen ein paar mehr Klammern benutzt werden:</p> + +<pre class="brush: js example-good">(function () { + +})();</pre> + +<h3 id="Funktionen_mit_Labeln">Funktionen mit Labeln</h3> + +<p>Wenn man ein <a href="/de/docs/Web/JavaScript/Reference/Statements/label">Funktionslabel</a> benutzt, muss ein Funktionsnamen nach dem <code>function</code> Schlüsselwort stehen. Folgendes funktioniert nicht:</p> + +<pre class="brush: js example-bad">function Greeter() { + german: function () { + return "Moin"; + } +} +// SyntaxError: function statement requires a name +</pre> + +<p>Das folgende funktioniert:</p> + +<pre class="brush: js example-good">function Greeter() { + german: function g() { + return "Moin"; + } +}</pre> + +<h3 id="Objektmethoden">Objektmethoden</h3> + +<p>Wenn man eine Methode für ein Objekt erstellen möchte, muss ein Objekt erstellt werden. Die folgende Syntax ohne einen Namen nach dem <code>function</code> Schlüsselwort ist zulässig.</p> + +<pre class="brush: js example-good">var greeter = { + german: function () { + return "Moin"; + } +};</pre> + +<h3 id="Callback_Syntax">Callback Syntax</h3> + +<p>Zudem sollte die Syntax bei Callbackfunktionen geprüft werden. Komma- und Klammersetzung kann schnell schwierig werden.</p> + +<pre class="brush: js example-bad">promise.then( + function() { + console.log("success"); + }); + function() { + console.log("error"); +} +// SyntaxError: function statement requires a name +</pre> + +<p>Richtig ist folgendes:</p> + +<pre class="brush: json example-good">promise.then( + function() { + console.log("success"); + }, + function() { + console.log("error"); + } +); +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Guide/Functions">Funktionen im JavaScript Guide</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Statements/function">Funktionsstatement</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Operators/function">Funktionsausdruck</a></li> + <li><a href="https://en.wikipedia.org/wiki/Immediately-invoked_function_expression">IIFE</a></li> + <li><a href="/de/docs/Web/JavaScript/Reference/Statements/label">Label</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/unterminated_string_literal/index.html b/files/de/web/javascript/reference/errors/unterminated_string_literal/index.html new file mode 100644 index 0000000000..3d60240b51 --- /dev/null +++ b/files/de/web/javascript/reference/errors/unterminated_string_literal/index.html @@ -0,0 +1,67 @@ +--- +title: 'SyntaxError: unterminated string literal' +slug: Web/JavaScript/Reference/Fehler/Unterminated_string_literal +tags: + - Errors + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Unterminated_string_literal +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">SyntaxError: unterminated string literal +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Es gibt irgendwo einen nicht beendeten {{jsxref("String")}}. Stringliterale müssen mit einfachen (<code>'</code>) oder doppelten (<code>"</code>) Anführungszeichen umschlossen sein. JavaScript unterscheidet nicht zwischen Strings, die mit einfachen oder doppelten Anführungszeichen umschlossen sind. <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/String#Escape_notation">Maskierte Sequenzen</a> funktionieren in Strings mit einfachen und doppelten Anführungszeichen. Um den Fehler zu beheben, sollte folgendes überprüft werden:</p> + +<ul> + <li>Es gibt öffnende und schließende Anführungszeichen (einfache oder doppelte) für alle Stringliterale,</li> + <li>Stringliterale sind richtig maskiert,</li> + <li>Stringliterale funktionieren richtig über mehrere Zeilen, wenn es solche gibt.</li> +</ul> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="MehrereZeilen">MehrereZeilen</h3> + +<p>Man kann Strings nicht über mehrere Zeilen in JavaScript schreiben:</p> + +<pre class="brush: js example-bad">var longString = 'This is a very long string which needs + to wrap across multiple lines because + otherwise my code is unreadable.'; +// SyntaxError: unterminated string literal</pre> + +<p>Stattdessen muss ein <a href="/de/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition">+ Operator</a>, ein Backslask oder ein <a href="/de/docs/Web/JavaScript/Reference/Template_literals">Templateliteral</a> eingesetzt werden. Die <code>+</code> Operator Variante sieht wie folgt aus:</p> + +<pre class="brush: js example-good">var longString = 'This is a very long string which needs ' + + 'to wrap across multiple lines because ' + + 'otherwise my code is unreadable.'; +</pre> + +<p>Oder man benutzt ein Backslash Zeichen ("\") am ende jeder Zeile, um anzudeuten, dass der String in der nächsten Zeile weiter geht. Man muss sicherstellen, dass keine Leerzeichen oder andere Zeichen nach dem Backslash stehen (ausgenommen der Zeilenumbruch) oder als Einrückung, ansonsten wird es nicht funktionieren. Diese Form sieht wie folgt aus:</p> + +<pre class="brush: js example-good">var longString = 'This is a very long string which needs \ +to wrap across multiple lines because \ +otherwise my code is unreadable.'; +</pre> + +<p>Eine andere Möglichkeit ist der Einsatz von <a href="/de/docs/Web/JavaScript/Reference/Template_literals">Templateliteralen</a>, welche in ECMAScript 2015 Umgebungen unterstützt werden:</p> + +<pre class="brush: js example-good">var longString = `This is a very long string which needs + to wrap across multiple lines because + otherwise my code is unreadable.`;</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li><a href="/de/docs/Web/JavaScript/Reference/Template_literals">Templateliterale</a></li> +</ul> diff --git a/files/de/web/javascript/reference/errors/var_hides_argument/index.html b/files/de/web/javascript/reference/errors/var_hides_argument/index.html new file mode 100644 index 0000000000..f06a1d5220 --- /dev/null +++ b/files/de/web/javascript/reference/errors/var_hides_argument/index.html @@ -0,0 +1,56 @@ +--- +title: 'TypeError: variable "x" redeclares argument' +slug: Web/JavaScript/Reference/Fehler/Var_hides_argument +tags: + - Errors + - JavaScript + - Strict Mode + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Var_hides_argument +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Fehlermeldung">Fehlermeldung</h2> + +<pre class="syntaxbox">TypeError: variable "x" redeclares argument (Firefox) +</pre> + +<h2 id="Fehlertyp">Fehlertyp</h2> + +<p>{{jsxref("TypeError")}} Warnung nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>.</p> + +<h2 id="Was_ist_falsch_gelaufen">Was ist falsch gelaufen?</h2> + +<p>Der selbe Variablenname für einen Funktionsparameter und einer Neudeklaration mit einer <code><a href="/de/docs/Web/JavaScript/Reference/Statements/var">var</a></code> Zuweisung im Funktionskörper ist vorhanden. Dieses ist ein Namenskonflikt, weshalb JavaScript eine Warnung erzeugt.</p> + +<p>Dieser Fehler ist eine Warnung, die nur im <a href="/de/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> auftaucht. Ist man nicht im strict mode, so wird die Neudeklaration still ignoriert.</p> + +<h2 id="Beispiele">Beispiele</h2> + +<h3 id="Nicht_balider_Fall">Nicht balider Fall</h3> + +<p>In diesem Fall wird die Variable "arg" neu deklariert.</p> + +<pre class="brush: js example-bad">'use strict'; + +function f(arg) { + var arg = 'foo'; +} +</pre> + +<h3 id="Valider_Fall">Valider Fall</h3> + +<p>Um diese Warnung zu vermeiden kann das <code><a href="/de/docs/Web/JavaScript/Reference/Statements/var">var</a></code> Statement weggelassen werden, weil die Variable schon existiert. In anderen Fällen kann der Funktionsparameter oder die Variable umbenannt werden.</p> + +<pre class="brush: js example-good">'use strict'; + +function f(arg) { + arg = 'foo'; +} +</pre> + +<h2 id="Siehe_auch">Siehe auch</h2> + +<ul> + <li><a href="/de/docs/Web/JavaScript/Reference/Strict_mode">Strict mode</a></li> +</ul> |