From 4ab365b110f2f1f2b736326b7059244a32115089 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:45:38 +0100 Subject: unslug de: move --- .../reference/errors/already_has_pragma/index.html | 42 ++++++ .../errors/array_sort_argument/index.html | 47 ++++++ .../reference/errors/bad_octal/index.html | 54 +++++++ .../reference/errors/bad_radix/index.html | 61 ++++++++ .../reference/errors/bad_regexp_flag/index.html | 105 +++++++++++++ .../errors/bad_return_or_yield/index.html | 55 +++++++ .../errors/called_on_incompatible_type/index.html | 64 ++++++++ .../index.html | 60 ++++++++ .../errors/cant_access_property/index.html | 59 ++++++++ .../index.html | 64 ++++++++ .../reference/errors/cant_delete/index.html | 58 +++++++ .../errors/cant_redefine_property/index.html | 51 +++++++ .../errors/cyclic_object_value/index.html | 67 ++++++++ .../reference/errors/dead_object/index.html | 50 ++++++ .../errors/delete_in_strict_mode/index.html | 70 +++++++++ .../index.html | 75 +++++++++ .../deprecated_expression_closures/index.html | 78 ++++++++++ .../reference/errors/deprecated_octal/index.html | 67 ++++++++ .../errors/deprecated_source_map_pragma/index.html | 58 +++++++ .../errors/deprecated_string_generics/index.html | 104 +++++++++++++ .../errors/deprecated_tolocaleformat/index.html | 90 +++++++++++ .../reference/errors/equal_as_assign/index.html | 54 +++++++ .../for-each-in_loops_are_deprecated/index.html | 168 +++++++++++++++++++++ .../reference/errors/getter_only/index.html | 83 ++++++++++ .../errors/identifier_after_number/index.html | 53 +++++++ .../reference/errors/illegal_character/index.html | 80 ++++++++++ .../errors/in_operator_no_object/index.html | 72 +++++++++ .../de/web/javascript/reference/errors/index.html | 29 ++++ .../errors/invalid_array_length/index.html | 77 ++++++++++ .../invalid_assignment_left-hand_side/index.html | 53 +++++++ .../errors/invalid_const_assignment/index.html | 90 +++++++++++ .../reference/errors/invalid_date/index.html | 54 +++++++ .../errors/invalid_for-in_initializer/index.html | 74 +++++++++ .../errors/invalid_for-of_initializer/index.html | 63 ++++++++ .../index.html | 62 ++++++++ .../reference/errors/is_not_iterable/index.html | 103 +++++++++++++ .../reference/errors/json_bad_parse/index.html | 112 ++++++++++++++ .../errors/malformed_formal_parameter/index.html | 61 ++++++++ .../reference/errors/malformed_uri/index.html | 66 ++++++++ .../errors/missing_bracket_after_list/index.html | 56 +++++++ .../missing_colon_after_property_id/index.html | 77 ++++++++++ .../missing_curly_after_function_body/index.html | 67 ++++++++ .../missing_curly_after_property_list/index.html | 51 +++++++ .../errors/missing_formal_parameter/index.html | 80 ++++++++++ .../errors/missing_initializer_in_const/index.html | 58 +++++++ .../missing_name_after_dot_operator/index.html | 68 +++++++++ .../index.html | 42 ++++++ .../missing_parenthesis_after_condition/index.html | 70 +++++++++ .../missing_semicolon_before_statement/index.html | 67 ++++++++ .../errors/more_arguments_needed/index.html | 48 ++++++ .../errors/negative_repetition_count/index.html | 44 ++++++ .../reference/errors/no_non-null_object/index.html | 66 ++++++++ .../reference/errors/no_properties/index.html | 40 +++++ .../reference/errors/no_variable_name/index.html | 84 +++++++++++ .../non_configurable_array_element/index.html | 83 ++++++++++ .../reference/errors/not_a_codepoint/index.html | 55 +++++++ .../reference/errors/not_a_constructor/index.html | 97 ++++++++++++ .../reference/errors/not_a_function/index.html | 124 +++++++++++++++ .../reference/errors/not_defined/index.html | 70 +++++++++ .../reference/errors/precision_range/index.html | 96 ++++++++++++ .../errors/property_access_denied/index.html | 47 ++++++ .../reference/errors/read-only/index.html | 78 ++++++++++ .../errors/redeclared_parameter/index.html | 61 ++++++++ .../index.html | 88 +++++++++++ .../errors/reserved_identifier/index.html | 80 ++++++++++ .../errors/resulting_string_too_large/index.html | 49 ++++++ .../reference/errors/stmt_after_return/index.html | 77 ++++++++++ .../errors/strict_non_simple_params/index.html | 111 ++++++++++++++ .../reference/errors/too_much_recursion/index.html | 54 +++++++ .../typed_array_invalid_arguments/index.html | 77 ++++++++++ .../reference/errors/undeclared_var/index.html | 67 ++++++++ .../reference/errors/undefined_prop/index.html | 63 ++++++++ .../reference/errors/unexpected_token/index.html | 47 ++++++ .../reference/errors/unexpected_type/index.html | 67 ++++++++ .../errors/unnamed_function_statement/index.html | 115 ++++++++++++++ .../errors/unterminated_string_literal/index.html | 67 ++++++++ .../reference/errors/var_hides_argument/index.html | 56 +++++++ 77 files changed, 5380 insertions(+) create mode 100644 files/de/web/javascript/reference/errors/already_has_pragma/index.html create mode 100644 files/de/web/javascript/reference/errors/array_sort_argument/index.html create mode 100644 files/de/web/javascript/reference/errors/bad_octal/index.html create mode 100644 files/de/web/javascript/reference/errors/bad_radix/index.html create mode 100644 files/de/web/javascript/reference/errors/bad_regexp_flag/index.html create mode 100644 files/de/web/javascript/reference/errors/bad_return_or_yield/index.html create mode 100644 files/de/web/javascript/reference/errors/called_on_incompatible_type/index.html create mode 100644 files/de/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html create mode 100644 files/de/web/javascript/reference/errors/cant_access_property/index.html create mode 100644 files/de/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.html create mode 100644 files/de/web/javascript/reference/errors/cant_delete/index.html create mode 100644 files/de/web/javascript/reference/errors/cant_redefine_property/index.html create mode 100644 files/de/web/javascript/reference/errors/cyclic_object_value/index.html create mode 100644 files/de/web/javascript/reference/errors/dead_object/index.html create mode 100644 files/de/web/javascript/reference/errors/delete_in_strict_mode/index.html create mode 100644 files/de/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.html create mode 100644 files/de/web/javascript/reference/errors/deprecated_expression_closures/index.html create mode 100644 files/de/web/javascript/reference/errors/deprecated_octal/index.html create mode 100644 files/de/web/javascript/reference/errors/deprecated_source_map_pragma/index.html create mode 100644 files/de/web/javascript/reference/errors/deprecated_string_generics/index.html create mode 100644 files/de/web/javascript/reference/errors/deprecated_tolocaleformat/index.html create mode 100644 files/de/web/javascript/reference/errors/equal_as_assign/index.html create mode 100644 files/de/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html create mode 100644 files/de/web/javascript/reference/errors/getter_only/index.html create mode 100644 files/de/web/javascript/reference/errors/identifier_after_number/index.html create mode 100644 files/de/web/javascript/reference/errors/illegal_character/index.html create mode 100644 files/de/web/javascript/reference/errors/in_operator_no_object/index.html create mode 100644 files/de/web/javascript/reference/errors/index.html create mode 100644 files/de/web/javascript/reference/errors/invalid_array_length/index.html create mode 100644 files/de/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html create mode 100644 files/de/web/javascript/reference/errors/invalid_const_assignment/index.html create mode 100644 files/de/web/javascript/reference/errors/invalid_date/index.html create mode 100644 files/de/web/javascript/reference/errors/invalid_for-in_initializer/index.html create mode 100644 files/de/web/javascript/reference/errors/invalid_for-of_initializer/index.html create mode 100644 files/de/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.html create mode 100644 files/de/web/javascript/reference/errors/is_not_iterable/index.html create mode 100644 files/de/web/javascript/reference/errors/json_bad_parse/index.html create mode 100644 files/de/web/javascript/reference/errors/malformed_formal_parameter/index.html create mode 100644 files/de/web/javascript/reference/errors/malformed_uri/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_bracket_after_list/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_colon_after_property_id/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_curly_after_function_body/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_curly_after_property_list/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_formal_parameter/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_initializer_in_const/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_name_after_dot_operator/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_parenthesis_after_condition/index.html create mode 100644 files/de/web/javascript/reference/errors/missing_semicolon_before_statement/index.html create mode 100644 files/de/web/javascript/reference/errors/more_arguments_needed/index.html create mode 100644 files/de/web/javascript/reference/errors/negative_repetition_count/index.html create mode 100644 files/de/web/javascript/reference/errors/no_non-null_object/index.html create mode 100644 files/de/web/javascript/reference/errors/no_properties/index.html create mode 100644 files/de/web/javascript/reference/errors/no_variable_name/index.html create mode 100644 files/de/web/javascript/reference/errors/non_configurable_array_element/index.html create mode 100644 files/de/web/javascript/reference/errors/not_a_codepoint/index.html create mode 100644 files/de/web/javascript/reference/errors/not_a_constructor/index.html create mode 100644 files/de/web/javascript/reference/errors/not_a_function/index.html create mode 100644 files/de/web/javascript/reference/errors/not_defined/index.html create mode 100644 files/de/web/javascript/reference/errors/precision_range/index.html create mode 100644 files/de/web/javascript/reference/errors/property_access_denied/index.html create mode 100644 files/de/web/javascript/reference/errors/read-only/index.html create mode 100644 files/de/web/javascript/reference/errors/redeclared_parameter/index.html create mode 100644 files/de/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.html create mode 100644 files/de/web/javascript/reference/errors/reserved_identifier/index.html create mode 100644 files/de/web/javascript/reference/errors/resulting_string_too_large/index.html create mode 100644 files/de/web/javascript/reference/errors/stmt_after_return/index.html create mode 100644 files/de/web/javascript/reference/errors/strict_non_simple_params/index.html create mode 100644 files/de/web/javascript/reference/errors/too_much_recursion/index.html create mode 100644 files/de/web/javascript/reference/errors/typed_array_invalid_arguments/index.html create mode 100644 files/de/web/javascript/reference/errors/undeclared_var/index.html create mode 100644 files/de/web/javascript/reference/errors/undefined_prop/index.html create mode 100644 files/de/web/javascript/reference/errors/unexpected_token/index.html create mode 100644 files/de/web/javascript/reference/errors/unexpected_type/index.html create mode 100644 files/de/web/javascript/reference/errors/unnamed_function_statement/index.html create mode 100644 files/de/web/javascript/reference/errors/unterminated_string_literal/index.html create mode 100644 files/de/web/javascript/reference/errors/var_hides_argument/index.html (limited to 'files/de/web/javascript/reference/errors') 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Warning: -file- is being assigned a //# sourceMappingURL, but already has one.
+ +

Fehlertyp

+ +

Warnung. Die Ausführung von JavaScript wird nicht unterbrochen.

+ +

Was ist falsch gelaufen?

+ +

Eine Source Map wurde mehrere Male für eine JavaScript Quelle spezifiziert.

+ +

JavaScript Quellen sind oft kombiniert und minimiert, um diesen auf einem Server effizienter zu gestalten. Mit Source Maps 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.

+ +

Beispiele

+ +

Setzen einer Source Map mit einem Kommentar in einer Datei:

+ +
//# sourceMappingURL=http://example.com/path/to/your/sourcemap.map
+ +

Oder alternativ mit dem setzen eines Headers in einer JavaScriptdatei:

+ +
X-SourceMap: /path/to/file.js.map
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: invalid Array.prototype.sort argument (Firefox)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Das Argument von {{jsxref("Array.prototype.sort()")}} erwartet entweder {{jsxref("undefined")}} oder eine Funktion, welche die Operanden vergleicht.

+ +

Beispiele

+ +

Nicht valide Fälle

+ +
[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
+
+ +

Valide Fälle

+ +
[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]
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Warning: SyntaxError: 08 is not a legal ECMA-262 octal constant.
+Warning: SyntaxError: 09 is not a legal ECMA-262 octal constant.
+
+ +

Fehlertyp

+ +

Warnung. Die Ausführung von JavaScript wird nicht gestoppt.

+ +

Was ist falsch gelaufen?

+ +

Dezimalliterale können mit einer Null (0) beginnen, gefolgt von anderen Dezimalziffern. en alle Ziffern nach der führenden 0 kleiner als 8 sind, wird die Zal als Oktalzahl interpretiert. Weil das nicht der Fall ist mit 08 und 09, warnt JavaScript.

+ +

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" (0o or 0O) benutzt. Sie dazu die Seite lexical grammar für mehr Informationen.

+ +

Beispiele

+ +

Ungültige Oktalzahlen

+ +
08;
+09;
+// SyntaxError: 08 is not a legal ECMA-262 octal constant
+// SyntaxError: "0"-prefixed octal literals and octal escape sequences
+// are deprecated
+ +

Gültige Oktalzahlen

+ +

Einsatz von einer führenden Null gefolgt von dem Buchstaben "o";

+ +
0O755;
+0o644;
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

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

Fehlertyp

+ +

{{jsxref("RangeError")}}

+ +

Was ist falsch gelaufen?

+ +

Der optionale radix 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.

+ +

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.

+ +

Die am meisten eingesetzten Basen sind:

+ + + +

Beispiele

+ +

Nicht valide Fälle

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

Valide Fälle

+ +
(42).toString(2);     // "101010" (binary)
+(13).toString(8);     // "15"     (octal)
+(0x42).toString(10);  // "66"     (decimal)
+(100000).toString(16) // "186a0"  (hexadecimal)
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: invalid regular expression flag "x" (Firefox)
+SyntaxError: Invalid regular expression flags (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

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.

+ +

Um ein Flag in regulären Ausdrücken einzufügen kann folgende Syntax benutzt werden:

+ +
var re = /pattern/flags;
+
+ +

oder

+ +
var re = new RegExp('pattern', 'flags');
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Flags von regulären Ausdrücken
FlagBeschreibung
gGlobale Suche.
iGroß- und Kleinschreibung nicht unterscheiden.
mSuche über mehrere Zeilen.
uUnicode; nimmt das Muster als eine Sequenz von Unicode Codepoints an.
yFührt eine "sticky" Suche durch, welche zutrifft, wenn der String von der Startposition aus auf das Muster zutrifft. Siehe {{jsxref("RegExp.sticky", "sticky")}}.
+ +

Beispiele

+ +

Es gibt nur fünf valide Flags für reguläre Ausdrücke.

+ +
/foo/bar;
+
+// SyntaxError: invalid regular expression flag "b"
+
+ +

Ist eine regulärer Ausdruck gewollt? Ein Ausdruck, der zwei Schrägstriche enthält wird als Literal für reguläre Ausdrücke interpretiert.

+ +
let obj = {
+  url: /docs/Web
+};
+
+// SyntaxError: invalid regular expression flag "W"
+
+ +

Oder war stattdessen ein String gemeint? Füge einfache oder doppelte Anführungszeichen hinzu, um ein Stringliteral zu erstellen.

+ +
let obj = {
+  url: '/docs/Web'
+};
+ +

Valide Flags für reguläre Ausdrücke

+ +

Siehe in der Tabelle oben für die fünf in JavaScript erlaubten validen Flags für reguläre Ausdrücke

+ +
/foo/g;
+/foo/gim;
+/foo/uy;
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: return not in function
+SyntaxError: yield not in function
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}.

+ +

Was ist falsch gelaufen?

+ +

Ein return oder yield Statement wird außerhalb einer Funktion aufgerufen. Es kann sein, dass geschweifte Klammern fehlen. Die Statements return und yield 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.

+ +

Beispiele

+ +
var cheer = function(score) {
+  if (score === 147)
+    return 'Maximum!';
+  };
+  if (score > 100) {
+    return 'Century!';
+  }
+}
+
+// SyntaxError: return not in function
+ +

Die geschweiften Klammern sehen auf den ersten Blick richtig aus, jedoch fehlt in dem Code eine { nach dem ersten if Statement. Korrekt währe es wir folgt:

+ +
var cheer = function(score) {
+  if (score === 147) {
+    return 'Maximum!';
+  }
+  if (score > 100) {
+    return 'Century!';
+  }
+};
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

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

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Wenn dieser Fehler auftritt, wird eine Funktion (auf eineem gegebenen Objekt) aufgerufen, wobei this nicht vom erwarteten Typ ist.

+ +

Dieser Fehler kann auftreten, wenn die {{jsxref("Function.prototype.call()")}} oder {{jsxref("Function.prototype.apply()")}} Methode mit einem this Argument genutzt werden, welches nicht dem erwarteten Typ entspricht.

+ +

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 this 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 this Objekt zu nutzen.

+ +

Beispiele

+ +

Fehlerfälle

+ +
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.
+
+
+ +

Gültiger Fälle

+ +
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..
+
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
ReferenceError: can't access lexical declaration `X' before initialization (Firefox)
+ReferenceError: 'x' is not defined (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("ReferenceError")}}

+ +

Was ist falsch gelaufen?

+ +

Auf eine lexikalische Variable wurde zugegriffen bevor sie deklariert wurde. Das passiert in Blockstatements, in denen auf let oder const Variablen zugegriffen wird, bevor sie definiert wurden.

+ +

Beispiele

+ +

Falsche Fälle

+ +

In diesem Fall wird die Variable "foo" in einem Blockstatement mit let neu deklariert.

+ +
function test() {
+  let foo = 33;
+  if (true) {
+    let foo = (foo + 55);
+    // ReferenceError: can't access lexical
+    // declaration `foo' before initialization
+  }
+}
+test();
+
+ +

Richtige Fälle

+ +

Um "foo" im if-Statement zu ändern, muss  let entfernt werden, welche die Neudeklaration verursacht.

+ +
function test(){
+   let foo = 33;
+   if (true) {
+      foo = (foo + 55);
+   }
+}
+test();
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
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
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}.

+ +

Was ist falsch gelaufen?

+ +

The Attributzugriff erfolgte über einen {{jsxref("undefined")}} oder {{jsxref("null")}} Wert

+ +

Beispiele

+ +

Invalide Fälle

+ +
// 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
+
+ +

Fehlerbehebung

+ +

Um den null pointer auf undefined oder null Werte zu beheben, kann beispielsweise der typeof Operator verwendet werden.

+ +
if (typeof foo !== 'undefined') {
+  // Hier wissen wir, dass foo definiert ist
+}
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: can't define property "x": "obj" is not extensible (Firefox)
+TypeError: Cannot define property: "x", object is not extensible. (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

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.

+ +

Beispiele

+ +

Im strict mode wird ein TypeError erzeugt, wenn versucht wird eine Eigenschaft zu einem nicht erweiterbaren Objekt hinzuzufügen. Im normalen Modus wird das Hinzufügen einfach ignoriert.

+ +
'use strict';
+
+var obj = {};
+Object.preventExtensions(obj);
+
+obj.x = 'foo';
+// TypeError: can't define property "x": "obj" is not extensible
+
+ +

Im strict mode und normalen Modus wird ein Fehler erzeugt, wenn {{jsxref("Object.defineProperty()")}} benutzt wird, um eine Eigenschaft zu einem nicht erweiterbaren Objekt hinzuzufügen.

+ +
var obj = { };
+Object.preventExtensions(obj);
+
+Object.defineProperty(obj,
+  'x', { value: "foo" }
+);
+// TypeError: can't define property "x": "obj" is not extensible
+
+ +

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.

+ +
'use strict';
+
+var obj = {};
+obj.x = 'foo'; // add property first and only then prevent extensions
+
+Object.preventExtensions(obj);
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: property "x" is non-configurable and can't be deleted. (Firefox)
+TypeError: Cannot delete property 'x' of #<Object> (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}} nur im strict mode.

+ +

Was ist falsch gelaufen?

+ +

Es wurde versucht eine EIgenschaft zu löschen, obwohl die Eigenschaft nicht Konfigurierbar (non-configurable) ist. Das configurable Attribut gibt an, ob ein Eigenschaft von einem Objekt gelöscht werden kann und ob ein Attribut (anders als writable) geändert werden kann.

+ +

Dieser Fehler ist nur tritt nur im strict mode auf. In non-strict Quelltext, gibt die Operation false zurück.

+ +

Beispiele

+ +

Nicht Konfigurierbare Eigenschaften sind nicht sehr häufig, aber sie können mit {{jsxref("Object.defineProperty()")}} oder {{jsxref("Object.freeze()")}} erstellt werden.

+ +
'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
+
+ +

Es gibt auch einige nicht Konfigurierbare Eigenschaften, die in JavaScript eingebaut sind. Dazu zählen zum Beispiel die mathematischen Konstanten.

+ +
'use strict';
+delete Math.PI;  // TypeError
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: can't redefine non-configurable property "x" (Firefox)
+TypeError: Cannot redefine property: "x" (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Es wurde versucht eine Eigenschaft erneut zu definieren, aber die Eigenschaft ist nicht konfigurierbar (non-configurable). Das configurable Attribut kontrolliert, ob eine Eigenschaft von einem Objekt gelöscht werden kann und seine Attribute (anders als writable) geändert werden können. Eigenschaften von einem Objekt, dass von einem Objekt-Initialisierer erstellt wurden, sind konfigurierbar. Immer, wenn zum Beispiel {{jsxref("Object.defineProperty()")}} eingesetzt wird, ist die Eigenschaft nicht ohne weiteres konfigurierbar.

+ +

Beispiele

+ +

Nicht konfigurierbare Eigenschaften mit Object.defineProperty erstellen

+ +

Die {{jsxref("Object.defineProperty()")}} Funktion erstellt nicht konfiguriertbare Eigenschaften wenn sie nicht extra als konfigurierbar spezifiziert sind.

+ +
var obj = Object.create({});
+Object.defineProperty(obj, "foo", {value: "bar"});
+
+Object.defineProperty(obj, "foo", {value: "baz"});
+// TypeError: can't redefine non-configurable property "foo"
+
+ +

Die "foo" Eigenschaft muss als Konfigurierbar eingestellt werden, wenn diese später im Quelltext erneut definiert bzw. überschrieben werden soll.

+ +
var obj = Object.create({});
+Object.defineProperty(obj, "foo", {value: "bar", configurable: true});
+Object.defineProperty(obj, "foo", {value: "baz", configurable: true});
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: cyclic object value (Firefox)
+TypeError: Converting circular structure to JSON (Chrome and Opera)
+TypeError: Circular reference in value argument not supported (Microsoft Edge)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Wenn {{jsxref("JSON.stringify()")}} aufgerufen wird, kann eine zyklische Objektreferenzstruktur nicht zu eine String konvertiert werden.

+ +

Beispiele

+ +

In eine zyklischen Struktur wie folgender

+ +
var circularReference = {otherData: 123};
+circularReference.myself = circularReference;
+
+ +

wird {{jsxref("JSON.stringify()")}} nicht funktionieren

+ +
JSON.stringify(a);
+// TypeError: cyclic object value
+
+ +

Um zyklische Referenzen zu serialisieren, kann man eine Bibliotheken benutzen (z. B. cycle.js von Douglas Crockford) oder eine eigene Lösung implementieren, welche zyklische Referenzen findet und mit serialisierbaren Werten ersetzt (oder diese entfernt).

+ +

Das folgende Codebeispiel zeigt, wie man eine zyklische Referenz mit dem Einsatz des  replacer Parameters von {{jsxref("JSON.stringify()")}} findet und filtert (das bedeutet, es gehen Daten verloren):

+ +
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(circularReference, getCircularReplacer());
+// {"otherData":123}
+ +

Siehe auch

+ + 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 +--- +
{{JSSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: can't access dead object
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

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 weak Referenz gespeichert werden.

+ +

Prüfen, ob ein Objekt tot ist

+ +

Components.utils hat ein isDeadWrapper() Methode, welche in privilegiertem Quelltext verwendet werden sollte.

+ +
if (Components.utils.isDeadWrapper(window)) {
+  // dead
+}
+ +

Nicht privilegierter Quelltext hat keinen Zugriff auf Component.utils und sollt deswegen einfach den Fehler abfangen.

+ +
try {
+  String(window);
+}
+catch (e) {
+  console.log("window is likely dead");
+}
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox)
+SyntaxError: Delete of an unqualified identifier in strict mode. (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}} nur im Strict Mode.

+ +

Was ist falsch gelaufen?

+ +

Normale Variablen können in JavaScript nicht mit dem delete Operator gelöscht werden. Im Strict Mode führt der Versuch des Löschens zu einem Fehler, weil es nicht erlaubt ist.

+ +

Der delete Operator kann nur Eigenschaften eines Objektes löschen. Objekteigenschaften müssen dafür Konfigurierbar sein.

+ +

Wie oft fälschlicherweise angenommen, hat die delete Operation nichts mit dem direkten freimachen von Speicher zu tun. Speicherverwaltung wird indirekt gemacht, mehr Informationen darüber auf den Seiten Speicherverwaltung und delete.

+ +

Der Fehler tritt nur im Strict Mode auf. In normalem Code gibt die Operation einfach false zurück.

+ +

Beispiele

+ +

Der Versuch eine einfache Variable zu Löschen funktioniert in JavaScript nicht unf führt im Strict Mode zu einem Fehler:

+ +
'use strict';
+
+var x;
+
+// ...
+
+delete x;
+
+// SyntaxError: applying the 'delete' operator to an unqualified name
+// is deprecated
+
+ +

Um den Inhalt einer Variable zu leeren, kann man sie auf {{jsxref("null")}} setzen:

+ +
'use strict';
+
+var x;
+
+// ...
+
+x = null;
+
+// x can be garbage collected
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Warning: ReferenceError: deprecated caller usage (Firefox)
+Warning: ReferenceError: deprecated arguments usage (Firefox)
+TypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari)
+
+ +

Fehlertyp

+ +

Eine {{jsxref("ReferenceError")}} Warnung, die nur im Strict Mode auftaucht. Die JavaScript-Ausführung wird dadurch nicht angehalten.

+ +

Was ist falsch gelaufen?

+ +

Im Strict Mode 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.

+ +

Beispiele

+ +

Veraltete function.caller oder arguments.callee.caller Eigenschaft

+ +

{{jsxref("Function.caller")}} und arguments.callee.caller sind veraltet (in den Referenzartikeln sind mehr Informationen dazu enthalten).

+ +
'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!"
+ +

Function.arguments

+ +

{{jsxref("Function.arguments")}} ist veraltet (im Referenzartikel sind mehr Informationen dazu enthalten).

+ +
'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
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Warning: expression closures are deprecated
+
+ +

Fehlertyp

+ +

Warnung. Die Ausführung von JavaScript wird nicht angehalten.

+ +

Was ist falsch gelaufen?

+ +

Die nicht standardisierte Ausdrucks Closure 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")}}.

+ +

Beispiele

+ +

Veraltete Syntax

+ +

Ausdrucks Closures vermeiden geschweifte Klammern oder return Anweisungen in Funktionsdeklarationen oder in Methodendefinitionen in Objekten.

+ +
var x = function() 1;
+
+var obj = {
+  count: function() 1
+};
+
+ +

Standardsyntax

+ +

Um die nicht standardisierte Ausdrucks Closures Syntax zu Standard-ECMAScript Syntax zu konvertieren müssen geschweifte Klammern und ein return Statement hinzugefügt werden.

+ +
var x = function() { return 1; }
+
+var obj = {
+  count: function() { return 1; }
+};
+
+ +

Standardsyntax mit Arrowfunktionen

+ +

Alternativ können Arrow-Funktionen genutzt werden:

+ +
var x = () => 1;
+ +

Standardsyntax mit Kurzformmethodensyntax

+ +

Anweisungs Closures können auch in Gettern und Settern gefunden werden:

+ +
var obj = {
+  get x() 1,
+  set x(v) this.v = v
+};
+
+ +

Mit ES2015 Methodendefinitionen können diese folgendermaßen konvertiert werden :

+ +
var obj = {
+  get x() { return 1 },
+  set x(v) { this.v = v }
+};
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError:
+"0"-prefixed octal literals and octal escape sequences are deprecated;
+for octal literals use the "0o" prefix instead
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}} nur im Strict Mode.

+ +

Was ist falsch gelaufen?

+ +

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 (0o oder 0O).

+ +

Beispiele

+ +

Oktalliteral mit führender 0

+ +
"use strict";
+
+03;
+
+// SyntaxError: "0"-prefixed octal literals and octal escape sequences
+// are deprecated
+ +

Oktal maskierte Sequenz

+ +
"use strict";
+
+"\251";
+
+// SyntaxError: "0"-prefixed octal literals and octal escape sequences
+// are deprecated
+
+ +

Valide Oktalzahlen

+ +

Einsatz einer führenden null gefolgt von "o" oder "O":

+ +
0o3;
+
+ +

Statt oktal maskierte Sequenzen können hexadezimal maskierte Sequenzen benutzt werden:

+ +
'\xA9';
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Warning: SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead
+
+Warning: SyntaxError: Using //@ to indicate sourceMappingURL pragmas is deprecated. Use //# instead
+
+ +

Fehlertyp

+ +

Eine Warnung die als {{jsxref("SyntaxError")}} auftritt. Die Ausführung von JavaScript wird nicht unterbrochen.

+ +

Was ist falsch gelaufen?

+ +

Es gibt eine veraltete Source-Map-Syntax im JavaScript Code.

+ +

JavaScript Code wird oft zusammengefügt und minimiert, um die Auslieferung durch einen Server effizienter zu machen. Mit Source-Maps kann beim Debuggen der ausgeführte Code auf die Original Codedateien übertragen werden.

+ +

Die Source-Map Spezifikation änderte die Syntax wegen eines Konflikts mit dem IE immer wenn die Seite nach //@cc_on war, interpretierte dieser es als bedingte Kompilierung in der IE JScript Umgebung. Der bedingte Kompilations Kommentar im IE ist eine relativ unbekannte Funktion, aber dieses machte Source-Maps von jQuery und anderen Bibliotheken kaputt.

+ +

Beispiele

+ +

Veraltete Syntax

+ +

Syntax mit dem veralteten "@" Zeichen.

+ +
//@ sourceMappingURL=http://example.com/path/to/your/sourcemap.map
+
+ +

Standard Syntax

+ +

Benutzt stattdessen ein "#" Zeichen.

+ +
//# sourceMappingURL=http://example.com/path/to/your/sourcemap.map
+ +

Alternativ kann ein {{HTTPHeader("SourceMap")}} Header zu der JavaScript Datei gesetzt werden, um einen solchen Kommentar zu vermeiden:

+ +
SourceMap: /path/to/file.js.map
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
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
+
+ +

Fehlertyp

+ +

Warnung. JavaScript unterbricht die Ausführung nicht.

+ +

Was ist falsch gelaufen?

+ +

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). String-Generics stellen String-Instanzmethoden für das String-Objekt bereit, wodurch String-Methoden auf jedes Objekt angewendet werden können.

+ +

Firefox {{bug(1222552)}} dokumentiert das Entfernen von generischen String Methoden.

+ +

Beispiele

+ +

Fehlerfälle

+ +
var num = 15;
+String.replace(num, /5/, '2');
+ +

Gültige Fälle

+ +
var num = 15;
+String(num).replace(/5/, '2');
+
+ +

Shim

+ +

Das Folgende ist ein Shim zur Unterstützung nicht unterstützender Browser:

+ +
/*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]);
+  }
+}());
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Warning: Date.prototype.toLocaleFormat is deprecated; consider using Intl.DateTimeFormat instead
+
+ +

Fehlertyp

+ +

Warnung. JavaScript stoppt die ausführung nicht an.

+ +

Was ist falsch gelaufen?

+ +

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 strftime(). Diese Funktion ist seit Firefox 58+ nicht mehr vorhanden.

+ +

Beispiele

+ +

Veraltete Syntax

+ +

Die {{jsxref("Date.prototype.toLocaleFormat")}} Methode ist veraltet und wird entfernt werden (keine browserübergreifende Unterstützung, nur in Firefox verfügbar).

+ +
var today = new Date();
+var date = today.toLocaleFormat('%A, %e. %B %Y');
+
+console.log(date);
+// In German locale
+// "Freitag, 10. März 2017"
+ +

Alternative Standardsyntax mit der ECMAScript Intl API

+ +

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+).

+ +

Man kan jetzt die {{jsxref("Date.prototype.toLocaleDateString")}} Methode einsetzen, um einen Zeitpunkt zu formatieren.

+ +
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"
+
+ +

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.

+ +
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"
+
+ +

Alternative Standardsyntax mit Date Methoden

+ +

Das {{jsxref("Date")}} Objekt enthält einige Methoden, um einen Benutzerdefinierten Datumsstring zu erhalten.

+ +
(new Date()).toLocaleFormat("%Y%m%d");
+// "20170310"
+
+ +

Dieses kan konvertiert werde:

+ +
let now = new Date();
+let date = now.getFullYear() * 10000 +
+          (now.getMonth() + 1) * 100 + now.getDate();
+
+console.log(date);
+// "20170310"
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Warning: SyntaxError: test for equality (==) mistyped as assignment (=)?
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}} Warnung nur im strict mode.

+ +

Was ist falsch gelaufen?

+ +

Es gibt eine Zuweisung (=) an der eigentlich ein Gleichheitsprüfung (==) erwartet wird. Um das Debuggen zu unterstützen, warnt JavaScript diesen Fakt (im strict mode).

+ +

Beispiele

+ +

Zuweisung in bedingten Ausdrücken

+ +

Es ist ratsam in bedingten Ausdrücken (wie z. B. if...else) 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:

+ +
if (x = y) {
+  // do the right thing
+}
+
+ +

Wenn es notwendig ist eine Zuweisung in einem bedingten Ausdruck einzusetzen, ist es verbreitet, diese mit runden Klammern einzuklammern. Zum Beispiel:

+ +
if ((x = y)) {
+  // do the right thing
+}
+ +

Andernfalls kann es sein, dass eigentliche eine Vergleichsoperation gemeint war (z. B. == oder ===):

+ +
if (x == y) {
+  // do the right thing
+}
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Warning: JavaScript 1.6's for-each-in loops are deprecated; consider using ES6 for-of instead
+
+ +

Fehlertyp

+ +

Warnung

+ +

Was ist falsch gelaufen?

+ +

Das {{jsxref("Statements/for_each...in", "for each (variable in obj)")}} Statement aus JavaScript 1.6 ist veraltet und wird in naher Zukunft entfernt.

+ +

Beispiele

+ +

Objektiteration

+ +

{{jsxref("Statements/for_each...in", "for each...in")}} wurde eingesetzt, um über spezifizierte Objektwerte zu iterieren.

+ +

Veraltete Syntax

+ +
var object = { a: 10, b: 20 };
+
+for each (var x in object) {
+  console.log(x);        // 10
+                         // 20
+}
+
+ +

Alternative Standardsyntax

+ +

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:

+ +
var object = { a: 10, b: 20 };
+
+for (var key in object) {
+  var x = object[key];
+  console.log(x);        // 10
+                         // 20
+}
+
+ +

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:

+ +
var object = { a: 10, b: 20 };
+
+for (var x of Object.values(object)) {
+  console.log(x);        // 10
+                         // 20
+}
+
+ +

Arrayiteration

+ +

{{jsxref("Statements/for_each...in", "for each...in")}} wurde eingesetzt, um über spezifizierte Arrayelemente zu iterieren.

+ +

Veraltete Syntax

+ +
var array = [10, 20, 30];
+
+for each (var x in array) {
+  console.log(x);        // 10
+                         // 20
+                         // 30
+}
+
+ +

Alternative Standardsyntax

+ +

Dieses ist mit der {{jsxref("Statements/for...of", "for...of Schleife")}} (ES2015) möglich.

+ +
var array = [10, 20, 30];
+
+for (var x of array) {
+  console.log(x);        // 10
+                         // 20
+                         // 30
+}
+
+ +

Iterieren über ein Arrays oder null

+ +

{{jsxref("Statements/for_each...in", "for each...in")}} tut nichts, wenn der übergebene Wert null oder undefined ist. {{jsxref("Statements/for...of", "for...of")}} erzeugt in diesem Fall einen Fehler.

+ +

Veraltete Syntax

+ +
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
+
+ +

Alternative Standardsyntax

+ +

Um das {{jsxref("Statements/for_each...in", "for each...in")}} Statement neu zu schreibe, so dass null oder undefined mit {{jsxref("Statements/for...of", "for...of")}} funktionieren, muss eine Bedingung um {{jsxref("Statements/for...of", "for...of")}} verfasst werden.

+ +
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
+
+ +

Über Objekt-Schlüssel-Werte-Paare iterieren

+ +

Veraltete Syntax

+ +

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.

+ +
var object = { a: 10, b: 20 };
+
+for each (var [key, value] in Iterator(object)) {
+  console.log(key, value);  // "a", 10
+                            // "b", 20
+}
+
+ +

Alternative Standardsyntax

+ +

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:

+ +
var object = { a: 10, b: 20 };
+
+for (var key in object) {
+  var value = object[key];
+  console.log(key, value);  // "a", 10
+                            // "b", 20
+}
+
+ +

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:

+ +
var object = { a: 10, b: 20 };
+
+for (var [key, value] of Object.entries(object)) {
+  console.log(key, value);  // "a", 10
+                            // "b", 20
+}
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: setting getter-only property "x" (Firefox)
+TypeError: Cannot set property "prop" of #<Object> which has only a getter (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}} nur im strict mode.

+ +

Was ist falsch gelaufen?

+ +

Wenn versucht wird einen neuen Wert einer Wichenschaft zuzuweisen, welche nur als Getter spezifiziert wurde. Wenn kein strict mode verwendet wird, wird dieses stillschweigend ignoriert, während im strict mode ein {{jsxref("TypeError")}} erzeugt wird.

+ +

Beispiele

+ +

Das folgende Beispiel zeigt, wie eine Eigenschaft als Getter eingestellt wird. Es wird kein Setter definiert, so dass ein TypeError erzeugt wird, wenn die temperature Eigenschaft mit dem Wert 30 beschrieben werden soll. Für mehr Details siehe auf der {{jsxref("Object.defineProperty()")}} Seite.

+ +
"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"
+ +

Um den Fehler zu beheben, muss einefach die Zeile 16 entfernt werden, weil dort der Versuch ist die temperature Eigenschaft zu beschreiben, oder es muss ein Setter definiert werden, wie zum Beispiel dieser:

+ +
"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 }]
+ +

Siehe auch

+ + 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 +--- +
{{JSSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: identifier starts immediately after numeric literal (Firefox)
+SyntaxError: Unexpected number (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Die Namen von Variablen, {{Glossary("Identifier", "Bezeichner")}} genannt, haben einige Regeln, die der Code erfüllen muss.

+ +

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).

+ +

Beispiele

+ +

Variablenname der mit einer Ziffer beginnt

+ +

Variablennamen dürfen in JavaScript nicht mit einer Zahl beginnen. Das folgende wird nciht funktionieren:

+ +
var 1life = 'foo';
+// SyntaxError: identifier starts immediately after numeric literal
+
+var foo = 1life;
+// SyntaxError: identifier starts immediately after numeric literal
+
+ +

Man muss die Variable neu benenne, um die führende Zahl im Namen zu vermeiden.

+ +
var life1 = 'foo';
+var foo = life1;
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: illegal character (Firefox)
+SyntaxError: Invalid or unexpected token (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

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 ( - ) und einem Dashzeichen ( – ) oder einfachen Anführungszeichen ( " ) und anderen Anführungszeichen ( “ ).

+ +

Beispiele

+ +

Verwechseltes Zeichen

+ +

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 (griechisches Fragezeichen (U+37e) sieht genauso aus)

+ +
“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';             // SyntaxError: illegal character
+                             // <37e> sind nicht ;, aber sieht so aus
+
+ +

Das funktioniert:

+ +
"This is actually a string";
+42 - 13;
+var foo = 'bar';
+
+ +

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.

+ +

Vergessene Zeichen

+ +

Es passiert schnell, dass man ein Zeichen vergisst.

+ +
var colors = ['#000', #333', '#666'];
+// SyntaxError: illegal character
+
+ +

Man muss das fehlende Anführungszeichen ergänzen '#333'.

+ +
var colors = ['#000', '#333', '#666'];
+ +

Nicht sichtbare Zeichen

+ +

Beim Kopieren und Einfügen von Code aus externen Quellen kann es nicht valide Zeichen geben. Zum Beispiel:

+ +
var foo = 'bar';​
+// SyntaxError: illegal character
+
+ +

Wenn man den Code in einem Editor wie Vim anschaut, bemerkt man, dass ein breitenloses Leerzeichen (ZWSP) (U+200B) benutzt wird.

+ +
var foo = 'bar';​<200b>
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

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

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Der in Operator kan nur für das Prüfen von Eigenschaften in Objekten genutzt werden. Man kann nicht in Strings, Nummern oder anderen primitiven Typen suchen.

+ +

Beispiele

+ +

Suchen in Strings

+ +

Im Vergleich zu anderen Programmiersprachen (z. B. Python) kann in Strings nicht mit dem in Operator gesucht werden.

+ +
"Hello" in "Hello World";
+// TypeError: cannot use 'in' operator to search for 'Hello' in 'Hello World'
+ +

Stattdessen kann zum Beispiel {{jsxref("String.prototype.indexOf()")}} eingesetzt werden.

+ +
"Hello World".indexOf("Hello") !== -1;
+// true
+ +

Der Operand kann nicht null oder undefined sein

+ +

Man muss sicherstellen, dass der Operand nicht {{jsxref("null")}} oder {{jsxref("undefined")}} ist.

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

Der in Operator erwartet immer ein Objekt.

+ +
var foo = { baz: "bar" };
+"bar" in foo; // false
+
+"PI" in Math; // true
+"pi" in Math; // false
+
+ +

Suchen in Arrays

+ +

Man muss vorsichtig sein, wenn der in Operator in {{jsxref("Array")}} Objekten genutzt wird. Der in Operator prüft die Indexnummern, aber nicht die Werte des Indizes.

+ +
var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
+3 in trees; // true
+"oak" in trees; // false
+ +

Siehe auch

+ + 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 +--- +

{{jsSidebar("Errors")}}

+ +

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 name und eine Fehlermeldung (message).

+ +

Fehler die in der Webconsole angezeigt werden enthalten manchmal einen Link zu einer der untenstehenden Seiten, um die Lösung von Problemen zu beschleunigen.

+ +

Liste von Fehlern

+ +

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!

+ +

{{ListSubPages("/en-US/docs/Web/JavaScript/Reference/Errors")}}

+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
RangeError: invalid array length (Firefox)
+RangeError: Invalid array length (Chrome)
+RangeError: Invalid array buffer length (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("RangeError")}}

+ +

Was ist falsch gelaufen?

+ +

entweder:

+ + + +

Warum ist die Länge von Array and ArrayBuffer limitiert? Die length Eigenschaft von Array und ArrayBuffer ist mit einem vorzeichenlosen 32-bit Integer definiert, sodass nur Werte von 0 bis 232-1 gültig sind.

+ +

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.

+ +

Man sollte die Länge festlegen, bevor man die length Eigenschaft setzt, oder mit dem ersten Argument im Konstruktor.

+ +

Beispiele

+ +

Ungültige Fälle

+ +
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
+
+ +

Gültige Fälle

+ +
[ 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
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
ReferenceError: invalid assignment left-hand side
+
+ +

Fehlertyp

+ +

{{jsxref("ReferenceError")}}.

+ +

Was ist falsch gelaufen?

+ +

Es gibt irgendwo eine unerwartete Zuweisung. Das kann zum Beispiel durch eine nicht Übereinstimmung des Zuweisungsoperators und eines Vergleichsoperators hervorgerufen werden. Während ein einzelnes "=" Zeichen einer Variable einen Wert zuweist, vergleichen  "==" und "===" zwei Werte.

+ +

Beispiele

+ +
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
+ +

In dem if Statement wird ein Vergleichsoperator ("==") und für die Stringverkettung ein plus ("+") Operator benötigt.

+ +
if (Math.PI == 3 || Math.PI == 4) {
+  console.log('no way!');
+}
+
+var str = 'Hello, '
++ 'from the '
++ 'other side!';
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: invalid assignment to const "x" (Firefox)
+TypeError: Assignment to constant variable. (Chrome)
+TypeError: Redeclaration of const 'x' (IE/Edge)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

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 const Schlüsselwort deklariert.

+ +

Beispiel

+ +

Nicht valide Neudeklaration

+ +

Weist eine Konstanten erneut einen Wert zu. Führt zu einem Fehler.

+ +
const COLUMNS = 80;
+
+// ...
+
+COLUMNS = 120; // TypeError: invalid assignment to const `COLUMNS'
+ +

Den Fehler auflösen

+ +

Es gibt mehrere Optionen, um den Fehler zu vermeiden. Überprüfen Sie, was mit der betreffenden Konstante erreicht werden sollte.

+ +

Umbenennen

+ +

Wenn Sie eine andere Konstante deklarieren möchten, wählen Sie einen anderen Namen und benennen Sie ihn um. Dieser konstante Name ist dann in diesem Bereich vergeben.

+ +
const COLUMNS = 80;
+const WIDE_COLUMNS = 120;
+ +

const, let or var?

+ +

Verwenden Sie nicht const, wenn Sie keine Konstante deklarieren wollten. Vielleicht soll eine Blockvariable mit let oder eine globale Variable mit var deklariert werden.

+ +
let columns = 80;
+
+// ...
+
+let columns = 120;
+
+ +

Gültigkeitsbereich

+ +

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.

+ +
const COLUMNS = 80;
+
+function setupBigScreenEnvironment() {
+  const COLUMNS = 120;
+}
+ +

const und Unveränderlichkeit

+ +

Die const 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.

+ +
const obj = {foo: 'bar'};
+obj = {foo: 'baz'}; // TypeError: invalid assignment to const `obj'
+
+ +

Aber man kann die Eigenschaften der Variable verändern:

+ +
obj.foo = 'baz';
+obj; // Object { foo: "baz" }
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
RangeError: invalid date (Firefox)
+RangeError: invalid time value (Chrome)
+RangeError: Provided date is not in valid range (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("RangeError")}}

+ +

Was ist schief gelaufen?

+ +

Eine Zeichenfolge, die ein ungültiges Datum enthält, wurde  {{jsxref("Date")}} oder {{jsxref("Date.parse()")}} übergeben.

+ +

Beispiele

+ +

Nicht valide Fälle

+ +

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 RangeError: invalid date erzeugen, wie die folgenden Fällen in Firefox:

+ +
new Date('foo-bar 2014');
+new Date('2014-25-23').toISOString();
+new Date('foo-bar 2014').toString();
+
+ +

Das folgende gibt in Firefox {{jsxref("NaN")}} zurück.

+ +
Date.parse('foo-bar 2014'); // NaN
+ +

Für mehr Details, sollte die {{jsxref("Date.parse()")}} Dokumentation angesehen werden.

+ +

Valide Fälle

+ +
new Date('05 October 2011 14:48 UTC');
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: for-in loop head declarations may not have initializers (Firefox)
+
+SyntaxError: for-in loop variable declaration may not have an initializer. (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}} nur im Strict Mode.

+ +

Was ist falsch gelaufen?

+ +

Der Kopf einer for...in Schleife enthält einen Initialisierungsausdruck. Das ist, wenn eine Variable deklariert und mit einem Wert initialisiert wird (for(var i = 0 in obj)). Ohne Strict Mode wird die Initialisierung still ignoriert und verhält sich wie for(var i in obj). Im Strict Mode wird ein SyntaxError erzeugt.

+ +

Beispiele

+ +

Das Beispiel erzeugt einen SyntaxError:

+ +
"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
+
+ +

Valide for-in Schleife

+ +

Man kann die Initialisierung (i = 0) im Kopf der for-in Schleife entfernen.

+ +
"use strict";
+
+var obj = {a: 1, b: 2, c: 3 };
+
+for (var i in obj) {
+  console.log(obj[i]);
+}
+
+ +

Array Iteration

+ +

Die for...in Schleife sollte nicht für Array Iterationen benutzt werden. Zum Iterieren von durch ein {{jsxref("Array")}} sollte eine for Schleife statt einer for-in Schleife benutzt werden. Die for Schleife erlaubt es dann auch eine Initialisierung vorzunehmen:

+ +
var arr = [ "a", "b", "c" ]
+
+for (var i = 2; i < arr.length; i++) {
+  console.log(arr[i]);
+}
+
+// "c"
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

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

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was falsch gelaufen ist?

+ +

Der Kopf einer for...of Schleife enthält einen Initialisierungsausdruck. Das ist eine Variable die deklariert und initialisiert wird |for (var i = 0 of iterable)|. Dieses ist nicht erlaubt in for...of Schleifen. Manchmal ist eine for Schleife gemeint, die eine Initialisierung erlaubt.

+ +

Beispiele

+ +

Nicht valide for...of Schleife

+ +
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
+ +

Valide for...of Schleife

+ +

Man muss die Initialisierung (value = 50) im Kopf der for...of Schleife entfernen. Wenn 50 als Offset gedacht ist, kann man eine Addition in den Körper der Schleife verschieben, wie im folgenden Beispiel:

+ +
let iterable = [10, 20, 30];
+
+for (let value of iterable) {
+  value += 50;
+  console.log(value);
+}
+// 60
+// 70
+// 80
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

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

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Der instanceof Operator erwartet als rechten Operand einen Konstruktorobjekt, z. B. ein Objekt, welches eine prototype Eigenschaft hat und aufrufbar ist.

+ +

Beispiele

+ +
"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
+
+ +

Um diesen Fehler zu beheben, kann entweder der instanceof Operator durch einen typeof Operator ersetzt werden, oder man muss sicher stellen, dass ein Funktionsname statt einem Resultat seines Aufrufes benutzt werden.

+ +
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
+
+ +

Siehe auch

+ + + +

 

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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: 'x' is not iterable (Firefox, Chrome)
+TypeError: 'x' is not a function or its return value is not iterable (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Der Wert, welcher auf der rechten Seite von for…of oder als Argument einer Funktion wie {{jsxref("Promise.all")}} oder {{jsxref("TypedArray.from")}} ist kein iterierbares Objekt. Ein iterierbares Objekt kann vom Standardtypen wie {{jsxref("Array")}}, {{jsxref("String")}} oder {{jsxref("Map")}} sein oder ein Objekt, welches das iterable Protokoll implementiert.

+ +

Beispiele

+ +

Über Objekteigenschaften iterieren

+ +

In JavaScript sind {{jsxref("Object", "Objekte")}} nicht iterierbar, außer sie implementieren das iterable Protokoll. Demnach kann man for…of nicht für das Iterieren von Objekteigenschaften benutzen.

+ +
var obj = { 'France': 'Paris', 'England': 'London' };
+for (let p of obj) { // TypeError: obj is not iterable
+    // …
+}
+
+ +

Stattdessen kann man {{jsxref("Object.keys")}} oder {{jsxref("Object.entries")}} benutzen, um über die Eigenschaften oder Einträge zu iterieren.

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

Eine andere Option ist in diesem Fall der Einsatz einer {{jsxref("Map")}}:

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

Über einen Generator iterieren

+ +

Generatoren sind Funktionen welche aufgerufen werden, um ein iterierbares Objekt zu produzieren.

+ +
function* generate(a, b) {
+  yield a;
+  yield b;
+}
+
+for (let x of generate) // TypeError: generate is not iterable
+    console.log(x);
+
+ +

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.

+ +
function* generate(a, b) {
+    yield a;
+    yield b;
+}
+
+for (let x of generate(1,2))
+    console.log(x);
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
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
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

{{jsxref("JSON.parse()")}} übersetzt einen String zu JSON. Dieser String muss eine gültiges JSON enthalten. Ist die Syntax fehlerhaft, wird dieser Error ausgegeben.

+ +

Beispiele

+ +

JSON.parse() erlaubt keine angehängten Kommata

+ +

Beide Zeilen werden einen SyntaxError erzeugen:

+ +
JSON.parse('[1, 2, 3, 4,]');
+JSON.parse('{"foo": 1,}');
+// SyntaxError JSON.parse: unexpected character
+// at line 1 column 14 of the JSON data
+
+ +

Das letzte trennende Komma muss in JSON vermieden werden:

+ +
JSON.parse('[1, 2, 3, 4]');
+JSON.parse('{"foo": 1}');
+ +

Eigenschaftsnamen müssen Strings mit doppelten Anführungszeichen sein

+ +

Man kann keine einfachen Anführungszeichen für Eigenschaften benutzen (wie 'foo').

+ +
JSON.parse("{'foo': 1}");
+// SyntaxError: JSON.parse: expected property name or '}'
+// at line 1 column 2 of the JSON data
+ +

Stattdessen muss "foo" benutzt werden:

+ +
JSON.parse('{"foo": 1}');
+ +

Führende Nullen und Dezimalpunkte

+ +

Man kann keine führenden Nullen (wie 01) benutzen. Nach Dezimalpunkten muss mindestens eine Stelle stehen.

+ +
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
+
+ +

Stattdessen schreibe man nur 1, ohne eine Null (also 1, statt 01) und nutze mindestens eine Ziffer nach dem Dezimalpunkt:

+ +
JSON.parse('{"foo": 1}');
+JSON.parse('{"foo": 1.0}');
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: malformed formal parameter (Firefox)
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Es existiert ein Function() 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.

+ +

Die Liste der Parameter ist manchmal nicht valide. Das kann passieren, wenn versehendlich ein Schlüsselword, wie if oder var, 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.

+ +

OK, das löst mein Problem. Aber warum hast du das nicht sofort gesagt?

+ +

Zugegeben, die Formulierung in der Fehlermeldung ist etwas seltsam. "formal parameter" ist eine andere Art "Funktionsargument"  oder "Funktionsparameter" zu sagen. Und wir verwenden das Wort "malformed", weil alle Firefox-Ingenieure sehr große Fans des Romans Gothic Horror sind.

+ +

Beispiele

+ +

Invalide Fälle

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

Valide Fälle

+ +
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; };
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
URIError: malformed URI sequence (Firefox)
+URIError: URI malformed (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("URIError")}}

+ +

Was ist falsch gelaufen?

+ +

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.

+ +

Beispiele

+ +

Kodieren

+ +

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:

+ +
encodeURI('\uD800');
+// "URIError: malformed URI sequence"
+
+encodeURI('\uDFFF');
+// "URIError: malformed URI sequence"
+
+ +

Ein high-low Paar ist ok. Zum Beispiel:

+ +
encodeURI('\uD800\uDFFF');
+// "%F0%90%8F%BF"
+ +

Dekodieren

+ +

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:

+ +
decodeURIComponent('%E0%A4%A');
+// "URIError: malformed URI sequence"
+
+ +

Mit richiger Eingabe sollte es wie folgendermaßen aussehen:

+ +
decodeURIComponent('JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B');
+// "JavaScript_шеллы"
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing ] after element list
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}.

+ +

Was ist falsch gelaufen?

+ +

Der Syntax der Array-Initialisierung enthält einen Fehler. Wahrscheinlich fehlt eine schließende eckige Klammer ("]") oder ein Komma (",").

+ +

Beispiele

+ +

Unvollständige Arrayinitialisierung

+ +
var list = [1, 2,
+
+var instruments = [
+  'Ukulele',
+  'Guitar',
+  'Piano'
+};
+
+var data = [{foo: 'bar'} {bar: 'foo'}];
+
+ +

Richtig wäre:

+ +
var list = [1, 2];
+
+var instruments = [
+ 'Ukulele',
+ 'Guitar',
+ 'Piano'
+];
+
+var data = [{foo: 'bar'}, {bar: 'foo'}];
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing : after property id
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Wenn Objekte mit der Objektinitialisierungs-Syntax erstellt werden, wird ein (:) eingesetzt, um bei Eiegenschaften Schlüssel und Werte zu trennen.

+ +
var obj = { propertyKey: 'value' };
+
+ +

Examples

+ +

Doppelpunkt vs. Gleichzeichen

+ +

Der Code funktioniert nicht, weil das Gleichzeichen nicht in dieser Form in der Objektinitialisierungs-Syntax genutzt werden kann.

+ +
var obj = { propertyKey = 'value' };
+// SyntaxError: missing : after property id
+
+ +

Richtig währe der Einsatz eines Doppelpunktes oder der Einsatz von eckigen Klammern, um eine Eigenschaft nach dem erstellen des Objektes zuzuweisen.

+ +
var obj = { propertyKey: 'value' };
+
+// or alternatively
+
+var obj = { };
+obj['propertyKey'] = 'value';
+
+ +

Leere Eigenschaften

+ +

Man kann nicht wie im Beispiel leere Eigenschaften erzeugen:

+ +
var obj = { propertyKey; };
+// SyntaxError: missing : after property id
+
+ +

Wenn eine Eigenschaft ohne Wert definiert werden soll, muss {{jsxref("null")}} als Wert genutzt werden.

+ +
var obj = { propertyKey: null };
+ +

Berechnete Eigenschaften

+ +

Wenn ein Eigenschaftsname aus einem Ausdruck berechnet wird, müssen eckige Klammern genutzt werden. Anderfalls kann der Eigenschaftname nicht errechnet werden:

+ +
var obj = { 'b'+'ar': 'foo' };
+// SyntaxError: missing : after property id
+
+ +

Man muss den Ausdruck in [] setzen:

+ +
var obj = { ['b'+'ar']: 'foo' };
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing } after function body
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

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.

+ +

Beispiele

+ +

Schließende geschweifte Klammer vergessen

+ +

Oftmals fehlt eine geschweifte Klammer im Funktionsocde:

+ +
var charge = function() {
+  if (sunny) {
+    useSolarCells();
+  } else {
+    promptBikeRide();
+};
+
+ +

Richtig wäre:

+ +
var charge = function() {
+  if (sunny) {
+    useSolarCells();
+  } else {
+    promptBikeRide();
+  }
+};
+ +

Es kann deutlich verwirrender sein, wenn {{Glossary("IIFE")}}, Closures, oder andere Konstrukte, die viele verschiedene Klammern benutzt, eingesetzt werden, wie zum Beispiel:

+ +
(function() { if (true) { return false; } );
+
+ +

Oftmals hilft verschiedenes Einrücken oder doppeltes Prüfen der Einrückung, um den Fehler zu finden.

+ +
(function() {
+  if (true) {
+    return false;
+  }
+});
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing } after property list
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Es gibt irgendwo in der Objektinitialisierungs-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.

+ +

Beispiele

+ +

Vergessenes Komma

+ +

Häufig wird ein Komma bei der Objektinitialisierung vergessen:

+ +
var obj = {
+  a: 1,
+  b: { myProp: 2 }
+  c: 3
+};
+
+ +

Richtig wäre:

+ +
var obj = {
+  a: 1,
+  b: { myProp: 2 },
+  c: 3
+};
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing formal parameter (Firefox)
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

"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.

+ +

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.

+ +

Beispiele

+ +

Funktionsparameter müssen Bezeichner beim erstellen der Funktion sein. Alle diese Funktionsdeklarationen schlagen fehl, wenn ein Wert als Parameter benutzt wird:

+ +
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
+
+ +

Man muss einen Bezeichner für die Funktionsdeklarationen benutzen:

+ +
function square(number) {
+  return number * number;
+};
+
+function greet(greeting) {
+  return greeting;
+};
+
+function log(arg) {
+  console.log(arg)
+};
+ +

Danach kann man die Funktionen mit beliebigen Argumentwerten aufrufen:

+ +
square(2); // 4
+
+greet("Howdy"); // "Howdy"
+
+log({obj: "value"}); // Object { obj: "value" }
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing = in const declaration (Firefox)
+SyntaxError: Missing initializer in const declaration (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

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 const 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).

+ +

Beispiele

+ +

Fehlender Initialwert bei const

+ +

Anders wie bei var or let, muss man bei const Deklarationen einen Initialwert angeben. Folgendes erzeugt einen Fehler:

+ +
const COLUMNS;
+// SyntaxError: missing = in const declaration
+ +

Den Fehler beheben

+ +

Es gibt mehrere Möglichkeiten den Fehler zu beheben. Es muss geprüft werden, was mit der Konstanten erreicht werden soll.

+ +

Hinzufügen eines konstanten Wertes

+ +

Der Wert muss im gleichen Statement wie die Deklaration spezifiziert werden:

+ +
const COLUMNS = 80;
+ +

const, let oder var?

+ +

Es sollte kein const verwendet werden, wenn keine Konstante gemeint ist. Vielleicht ist eine Variable für den Block (let) oder eine global Variable (var) gemeint. Beide benötigen keinen Initialwert.

+ +
let columns;
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing name after . operator
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Der Punktoperator (.) wird für den Zugriff auf Eigenschaften 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 (+) genutzt werden.

+ +

Beispiele

+ +

Zugriff auf Eigenschaften

+ +

Zugriff auf Eigenschaften wird in JavaScript entweder mit einem Punkt oder eckigen Klammern erreicht, aber nicht beides. Eckige Klammern erlauben es auch Eigenschaftsnamen zu berechnen.

+ +
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
+
+ +

Um das Problem zu lösen, muss auf das Objekt wie folgt zugegriffen werden:

+ +
obj.foo.bar; // "baz"
+// or alternatively
+obj["foo"]["bar"]; // "baz"
+
+// computed properties require square brackets
+obj.foo["bar" + i]; // "baz2"
+
+ +

Zugriff auf Eigenschaften vs. Konkatenation

+ +

Wenn man aus einer anderen Programmiersprache kommt (z. B. {{Glossary("PHP")}}), ist es einfach den Punktoperator (.) und den Konkatenationsoperator (+) zu vermischen.

+ +
console.log("Hello" . "world");
+
+// SyntaxError: missing name after . operator
+ +

Stattdessen muss man das Pluszeichen für Konkatenation benutzen:

+ +
console.log("Hello" + "World");
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing ) after argument list
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}.

+ +

Was ist falsch gelaufen?

+ +

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. 

+ +

Beispiele

+ +

Bei einem fehlenden "+" Operator,  um zwei Strings zu konkatinieren,erwartet JavaScript , dass nur "PI: " der Parameter für die "log" Funktion ist. Darum sollte danach die Funktion mit einer abschliessenden Klammer abgeschlossen werden. 

+ +
console.log("PI: " Math.PI);
+// SyntaxError: missing ) after argument list
+
+ +

Man kann den Fehler korrigieren, indem man den "+" Operator hinzufügt:

+ +
console.log("PI: " + Math.PI);
+// "PI: 3.141592653589793"
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing ) after condition
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Es gibt einen Fehler beim schreiben einer if 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 if Schlüsselwort geschrieben werden, wie dieses:

+ +
if (condition) {
+  // do something if the condition is true
+}
+ +

Beispiele

+ +

Es könnte nur ein Versehen sein, weshalb man alle runden Klammern im Code gründlich überprüfen sollte.

+ +
if (3 > Math.PI {
+  console.log("wait what?");
+}
+
+// SyntaxError: missing ) after condition
+
+ +

Um das Problem zu beheben, muss eine schließende runde Klammer nach der Bedingung geschrieben werden.

+ +
if (3 > Math.PI) {
+  console.log("wait what?");
+}
+ +

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.

+ +
if (done is true) {
+ console.log("we are done!");
+}
+
+// SyntaxError: missing ) after condition
+
+ +

Stattdessen muss die richtige Vergleichsoperation benutzt werden. Zum Beispiel:

+ +
if (done === true) {
+ console.log("we are done!");
+}
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing ; before statement
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}.

+ +

Was ist falsch gelaufen?

+ +

Es fehlt irgendwo ein Semikolon (;). JavaScript Statements müssen durch ein Semikolon beendet werden. Einige Statements sind von der automatischen Semikolon Einfügung (ASI) betroffen, aber in diesem Fall muss man ein Semikolon geliefert werden, damit JavaScript den Quelltext korrekt lesen kann.

+ +

Meistens ist dieser Fehler eine Folge aus einem anderen Fehler, wie ein nicht escaptes Zeichen in einem String oder der falsche Einsatz von var.  Es kann auch sein, dass man zu viele runde Klammern benutzt. Wenn dieser Fehler auftritt, sollte die Syntax gründlich geprüft werden.

+ +

Beispiele

+ +

Nicht escapte Strings

+ +

Dieser Fehler kann leicht auftreten, wenn ein String nicht richtig escapt wird und die JavaScript-Umgebung schon das Ende eines Strings erwartet. Zum Beispiel:

+ +
var foo = 'Tom's bar';
+// SyntaxError: missing ; before statement
+ +

Man kann doppelte Anführungszeichen benutzen oder das Apostroph escapen:

+ +
var foo = "Tom's bar";
+var foo = 'Tom\'s bar';
+
+ +

Eigenschaften mit var deklarieren

+ +

Man kann Eigenschaften eines Objektes oder Arrays nicht mit einem var deklarieren.

+ +
var obj = {};
+var obj.foo = 'hi'; // SyntaxError missing ; before statement
+
+var array = [];
+var array[0] = 'there'; // SyntaxError missing ; before statement
+
+ +

Stattdessen muss das var Schlüsselwort vermieden werden:

+ +
var obj = {};
+obj.foo = 'hi';
+
+var array = [];
+array[0] = 'there';
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: Object.create requires more than 0 arguments
+TypeError: Object.setPrototypeOf requires more than 1 argument
+TypeError: Object.defineProperties requires more than 0 arguments
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}.

+ +

Was ist falsch gelaufen?

+ +

Es ist ein Fehler beim Aufrufen einer Funktion aufgetaucht. Es müssen mehr Argumente übergeben werden.

+ +

Beispiele

+ +

Die {{jsxref("Object.create()")}} Methode benötigt mindestens ein Argument und die {{jsxref("Object.setPrototypeOf()")}} Methode benötigt mindestens zwei Argumente:

+ +
var obj = Object.create();
+// TypeError: Object.create requires more than 0 arguments
+
+var obj = Object.setPrototypeOf({});
+// TypeError: Object.setPrototypeOf requires more than 1 argument
+
+ +

Dieser Fehler kann behoben werden, indem {{jsxref("null")}} als Eigenschaft gesetzt wird:

+ +
var obj = Object.create(null);
+
+var obj = Object.setPrototypeOf({}, null);
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
RangeError: repeat count must be non-negative (Firefox)
+RangeError: Invalid count value (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("RangeError")}}

+ +

Was ist falsch gelaufen?

+ +

Die {{jsxref("String.prototype.repeat()")}} Methode wurde benutzt. Sie hat einen count 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, +∞).

+ +

Beispiele

+ +

Falsche Fälle

+ +
'abc'.repeat(-1); // RangeError
+ +

Richtige Fälle

+ +
'abc'.repeat(0);    // ''
+'abc'.repeat(1);    // 'abc'
+'abc'.repeat(2);    // 'abcabc'
+'abc'.repeat(3.5);  // 'abcabcabc' (count will be converted to integer)
+
+ +

Siehe auch

+ + 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 +--- +
{{JSSidebar("Errors")}}
+ +

Fehlermeldung

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

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Ein Objekt wird erwartete aber nicht übergeben. {{jsxref("null")}} ist kein Objekt und funktioniert nicht. In dieser Situation wird ein normales Objekt erwartet.

+ +

Beispiele

+ +

Eigehscgaftsbeschreibung erwartet

+ +

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:

+ +
Object.defineProperty({}, 'key', 1);
+// TypeError: 1 is not a non-null object
+
+Object.defineProperty({}, 'key', null);
+// TypeError: null is not a non-null object
+
+ +

Ein valides Beschreibungsobjekt kann wie folgendes aussehen:

+ +
Object.defineProperty({}, 'key', { value: 'foo', writable: false });
+
+ +

WeakMap und WeakSet Objekte benötigen Objektschlüssel

+ +

{{jsxref("WeakMap")}} und {{jsxref("WeakSet")}} Objekte speichern Objektschlüssel. Man kann keine anderen Schlüssel verwenden.

+ +
var ws = new WeakSet();
+ws.add('foo');
+// TypeError: "foo" is not a non-null object
+ +

Stattdessen sollte folgendes verwendet werden:

+ +
ws.add({foo: 'bar'});
+ws.add(window);
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: null has no properties
+TypeError: undefined has no properties
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}.

+ +

Was ist falsch gelaufen?

+ +

Weder {{jsxref("null")}} noch {{jsxref("undefined")}} besitzen Eigenschaften auf die man zugreifen könnte.

+ +

Beispiele

+ +
null.foo;
+// TypeError: null has no properties
+
+undefined.bar;
+// TypeError: undefined has no properties
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: missing variable name (Firefox)
+SyntaxError: Unexpected token = (Chrome)
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

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! Dinge zu benennen ist so schwer.

+ +

Beispiele

+ +

Ein Variablenname fehlt

+ +
var = "foo";
+
+ +

Es ist schwer gute Variablennamen zu vergeben. Das geht allen so.

+ +
var ohGodWhy = "foo";
+ +

Reservierte Schlüsselwörter können kein Variablenname sein

+ +

Es gibt ein paar Namen, die reservierte Schlüsselwörter sind. Diese kann man nicht benutzen.

+ +
var debugger = "whoop";
+// SyntaxError: missing variable name
+
+ +

Deklarieren von mehreren Variablen

+ +

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?

+ +
var x, y = "foo",
+var x, = "foo"
+
+var first = document.getElementById('one'),
+var second = document.getElementById('two'),
+
+// SyntaxError: missing variable name
+
+ +

Die korrigierte Version:

+ +
var x, y = "foo";
+var x = "foo";
+
+var first = document.getElementById('one');
+var second = document.getElementById('two');
+ +

Arrays

+ +

{{jsxref("Array")}}-Literale in JavaScript benötigen eckige Klammern um die Werte. Folgendes funktioniert nicht:

+ +
var arr = 1,2,3,4,5;
+// SyntaxError: missing variable name
+
+ +

Richtig ist:

+ +
var arr = [1,2,3,4,5];
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: can't delete non-configurable array element (Firefox)
+TypeError: Cannot delete property '2' of [object Array] (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Es wurde versucht die Länge eines Arrays zu kürzen obwohl eines der Arrayelemente nicht Konfigurierbar(non-configurable) ist. Beim Kürzen eines Arrays werden die Elemente hinter der neuen Länge gelöscht, was in dieser Situation nicht funktioniert.

+ +

Das configurable Attribut kontrolliert, ob eine Eigenschaft von einem Objekt gelöscht werden kann und seine Attribute (anders als writable) geändert werden können.

+ +

Eigenschaften von einem Objekt, dass von einem Array-Initialisierer erstellt wurden, sind konfigurierbar. Immer, wenn zum Beispiel {{jsxref("Object.defineProperty()")}} eingesetzt wird, ist die Eigenschaft nicht ohne weiteres konfigurierbar.

+ +

Beispiele

+ +

Nicht konfigurierbare Eigenschaften mit Object.defineProperty erstellen

+ +

Die {{jsxref("Object.defineProperty()")}} Funktion erstellt nicht konfiguriertbare Eigenschaften wenn sie nicht extra als konfigurierbar spezifiziert sind.

+ +
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
+
+ +

Die Elemente müssen als Konfigurierbar eingestellt werden, wenn das Array später im Quelltext gekürzt werden soll.

+ +
var arr = [];
+Object.defineProperty(arr, 0, {value: 0, configurable: true});
+Object.defineProperty(arr, 1, {value: "1", configurable: true});
+
+arr.length = 1;
+
+ +

Ein Array versiegeln (seal)

+ +

Die {{jsxref("Object.seal()")}} Funktion markiert alle existirenden Elements als nicht Konfugurierbar.

+ +
var arr = [1,2,3];
+Object.seal(arr);
+
+arr.length = 1;
+// TypeError: can't delete non-configurable array element
+
+ +

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.

+ +
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
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
RangeError: {0} is not a valid code point (Firefox)
+RangeError: Invalid code point {0} (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("RangeError")}}

+ +

Was ist falsch gelaufen?

+ +

Die {{jsxref("String.fromCodePoint()")}} Methode erwartet gültige Codepoint.

+ +

Ein Codepoint  ist ein Wert im Unicode Coderaum, der als Integer im Wertebereich zwischen 0 und 0x10FFFF liegt.

+ +

Die Verwendung von {{jsxref("NaN")}} , negativen Integern (-1), nicht Integern (3.14) und Werten die größer als 0x10FFFF (1114111) sind, werden einen Fehler bei dieser Methode produzieren.

+ +

Beispiele

+ +

Ungültige Fälle

+ +
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
+ +

Gültige Fälle

+ +
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"
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
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
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

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 new Operators.

+ +

Es gibt viele globale Objekte, wie {{jsxref("String")}} oder {{jsxref("Array")}}, welche mittels new erstellt werden können. Jedoch funktioniert das bei einigen Objekten nicht und deren Eigenschaften und Methoden sind statisch.

+ +

Die folgenden Standard build-in Objekte sind keine Konstruktoren: {{jsxref("Math")}}, {{jsxref("JSON")}}, {{jsxref("Symbol")}}, {{jsxref("Reflect")}}, {{jsxref("Intl")}}, {{jsxref("SIMD")}}, {{jsxref("Atomics")}}.

+ +

Generelle Funktionen können ebenso nicht als Konstruktor verwendet werden.

+ +

Beispiele

+ +

Ungültige Fälle

+ +
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
+
+ +

Ein car Konstruktor

+ +

Stellen Sie sich vor, Sie erstellen ein Objekt vom Typ vars. Sie wollen dieses Objekt als Car bezeichen und es soll Eigenschaften für make, model und year besitzt. Um dies zu erreichen, schreiben Sie die folgende Funktion:

+ +
function Car(make, model, year) {
+  this.make = make;
+  this.model = model;
+  this.year = year;
+}
+
+ +

Jetzt können Sie wie folgt ein Objekt mit dem Namen mycar erstellen:

+ +
var mycar = new Car('Eagle', 'Talon TSi', 1993);
+ +

Promises

+ +

Bei Rückgabe eines Promises, welches sofort im Status resolved oder rejected ist, brauchen Sie kein neues Promise mit new Promise(...) erstellen und damit zu arbeiten. 

+ +

Folgendes ist nicht erlaubt (der Promise Konstruktor wird nicht korrekt aufgerufen) und wirft eine TypeError: this is not a constructor Exception.

+ +
return new Promise.resolve(true);
+
+ +

Verwenden Sie stattdessen Promise.resolve() oder die statische Methode Promise.reject():

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

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: "x" is not a function
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}.

+ +

Was ist falsch gelaufen?

+ +

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.

+ +

Vielleicht ist ein Tippfehler im Funktionsnamen. Manchmal besitzt das aufgerufene Objekt eine Funktion aber auch nicht. Zum Beispiel besitzen JavaScript Objekte keine map Funktion, aber JavaScript Arrays haben diese Funktion.

+ +

Es gibt viele eingebaute Funktionen, die eine (Callback-) Funktion benötigen. Es muss eine Funktion bereitgestellt werden, damit diese Methoden normal funktionieren:

+ + + +

Beispiele

+ +

Ein Schreibfehler im Funktionsnamen

+ +

In diesem Fall passiert es viel zu oft, dass im Name ein Schreibfehler enthält:

+ +
var x = document.getElementByID('foo');
+// TypeError: document.getElementByID is not a function
+
+ +

Der korrekte Funktionsname ist getElementById:

+ +
var x = document.getElementById('foo');
+
+ +

Funktion wird auf dem falschen Objekt aufgerufen

+ +

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.

+ +
var obj = {a: 13, b: 37, c: 42};
+
+obj.map(function(num) {
+  return num * 2;
+});
+
+// TypeError: "x" is not a function
+ +

Stattdessen muss ein Array verwendet werden:

+ +
var numbers = [1, 4, 9];
+
+numbers.map(function(num) {
+  return num * 2;
+});
+
+// Array [2, 8, 18]
+
+ +

Funktionen teilen einen Namen mit einer existierenden Eigenschaft

+ +

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.

+ +
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
+
+ +

Stattdessen kann ein anderer Eigenschaftsname benutzt werden:

+ +
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' }
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
ReferenceError: "x" is not defined
+
+ +

Fehlertyp

+ +

{{jsxref("ReferenceError")}}.

+ +

Was ist falsch gelaufen?

+ +

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.

+ +
+

Hinweis: 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.

+
+ +

Beispiele

+ +

Variable nicht deklariert

+ +
foo.substring(1); // ReferenceError: foo is not defined
+
+ +

Die "foo" Variable ist nirgends deklariert. Die Variable muss ein String sein, damit die Methode {{jsxref("String.prototype.substring()")}} funktioniert.

+ +
var foo = "bar";
+foo.substring(1); // "ar"
+ +

Falscher Gültigkeitsbereich

+ +

Eine Variable muss im aktuellem Kontext verfügbar sein. Variablen, die innerhalb einer Funktion definiert sind, können nicht von außerhalb erreicht werden, da diese nur im Gültigkeitsbereich der Funktion existieren.

+ +
function numbers() {
+  var num1 = 2,
+      num2 = 3;
+  return num1 + num2;
+}
+
+console.log(num1); // ReferenceError "num1" is not defined.
+ +

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.

+ +
var num1 = 2,
+    num2 = 3;
+
+function numbers() {
+  return num1 + num2;
+}
+
+console.log(numbers()); // 5
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

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

Fehlertyp

+ +

{{jsxref("RangeError")}}

+ +

Was ist falsch gelaufen?

+ +

Das übergebene Argument für die Genauigkeit ist, für einer der folgenden Funktionen, ausserhalb des gültigen Bereiches:

+ + + +

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.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
MethodFirefox (SpiderMonkey)Chrome, Opera (V8)
{{jsxref("Number.prototype.toExponential()")}}0 bis 1000 bis 20
{{jsxref("Number.prototype.toFixed()")}}-20 bis1000 bis 20
{{jsxref("Number.prototype.toPrecision()")}}1 bis 1001 bis 21
+ +

Beispiele

+ +

Ungültige Fälle

+ +
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
+
+ +

Gültige Fälle

+ +
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
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Error: Permission denied to access property "x"
+
+ +

Fehlertyp

+ +

{{jsxref("Error")}}.

+ +

Was ist falsch gelaufen?

+ +

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 Same-Origin Policy verletzt.

+ +

Beispiele

+ +
<!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>
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

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

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Die globale Variable oder Objekteigenschaften werden als nur lesbare Eigenschaften definiert (technisch wird das mit der writable Eigenschaft erreicht).

+ +

Der Fehler tritt nur im strict mode auf. Im normalen Modus wird eine Zuweisung still ignoriert.

+ +

Beispiele

+ +

Nicht valide Fälle

+ +

Nur lesbare Eigenschaften sind nicht sehr weit verbreitet, aber sie können mit {{jsxref("Object.defineProperty()")}} oder {{jsxref("Object.freeze()")}} erstellt werden.

+ +
'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
+
+ +

Zudem gibt es ein paar standard Eigenschaft in JavaScript, die nicht überschrieben werden können. Da währen zum Beispiel mathematische Konstanten.

+ +
'use strict';
+Math.PI = 4;  // TypeError
+
+ +

Die globale Variable undefined ist auch nur lesbar, sodass der berüchtigte Fehler "undefined is not a function" nicht wie folgt umgangen werden kann:

+ +
'use strict';
+undefined = function() {};  // TypeError: "undefined" is read-only
+
+ +

Valide Fälle

+ +
'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)
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: redeclaration of formal parameter "x" (Firefox)
+SyntaxError: Identifier "x" has already been declared (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Der selbe Variablenname wird für einen Funktionsparameter benutzt und dann in einer let Zuweisung im Funktionskörper wieder neu deklariert. Das Neudeklarieren der gleichen Variablen in der selben Funktion oder im selben Block mit let ist in JavaScript nicht erlaubt.

+ +

Beispiele

+ +

In diesem Fall wird der Parameter "arg" neu deklariert.

+ +
function f(arg) {
+  let arg = 'foo';
+}
+
+// SyntaxError: redeclaration of formal parameter "arg"
+
+ +

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 let Schlüsselwort weg lassen. Wenn eine neue Variable erstellt werden soll, muss sie umbenannt werden, damit es keine Konflikte mit dem Funktionsparameter mehr gibt.

+ +
function f(arg) {
+  arg = 'foo';
+}
+
+function f(arg) {
+  let bar = 'foo';
+}
+
+ +

Kompatibilitätshinweise

+ + + +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: reduce of empty array with no initial value
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

In JavaScript gibt es einige Reduktionsfunktionen:

+ + + +

Diese Funktionen haben den optionalen initialValue Parameter (welcher als erster Parameter beim ersten Aufruf der callback 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.

+ +

Beispiele

+ +

Nicht valide Fälle

+ +

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.

+ +
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.
+ +

Der gleiche Fehler kann bei einem Tippfehler passieren oder, bei einer unerwarteten Anzahl von Elementen in einer Liste.

+ +
var names = document.getElementsByClassName("names");
+var name_list = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name);
+
+ +

Valide Fälle

+ +

Diese Problem kann mit zwei Wegen gelöst werden.

+ +

Ein Weg ist es, einen initialValue als neutrales Element des Operators anzugeben, so wie 0 bei der Addition, 1 bei der Multiplikation oder ein leerer String bei einer Konkatination.

+ +
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
+
+ +

Ein anderer Weg ist es den Fall eines leeren Arrays schon vor dem Aufruf von reduce zu behandeln oder einen Dummywert als Initialwert in der callback-Funktion zu benutzen.

+ +
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.
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: "x" is a reserved identifier (Firefox)
+SyntaxError: Unexpected reserved word (Chrome)
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Reservierte Schlüsselwörter 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:

+ + + +

Die folgenden Schlüsselwörter führen nur im Strict Mode zu einem Fehler:

+ + + +

Beispiele

+ +

Reservierte Schlüsselwörter im Strict und Normalen Mode

+ +

Derenum Bezeichner ist generell reserviert.

+ +
var enum = { RED: 0, GREEN: 1, BLUE: 2 };
+// SyntaxError: enum is a reserved identifier
+
+ +

Im Strict Mode sind weitere Bezeichner reserviert.

+ +
"use strict";
+var package = ["potatoes", "rice", "fries"];
+// SyntaxError: package is a reserved identifier
+
+ +

Man muss die Variablen umbenennen.

+ +
var colorEnum = { RED: 0, GREEN: 1, BLUE: 2 };
+var list = ["potatoes", "rice", "fries"];
+ +

Ältere Browser aktualisieren

+ +

Wenn ein alter Browser eingesetzt wird, der zum Beispiel noch nicht let oder class implementiert, muss der Browser aktualisiert werden, so dass er diese neuen Sprachfunktionen unterstützt.

+ +
"use strict";
+class DocArchiver {}
+
+// SyntaxError: class is a reserved identifier
+// (throws in older browsers only, e.g. Firefox 44 and older)
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
RangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox)
+
+RangeError: Invalid count value (Chrome)
+
+ +

Fehlertyp

+ +

{{jsxref("RangeError")}}

+ +

Was ist falsch gelaufen?

+ +

Die {{jsxref("String.prototype.repeat()")}} Methode wurde benutzt. Sie hat einen count 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, +∞).

+ +

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 228 -1 (0xFFFFFFF).

+ +

Beispiele

+ +

Falsche Fälle

+ +
'abc'.repeat(Infinity); // RangeError
+'a'.repeat(2**28);      // RangeError
+
+ +

Richtige Fälle

+ +
'abc'.repeat(0);    // ''
+'abc'.repeat(1);    // 'abc'
+'abc'.repeat(2);    // 'abcabc'
+'abc'.repeat(3.5);  // 'abcabcabc' (count will be converted to integer)
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
Warning: unreachable code after return statement (Firefox)
+
+ +

Fehlertyp

+ +

Warnung

+ +

Was ist falsch gelaufen?

+ +

Nicht erreichbarer Code nach einem return Statement tritt in folgenden Fällen auf:

+ + + +

Wenn eine Anweisung nach einer gültigen return Anweisung existiert, dann wird diese Warnmeldung ausgegeben, um aufzuzeigen, das der nachfolgende Quellcode nie ausgeführt wird.

+ +

Warum sollte man Semikolons am Ende einer return Anweisung verwenden? Da im Falle einer return Anweisung ohne Semikolon, die Absicht des Entwicklers nicht klar ist. Es stellt sich die Frage, ob die Anweisung nach dem return als Rückgabewert der Methode zu sehen ist, oder sollte die Ausführung gleich beim return beendet werden. Hier zeigt die Warnung an, dass es sich um einen uneindeutige Situation handelt.

+ +

Warnungen werden nicht erzeugt wenn nach einem semikolonlosen return folgende Anweisungen folgen:

+ + + +

Beispiele

+ +

Fehlerfälle

+ +
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
+}
+
+ +

Gültige Fälle

+ +
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
+}
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
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
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}.

+ +

Was ist falsch gelaufen?

+ +

Eine "use strict" Direktive steht am Anfang einer Funktion, die einen der folgende Parameter hat:

+ + + +

Eine "use strict" Direktive ist am Anfang solcher Funktionen durch die ECMAScript Spezifikation nicht erlaubt.

+ +

Beispiele

+ +

Funktionsstatement

+ +

In diesem Fall hat die Funktion sum zwei Standardparameter a=1 und b=2:

+ +
function sum(a = 1, b = 2) {
+  // SyntaxError: "use strict" not allowed in function with default parameter
+  'use strict';
+  return a + b;
+}
+
+ +

Wenn die Funktion im Strict Mode sein soll und das Skript oder die umschließende FUnktion auch für den Strict Mode in Ordnung ist, kann man die "use strict" Direktive nach außen verschieben:

+ +
'use strict';
+function sum(a = 1, b = 2) {
+  return a + b;
+}
+
+ +

Funktionsausdruck

+ +

Bei eine Funktionsausdruck kann ein andere Workaround genutzt werden:

+ +
var sum = function sum([a, b]) {
+  // SyntaxError: "use strict" not allowed in function with destructuring parameter
+  'use strict';
+  return a + b;
+};
+
+ +

Dieses kann zu folgendem Ausdruck konvertiert werden:

+ +
var sum = (function() {
+  'use strict';
+  return function sum([a, b]) {
+    return a + b;
+  };
+})();
+
+ +

Pfeilfunktionen

+ +

Wenn eine Pfeilfunktion auf die this Variable zugreift, so kann eine umschließende Pfeilfunktion benutzt werden:

+ +
var callback = (...args) => {
+  // SyntaxError: "use strict" not allowed in function with rest parameter
+  'use strict';
+  return this.run(args);
+};
+
+ +

Dieses kann zu folgendem Ausdruck konvertiert werden:

+ +
var callback = (() => {
+  'use strict';
+  return (...args) => {
+    return this.run(args);
+  };
+})();
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
InternalError: too much recursion
+
+ +

Fehlertyp

+ +

{{jsxref("InternalError")}}.

+ +

Was ist falsch gelaufen?

+ +

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.

+ +

Beispiele

+ +

Diese rekursive Methode wird bis zur Abbruchbedingung 10 mal durchlaufen.

+ +
function schleife(x) {
+  if (x >= 10) // "x >= 10" ist die Abbruchsbedingung
+    return;
+  // zu wiederholende Codezeilen
+  schleife(x + 1); // rekursiver Methodenaufruf
+}
+schleife(0);
+ +

Wird die Abbruchsbedingung auf eine zu hohe Wert gesetzt, ist die Rekursionstiefe zu hoch und es wird einen Fehler erzeugt:

+ +
function boeseSchleife(x) {
+  if (x >= 1000000000000)
+    return;
+  // zu wiederholende Codezeilen
+  boeseSchleife(x + 1);
+}
+boeseSchleife(0);
+
+// InternalError: too much recursion
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: invalid arguments (Firefox)
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}

+ +

Was ist falsch gelaufen?

+ +

Der Typed Array Konstruktor erwartet entweder

+ + + +

um ein neues Typed Array zu erstelltn. Andere Argumente im Konstruktor erstellen kein valides Typed Array.

+ +

Beispiele

+ +

Typed Arrays, zum Beispiel ein {{jsxref("Uint8Array")}}, können nicht von einem String erstellt werden. Tatsächlich können String nicht in typisierten Arrays enthalten sein.

+ +
var ta = new Uint8Array("nope");
+// TypeError: invalid arguments
+
+ +

Verschiedene Wege um ein valides {{jsxref("Uint8Array")}} Objekt zu erstellen:

+ +
// 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]
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
ReferenceError: assignment to undeclared variable "x" (Firefox)
+ReferenceError: "x" is not defined (Chrome)
+ReferenceError: Variable undefined in strict mode (Edge)
+
+ +

Fehlertyp

+ +

{{jsxref("ReferenceError")}} Warnung nur im Strict mode.

+ +

Was ist falsch gelaufen?

+ +

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.

+ +

Drei Dinge über deklarierte und nicht deklarierte Variablen:

+ + + +

Mehr Details und Beispiele findet man auf der var Referenzseite.

+ +

Fehler mit nicht deklarierten Variablenzuweisungen gibt es nur im Strict Mode Code. Außerhalb davon wird die Warnung einfach Ignoriert.

+ +

Beispiele

+ +

Falsche Fälle

+ +

In diesem Fall ist die "bar" eine nicht deklarierte Variable.

+ +
function foo() {
+  'use strict';
+  bar = true;
+}
+foo(); // ReferenceError: assignment to undeclared variable bar
+
+ +

Richtige Fälle

+ +

Um "bar" zu einer deklarierten Variable zu machen, kann das Schlüsselwort var eingesetzt werden.

+ +
function foo() {
+  'use strict';
+  var bar = true;
+}
+foo();
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
ReferenceError: reference to undefined property "x" (Firefox)
+
+ +

Fehlertyp

+ +

{{jsxref("ReferenceError")}} Fehlermeldung tritt nur im  strikten Modus auf.

+ +

Was ist falsch gelaufen?

+ +

Es wird versucht auf eine Eigenschaft zuzugreifen, die nicht existiert. Es gibt zwei Arten um auf Eigenschaften zuzugreifen, siehe Eigenschaften Zugriffsfunktionen auf den Referenzseiten für weitere Details.

+ +

Fehler aufgrund von leeren Eigenschaftsreferenzen treten nur im Quellcode auf, der im strikten Modus geschrieben ist. Im Quellcode der nicht im strikten Modus geschrieben ist, wird der Fehler ohne Meldung ignoriert.

+ +

Beispiele

+ +

Ungültige Fälle

+ +

In diesem Fall ist die Eigenschaft "bar" undefiniert.

+ +
"use strict";
+
+var foo = {};
+foo.bar; // ReferenceError: reference to undefined property "bar"
+
+ +

Gültige Fälle

+ +

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

+ +
"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);
+}
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
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"
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Es wurde eine bestimmte Sprachenstruktur erwartet, aber etwas anderes wurde übermittelt. Es kann sich dabei um einen einfachen Tippfehler handeln.

+ +

Beispiele

+ +

Expression expected (Ausdruck erwartet)

+ +

Zum Beispiel sind Kommas am Ende eines Befehls nicht erlaubt.

+ +
for (let i = 0; i < 5,; i++) {
+  console.log(i);
+}
+// SyntaxError: expected expression, got ')'
+
+ +

Richtig wäre das Komma auszulassen oder ein weiteren Ausdruck hinzuzufügen:

+ +
for (let i = 0; i < 5; i++) {
+  console.log(i);
+}
+
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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
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
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}}.

+ +

Was ist falsch gelaufen?

+ +

Der Typ einer Variable ist unpassend. Dieser Fall tritt oft bei {{jsxref("undefined")}}- oder {{jsxref("null")}}-Werten auf.

+ +

Außerdem benötigen bestimmte Metodhen wie {{jsxref("Object.create()")}} oder {{jsxref("Symbol.keyFor()")}} einen bestimmten Typ, der bereitgestellt werden muss.

+ +

Beispiele

+ +

Ungültige Fälle

+ +
// 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
+
+ +

Den Fehler beheben?

+ +

Um den Nullzeiger auf undefined- oder null-Werte zu beheben, kann z. B. der "typeof"-Operator verwendt werden.

+ +
if (typeof foo !== 'undefined') {
+  // Nun wissen wir, dass foo definiert ist, und können weitermachen.
+}
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: function statement requires a name [Firefox]
+SyntaxError: Unexpected token ( [Chrome]
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Es gibt eine Funktionsstatement 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.

+ +

Beispiele

+ +

Statements vs Ausdrücke

+ +

Ein Funktionsstatement (oder Funktionsdeklaration) benötigt einen Namen. Folgendes funktioniert nicht:

+ +
function () {
+  return 'Hello world';
+}
+// SyntaxError: function statement requires a name
+
+ +

Man kann stattdessen ein Funktionsausdruck (Zuweisung) nutzen:

+ +
var greet = function() {
+  return 'Hello world';
+};
+ +

Manchmal soll auch eine auch eine IIFE (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:

+ +
(function () {
+
+})();
+ +

Funktionen mit Labeln

+ +

Wenn man ein Funktionslabel benutzt, muss ein Funktionsnamen nach dem function Schlüsselwort stehen. Folgendes funktioniert nicht:

+ +
function Greeter() {
+  german: function () {
+    return "Moin";
+  }
+}
+// SyntaxError: function statement requires a name
+
+ +

Das folgende funktioniert:

+ +
function Greeter() {
+  german: function g() {
+    return "Moin";
+  }
+}
+ +

Objektmethoden

+ +

Wenn man eine Methode für ein Objekt erstellen möchte, muss ein Objekt erstellt werden. Die folgende Syntax ohne einen Namen nach dem function Schlüsselwort ist zulässig.

+ +
var greeter = {
+  german: function () {
+    return "Moin";
+  }
+};
+ +

Callback Syntax

+ +

Zudem sollte die Syntax bei Callbackfunktionen geprüft werden. Komma- und Klammersetzung kann schnell schwierig werden.

+ +
promise.then(
+  function() {
+    console.log("success");
+  });
+  function() {
+    console.log("error");
+}
+// SyntaxError: function statement requires a name
+
+ +

Richtig ist folgendes:

+ +
promise.then(
+  function() {
+    console.log("success");
+  },
+  function() {
+    console.log("error");
+  }
+);
+
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
SyntaxError: unterminated string literal
+
+ +

Fehlertyp

+ +

{{jsxref("SyntaxError")}}

+ +

Was ist falsch gelaufen?

+ +

Es gibt irgendwo einen nicht beendeten {{jsxref("String")}}. Stringliterale müssen mit einfachen (') oder doppelten (") Anführungszeichen umschlossen sein. JavaScript unterscheidet nicht zwischen Strings, die mit einfachen oder doppelten Anführungszeichen umschlossen sind. Maskierte Sequenzen funktionieren in Strings mit einfachen und doppelten Anführungszeichen. Um den Fehler zu beheben, sollte folgendes überprüft werden:

+ + + +

Beispiele

+ +

MehrereZeilen

+ +

Man kann Strings nicht über mehrere Zeilen in JavaScript schreiben:

+ +
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
+ +

Stattdessen muss ein + Operator, ein Backslask oder ein Templateliteral eingesetzt werden. Die + Operator Variante sieht wie folgt aus:

+ +
var longString = 'This is a very long string which needs ' +
+                 'to wrap across multiple lines because ' +
+                 'otherwise my code is unreadable.';
+
+ +

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:

+ +
var longString = 'This is a very long string which needs \
+to wrap across multiple lines because \
+otherwise my code is unreadable.';
+
+ +

Eine andere Möglichkeit ist der Einsatz von Templateliteralen, welche in ECMAScript 2015 Umgebungen unterstützt werden:

+ +
var longString = `This is a very long string which needs
+                  to wrap across multiple lines because
+                  otherwise my code is unreadable.`;
+ +

Siehe auch

+ + 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 +--- +
{{jsSidebar("Errors")}}
+ +

Fehlermeldung

+ +
TypeError: variable "x" redeclares argument (Firefox)
+
+ +

Fehlertyp

+ +

{{jsxref("TypeError")}} Warnung nur im strict mode.

+ +

Was ist falsch gelaufen?

+ +

Der selbe Variablenname für einen Funktionsparameter und einer Neudeklaration mit einer var Zuweisung im Funktionskörper ist vorhanden. Dieses ist ein Namenskonflikt, weshalb JavaScript eine Warnung erzeugt.

+ +

Dieser Fehler ist eine Warnung, die nur im strict mode auftaucht. Ist man nicht im strict mode, so wird die Neudeklaration still ignoriert.

+ +

Beispiele

+ +

Nicht balider Fall

+ +

In diesem Fall wird die Variable "arg" neu deklariert.

+ +
'use strict';
+
+function f(arg) {
+  var arg = 'foo';
+}
+
+ +

Valider Fall

+ +

Um diese Warnung zu vermeiden kann das var Statement weggelassen werden, weil die Variable schon existiert. In anderen Fällen kann der Funktionsparameter oder die Variable umbenannt werden.

+ +
'use strict';
+
+function f(arg) {
+  arg = 'foo';
+}
+
+ +

Siehe auch

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