JavaScript => Reserverade nyckelord

Introduktion

Vissa ord - så kallade nyckelord - behandlas speciellt i JavaScript. Det finns en mängd olika typer av nyckelord, och de har ändrats i olika versioner av språket.

Reserverade nyckelord

JavaScript har en fördefinierad samling reserverade nyckelord som du inte kan använda som variabler, etiketter eller funktionsnamn.

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

Lade till 24 extra reserverade nyckelord. (Nya tillägg i fetstil).

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

Det skedde ingen förändring sedan ECMAScript 3 .

ECMAScript 5 tas bort int , byte , char , goto , long , final , float , short , double , native , throws , boolean , abstract , volatile , transient och synchronized ; det lägg till let och 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 och yield tillåts endast i strikt läge .

eval och arguments är inte reserverade ord men de fungerar som det i strikt läge .

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`

Framtida reserverade nyckelord

Följande är reserverade som framtida nyckelord av ECMAScript-specifikationen. De har ingen speciell funktionalitet för närvarande, men de kanske vid en framtida tid, så att de inte kan användas som identifierare.


`enum`

Följande är endast reserverade när de finns i strikt läge kod:


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

Framtida reserverade nyckelord i äldre standarder

Följande är reserverade som framtida nyckelord av äldre ECMAScript-specifikationer (ECMAScript 1 till 3).


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

Dessutom kan bokstäverna noll, sant och falsk inte användas som identifierare i ECMAScript.

Från Mozilla Developer Network .

Identifierare och namn

När det gäller reserverade ord finns det en liten distinktion mellan "identifierare" som används för att gilla variabla eller funktionsnamn och "identifieringsnamn" som är tillåtna som egenskaper hos sammansatta datatyper.

Till exempel kommer följande att resultera i ett olagligt syntaxfel:

var break = true;

Unctained SyntaxError: Oväntat token break

Namnet anses dock vara giltigt som en egenskap hos ett objekt (från ECMAScript 5+):

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

För att citera från detta svar :

Från ECMAScript® 5.1-språkspecifikation :

Avsnitt 7.6
Identifieringsnamn är symboler som tolkas enligt grammatiken som ges i avsnittet "Identifierare" i kapitel 5 i Unicode-standarden, med några små ändringar. En Identifier är ett IdentifierName som inte är ett ReservedWord (se 7.6.1 ).

Syntax

Identifier ::
  IdentifierName but not ReservedWord

Genom specifikation är ett ReservedWord :

Avsnitt 7.6.1
Ett reserverat ord är ett IdentifierName som inte kan användas som Identifier .
ReservedWord :: 
  Keyword
  FutureReservedWord
  NullLiteral
  BooleanLiteral

Detta inkluderar nyckelord, framtida nyckelord, null och booleska bokstäver. Den fullständiga listan med nyckelord finns i avsnitt 7.6.1 och bokstäver finns i avsnitt 7.8 .

Ovanstående (avsnitt 7.6) antyder att IdentifierName kan ReservedWord och från specifikationen för objektinitierare :

Avsnitt 11.1.5

Syntax

ObjectLiteral :
  { }
  { PropertyNameAndValueList }
  { PropertyNameAndValueList , }

Var PropertyName är, enligt specifikation:

PropertyName :
  IdentifierName
  StringLiteral
  NumericLiteral

Som du kan se kan ett PropertyName vara ett IdentifierName , vilket gör att ReservedWord s kan vara PropertyName . Det säger oss slutgiltigt att det enligt specifikation är tillåtet att ha ReservedWord s som class och var som PropertyName är citerade precis som strängbokstäver eller numeriska bokstäver.

För att läsa mer, se Avsnitt 7.6 - Identifieringsnamn och identifierare.

Obs! Syntaxmarkören i detta exempel har upptäckt det reserverade ordet och fortfarande markerat det. Exemplet är giltigt Javascript-utvecklare kan komma i kontakt med vissa kompilator / transpilerare, linter och minifieringsverktyg som hävdar något annat.

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

JavaScript
Reserverade nyckelord

Sök…