JavaScript => Zarezerwowane słowa kluczowe

Wprowadzenie

Niektóre słowa - tak zwane słowa kluczowe - są traktowane specjalnie w JavaScript. Istnieje mnóstwo różnych rodzajów słów kluczowych, które zmieniły się w różnych wersjach języka.

Zarezerwowane słowa kluczowe

JavaScript ma predefiniowany zbiór zastrzeżonych słów kluczowych, których nie można używać jako zmiennych, etykiet lub nazw funkcji.

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

Dodano 24 dodatkowe zastrzeżone słowa kluczowe. (Nowe dodatki pogrubione).

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

Nie było zmian od ECMAScript 3 .

ECMAScript 5 usunął int , byte , char , goto , long , final , float , short , double , native , throws , boolean , abstract , volatile , transient i synchronized ; dodało let i 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 i yield są niedozwolone tylko w trybie ścisłym .

eval i arguments nie są zastrzeżonymi słowami, ale zachowują się jak w trybie ścisłym .

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`

Przyszłe zastrzeżone słowa kluczowe

Poniższe są zastrzeżone jako przyszłe słowa kluczowe według specyfikacji ECMAScript. Nie mają one obecnie żadnych specjalnych funkcji, ale mogą w przyszłości, więc nie można ich używać jako identyfikatorów.


`enum`

Następujące są zastrzeżone tylko wtedy, gdy zostaną znalezione w kodzie trybu ścisłego:


`implements`	`package`	`public`
`interface`	`private`	„statyczny”
`let`	`protected`

Przyszłe zastrzeżone słowa kluczowe w starszych standardach

Następujące słowa kluczowe są zastrzeżone jako przyszłe słowa kluczowe według starszych specyfikacji ECMAScript (ECMAScript 1 do 3).


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

Ponadto literałów null, true i false nie można używać jako identyfikatorów w ECMAScript.

Z sieci deweloperów Mozilla .

Identyfikatory i nazwy identyfikatorów

W odniesieniu do słów zastrzeżonych istnieje niewielkie rozróżnienie między „Identyfikatorami” stosowanymi w przypadku nazw zmiennych lub funkcji a „Nazwami identyfikatorów” dozwolonymi jako właściwości złożonych typów danych.

Na przykład poniższe spowoduje niepoprawny błąd składniowy:

var break = true;

Uncaught SyntaxError: Nieoczekiwana przerwa tokena

Jednak nazwa jest ważna jako właściwość obiektu (od ECMAScript 5+):

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

Cytując z tej odpowiedzi :

Ze specyfikacji języka ECMAScript® 5.1 :

Sekcja 7.6
Nazwy identyfikatorów to tokeny interpretowane zgodnie z gramatyką podaną w sekcji „Identyfikatory” w rozdziale 5 standardu Unicode, z pewnymi niewielkimi modyfikacjami. Identifier to nazwa IdentifierName która nie jest ReservedWord (patrz 7.6.1 ).

Składnia

Identifier ::
  IdentifierName but not ReservedWord

Zgodnie ze specyfikacją ReservedWord to:

Sekcja 7.6.1
Słowo zastrzeżone to IdentifierName , którego nie można użyć jako Identifier .
ReservedWord :: 
  Keyword
  FutureReservedWord
  NullLiteral
  BooleanLiteral

Dotyczy to słów kluczowych, przyszłych słów kluczowych, literału null i literału logicznego. Pełna lista słów kluczowych znajduje się w sekcji 7.6.1, a literały w sekcji 7.8 .

Powyższe (Sekcja 7.6) implikuje, że IdentifierName s może być ReservedWord i ze specyfikacji dla inicjalizatorów obiektów :

Sekcja 11.1.5

Składnia

ObjectLiteral :
  { }
  { PropertyNameAndValueList }
  { PropertyNameAndValueList , }

Gdzie jest nazwa PropertyName , według specyfikacji:

PropertyName :
  IdentifierName
  StringLiteral
  NumericLiteral

Jak widać, PropertyName może być IdentifierName , dzięki czemu ReservedWord może być PropertyName . To jednoznacznie mówi nam, że zgodnie ze specyfikacją dozwolone jest, aby ReservedWord takie jak class i var jak PropertyName nie były cytowane, tak jak literały łańcuchowe lub literały liczbowe.

Aby przeczytać więcej, zobacz Sekcja 7.6 - Nazwy identyfikatorów i identyfikatory.

Uwaga: zakreślacz składni w tym przykładzie zauważył zarezerwowane słowo i nadal je podświetlił. Chociaż ten przykład jest prawidłowy, programiści JavaScript mogą zostać złapani przez niektóre narzędzia kompilatora / transpilatora, linter i minifier, które twierdzą inaczej.

Modified text is an extract of the original Stack Overflow Documentation

Licencjonowany na podstawie CC BY-SA 3.0

Nie związany z Stack Overflow

JavaScript
Zarezerwowane słowa kluczowe

Szukaj…