JavaScript => Parole chiave riservate

introduzione

Alcune parole - le cosiddette parole chiave - sono trattate appositamente in JavaScript. Esiste una pletora di diversi tipi di parole chiave e sono cambiati in diverse versioni della lingua.

Parole chiave riservate

JavaScript ha una raccolta predefinita di parole chiave riservate che non è possibile utilizzare come variabili, etichette o nomi di funzioni.

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

Aggiunte 24 parole chiave riservate aggiuntive. (Nuove aggiunte in grassetto).

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

Non ci sono stati cambiamenti da ECMAScript 3 .

ECMAScript 5 rimosso int , byte , char , goto , long , final , float , short , double , native , throws , boolean , abstract , volatile , transient e synchronized ; ha aggiunto let e 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 e yield non sono consentiti in modalità rigorosa .

eval e gli arguments non sono parole riservate ma agiscono come in modalità rigorosa .

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`

Parole chiave riservate future

Quanto segue sono riservati come parole chiave future dalla specifica ECMAScript. Al momento non hanno funzionalità speciali, ma potrebbero esserlo in futuro, quindi non possono essere utilizzate come identificatori.


`enum`

I seguenti sono riservati solo quando vengono trovati in un codice di modalità rigoroso:


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

Parole chiavi riservate future in standard più vecchi

Le seguenti sono riservate come parole chiave future dalle specifiche ECMAScript precedenti (ECMAScript 1 fino a 3).


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

Inoltre, i valori letterali null, true e false non possono essere utilizzati come identificatori in ECMAScript.

Dalla rete di sviluppatori Mozilla .

Identificatori e nomi identificativi

Per quanto riguarda le parole riservate vi è una piccola distinzione tra gli "identificatori" utilizzati per i nomi di variabili o di funzioni e "Nomi identificativi" consentiti come proprietà dei tipi di dati compositi.

Ad esempio quanto segue provocherà un errore di sintassi illegale:

var break = true;

Uncaught SyntaxError: break token inaspettato

Tuttavia, il nome è ritenuto valido come proprietà di un oggetto (come da ECMAScript 5+):

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

Per citare da questa risposta :

Dalla specifica del linguaggio ECMAScript® 5.1 :

Sezione 7.6
Identificatore I nomi sono token interpretati in base alla grammatica fornita nella sezione "Identificatori" del capitolo 5 dello standard Unicode, con alcune piccole modifiche. Un Identifier è un IdentifierName che non è un ReservedWord (vedi 7.6.1 ).

Sintassi

Identifier ::
  IdentifierName but not ReservedWord

Per specifica, un ReservedWord è:

Sezione 7.6.1
Una parola riservata è un IdentifierName che non può essere utilizzato come Identifier .
ReservedWord :: 
  Keyword
  FutureReservedWord
  NullLiteral
  BooleanLiteral

Questo include parole chiave, parole chiave future, valori null e valori letterali booleani. L'elenco completo delle parole chiave si trova nelle Sezioni 7.6.1 e le letterali sono nella Sezione 7.8 .

Quanto sopra (Sezione 7.6) implica che IdentifierName può essere ReservedWord s, e dalle specifiche per gli inizializzatori di oggetti :

Sezione 11.1.5

Sintassi

ObjectLiteral :
  { }
  { PropertyNameAndValueList }
  { PropertyNameAndValueList , }

Dove PropertyName è, per specifica:

PropertyName :
  IdentifierName
  StringLiteral
  NumericLiteral

Come puoi vedere, un PropertyName può essere un IdentifierName , consentendo a ReservedWord di essere PropertyName s. Questo ci dice in modo definitivo che, per specifica , è permesso avere ReservedWord s come la class e var come PropertyName s non quotate come le stringhe letterali oi valori letterali numerici.

Per saperne di più, consultare la Sezione 7.6 - Identificatori, nomi e identificatori.

Nota: l'evidenziatore della sintassi in questo esempio ha individuato la parola riservata e ancora evidenziata. Mentre l'esempio è valido, gli sviluppatori di Javascript possono essere scoperti da alcuni strumenti di compilatore / transpiler, linter e minifier che argomentano diversamente.

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

JavaScript
Parole chiave riservate

Ricerca…