JavaScript => Reservierte Schlüsselwörter

Einführung

Bestimmte Wörter - sogenannte Schlüsselwörter - werden in JavaScript speziell behandelt. Es gibt eine Vielzahl verschiedener Arten von Schlüsselwörtern, die sich in verschiedenen Versionen der Sprache geändert haben.

Reservierte Schlüsselwörter

JavaScript verfügt über eine vordefinierte Sammlung reservierter Schlüsselwörter, die Sie nicht als Variablen, Bezeichnungen oder Funktionsnamen verwenden können.

ECMAScript 1

_{A - E}	_{E - R}	_{S - Z}
`break`	`export`	`super`
`case`	`extends`	`switch`
`catch`	`false`	`this`
`class`	`finally`	`throw`
`const`	`for`	`true`
`continue`	`function`	`try`
`debugger`	`if`	`typeof`
`default`	`import`	`var`
`delete`	`in`	`void`
`do`	`new`	`while`
`else`	`null`	`with`
`enum`	`return`

ECMAScript 2

24 zusätzliche reservierte Schlüsselwörter hinzugefügt. (Neue Ergänzungen in Fettdruck).

3 E4X

_{A - F}	_{F - P}	_{P - Z}
`abstract`	`final`	`public`
`boolean`	`finally`	`return`
`break`	`float`	`short`
`byte`	`for`	`static`
`case`	`function`	`super`
`catch`	`goto`	`switch`
`char`	`if`	`synchronized`
`class`	`implements`	`this`
`const`	`import`	`throw`
`continue`	`in`	`throws`
`debugger`	`instanceof`	`transient`
`default`	`int`	`true`
`delete`	`interface`	`try`
`do`	`long`	`typeof`
`double`	`native`	`var`
`else`	`new`	`void`
`enum`	`null`	`volatile`
`export`	`package`	`while`
`extends`	`private`	`with`
`false`	`protected`

ECMAScript 5 / 5.1

Seit ECMAScript 3 hat sich nichts geändert.

ECMAScript 5 entfernte int , byte , char , goto , long , final , float , short , double , native , throws , boolean , abstract , volatile , transient und synchronized ; es fügte let und yield .

_{A - F}	_{F - P}	_{P - Z}
`break`	`finally`	`public`
`case`	`for`	`return`
`catch`	`function`	`static`
`class`	`if`	`super`
`const`	`implements`	`switch`
`continue`	`import`	`this`
`debugger`	`in`	`throw`
`default`	`instanceof`	`true`
`delete`	`interface`	`try`
`do`	`let`	`typeof`
`else`	`new`	`var`
`enum`	`null`	`void`
`export`	`package`	`while`
`extends`	`private`	`with`
`false`	`protected`	`yield`

implements , let , private , public , interface , package , protected , static und yield sind nur im strikten Modus nicht zulässig .

eval und arguments sind keine reservierten Wörter, sie verhalten sich jedoch im strikten Modus .

ECMAScript 6 / ECMAScript 2015

_{A - E}	_{E - R}	_{S - Z}
`break`	`export`	`super`
`case`	`extends`	`switch`
`catch`	`finally`	`this`
`class`	`for`	`throw`
`const`	`function`	`try`
`continue`	`if`	`typeof`
`debugger`	`import`	`var`
`default`	`in`	`void`
`delete`	`instanceof`	`while`
`do`	`new`	`with`
`else`	`return`	`yield`

Zukünftig reservierte Keywords

Die folgenden sind als zukünftige Schlüsselwörter von der ECMAScript-Spezifikation reserviert. Sie verfügen derzeit über keine speziellen Funktionen, können jedoch zu einem späteren Zeitpunkt verwendet werden, sodass sie nicht als Bezeichner verwendet werden können.


`enum`

Die folgenden sind nur reserviert, wenn sie im strengen Moduscode gefunden werden:


`implements`	`package`	`public`
`interface`	`private`	"statisch"
`let`	`protected`

Zukünftig reservierte Schlüsselwörter in älteren Standards

Die folgenden sind als zukünftige Schlüsselwörter durch ältere ECMAScript-Spezifikationen (ECMAScript 1 bis 3) reserviert.


`abstract`	`float`	`short`
`boolean`	`goto`	`synchronized`
`byte`	`instanceof`	`throws`
`char`	`int`	`transient`
`double`	`long`	`volatile`
`final`	`native`

Darüber hinaus können die Literale null, wahr und falsch nicht als Bezeichner in ECMAScript verwendet werden.

Aus dem Mozilla Developer Network .

Bezeichner und Bezeichnernamen

In Bezug auf reservierte Wörter unterscheidet man geringfügig zwischen den "Bezeichnern", die für Variablen- oder Funktionsnamen verwendet werden, und den "Bezeichnernamen", die als Eigenschaften von zusammengesetzten Datentypen zulässig sind.

Beispielsweise führt Folgendes zu einem ungültigen Syntaxfehler:

var break = true;

Nicht abgeholter SyntaxError: Unerwarteter Tokenbruch

Der Name gilt jedoch als Eigenschaft eines Objekts (ab ECMAScript 5+):

var obj = {
    break: true
};
console.log(obj.break);

Um aus dieser Antwort zu zitieren:

Aus der ECMAScript® 5.1-Sprachspezifikation :

Abschnitt 7.6
Bezeichner Bezeichnungen sind Token, die gemäß der im Abschnitt „Bezeichner“ in Kapitel 5 des Unicode-Standards angegebenen Grammatik interpretiert werden, mit einigen kleinen Änderungen. Ein Identifier ist ein IdentifierName , der kein ReservedWord (siehe 7.6.1 ).

Syntax

Identifier ::
  IdentifierName but not ReservedWord

Nach Angabe ist ein ReservedWord :

Abschnitt 7.6.1
Ein reserviertes Wort ist ein IdentifierName , der nicht als Identifier .
ReservedWord :: 
  Keyword
  FutureReservedWord
  NullLiteral
  BooleanLiteral

Dazu gehören Schlüsselwörter, zukünftige Schlüsselwörter, null und boolesche Literale. Die vollständige Liste der Schlüsselwörter finden Sie in Abschnitt 7.6.1 und Literale in Abschnitt 7.8 .

Das obige (Abschnitt 7.6) impliziert, dass IdentifierName s ReservedWord s sein kann und aus der Spezifikation für Objektinitialisierer :

Abschnitt 11.1.5

Syntax

ObjectLiteral :
  { }
  { PropertyNameAndValueList }
  { PropertyNameAndValueList , }

Wo PropertyName ist, laut Spezifikation:

PropertyName :
  IdentifierName
  StringLiteral
  NumericLiteral

Wie Sie sehen, kann ein PropertyName ein IdentifierName , wodurch ReservedWord als PropertyName s verwendet werden können. Das sagt uns schlüssig, dass es durch Spezifikation erlaubt ist, ReservedWord Werte wie class und var als PropertyName Werte zu verwenden, die wie String-Literale oder numerische Literale nicht angegeben sind.

Weitere Informationen finden Sie in Abschnitt 7.6 - Bezeichner und Bezeichner.

Hinweis: Der Syntax-Highlighter in diesem Beispiel hat das reservierte Wort erkannt und es dennoch hervorgehoben. Während das Beispiel gültig ist, können Javascript-Entwickler von Compiler / Transpiler-, Linter- und Minifier-Tools herausgefunden werden, die anders argumentieren.

Modified text is an extract of the original Stack Overflow Documentation

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

JavaScript
Reservierte Schlüsselwörter

Suche…