JavaScript => Gereserveerde zoekwoorden

Invoering

Bepaalde woorden - zogenaamde trefwoorden - worden speciaal behandeld in JavaScript. Er is een overvloed aan verschillende soorten zoekwoorden en deze zijn in verschillende versies van de taal gewijzigd.

Gereserveerde zoekwoorden

JavaScript heeft een vooraf gedefinieerde verzameling gereserveerde zoekwoorden die u niet als variabelen, labels of functienamen kunt gebruiken.

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 extra gereserveerde zoekwoorden toegevoegd. (Nieuwe toevoegingen vetgedrukt).

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

Er was geen verandering sinds ECMAScript 3 .

ECMAScript 5 verwijderd int , byte , char , goto , long , final , float , short , double , native , throws , boolean , abstract , volatile , transient en synchronized ; het voegde let en 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 en yield zijn alleen in de strikte modus niet toegestaan .

eval en arguments zijn geen gereserveerde woorden, maar ze gedragen zich in strikte 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`

Toekomstige gereserveerde zoekwoorden

De volgende zijn gereserveerd als toekomstige trefwoorden door de ECMAScript-specificatie. Ze hebben momenteel geen speciale functionaliteit, maar op een later tijdstip misschien wel, dus ze kunnen niet als identificatie worden gebruikt.


`enum`

De volgende zijn alleen gereserveerd als ze worden gevonden in de strikte moduscode:


`implements`	`package`	`public`
`interface`	`private`	'Statische'
`let`	`protected`

Toekomstige gereserveerde zoekwoorden in oudere normen

De volgende zijn gereserveerd als toekomstige sleutelwoorden door oudere ECMAScript-specificaties (ECMAScript 1 tot 3).


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

Bovendien kunnen de letterlijke waarden null, true en false niet worden gebruikt als ID's in ECMAScript.

Van het Mozilla Developer Network .

ID's en identificatienamen

Met betrekking tot gereserveerde woorden is er een klein onderscheid tussen de "ID's" die worden gebruikt voor namen van variabelen of functienamen en de "Identificatienamen" die zijn toegestaan als eigenschappen van samengestelde gegevenstypen.

Het volgende resulteert bijvoorbeeld in een illegale syntaxisfout:

var break = true;

Uncaught SyntaxError: onverwachte tokenpauze

De naam wordt echter als geldig van een object (vanaf ECMAScript 5+) beschouwd:

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

Om uit dit antwoord te citeren:

Uit de ECMAScript® 5.1 taalspecificatie :

Sectie 7.6
Identificatienamen zijn tokens die worden geïnterpreteerd volgens de grammatica in het gedeelte 'Identifiers' van hoofdstuk 5 van de Unicode-standaard, met enkele kleine wijzigingen. Een Identifier is een IdentifierName die geen ReservedWord (zie 7.6.1 ).

Syntaxis

Identifier ::
  IdentifierName but not ReservedWord

Op specificatie is een ReservedWord :

Sectie 7.6.1
Een gereserveerd woord is een IdentifierName die niet kan worden gebruikt als een Identifier .
ReservedWord :: 
  Keyword
  FutureReservedWord
  NullLiteral
  BooleanLiteral

Dit omvat trefwoorden, toekomstige trefwoorden, null en booleaanse literals. De volledige lijst met trefwoorden staat in paragraaf 7.6.1 en de letterlijke woorden staan in paragraaf 7.8 .

Het bovenstaande (paragraaf 7.6) houdt in dat IdentifierName s ReservedWord kunnen worden en uit de specificatie voor objectinitializers :

Sectie 11.1.5

Syntaxis

ObjectLiteral :
  { }
  { PropertyNameAndValueList }
  { PropertyNameAndValueList , }

Waar PropertyName is, per specificatie:

PropertyName :
  IdentifierName
  StringLiteral
  NumericLiteral

Zoals u ziet, kan een PropertyName een IdentifierName , waardoor ReservedWord s PropertyName s kan zijn. Dat zegt ons overtuigend dat het volgens specificatie is toegestaan om ReservedWord s zoals class en var als PropertyName s niet geciteerd te hebben, net als stringliterals of numerieke literals.

Zie Sectie 7.6 - Identificatienamen en -identificaties voor meer informatie.

Opmerking: de syntax markeerstift in dit voorbeeld heeft het gereserveerde woord gespot en nog steeds gemarkeerd. Hoewel het voorbeeld geldig is, kunnen Javascript-ontwikkelaars worden gepakt door sommige compiler / transpiler-, linter- en minifier-tools die anders beweren.

Modified text is an extract of the original Stack Overflow Documentation

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

JavaScript
Gereserveerde zoekwoorden

Zoeken…