JavaScript => Mots-clés réservés

Introduction

Certains mots - appelés mots - clés - sont traités spécialement en JavaScript. Il y a une pléthore de différents types de mots-clés, et ils ont changé dans différentes versions du langage.

Mots-clés réservés

JavaScript contient une collection prédéfinie de mots-clés réservés que vous ne pouvez pas utiliser comme variables, libellés ou noms de fonctions.

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

Ajout de 24 mots-clés réservés supplémentaires. (Nouveaux ajouts en gras).

3 E4X

_{UN 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

Il n'y avait pas de changement depuis ECMAScript 3 .

ECMAScript 5 retiré int , byte , char , goto , long , final , float , short , double , native , throws , boolean , abstract , volatile , transient et synchronized ; il a ajouté let et yield .

_{UN 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 et yield sont interdites en mode strict uniquement .

eval et les arguments ne sont pas des mots réservés mais ils agissent comme lui en mode strict .

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`

Futurs mots-clés réservés

Les éléments suivants sont réservés comme futurs mots-clés par la spécification ECMAScript. Ils n’ont pas de fonctionnalité spéciale à l’heure actuelle, mais ils pourraient le faire ultérieurement, ils ne peuvent donc pas être utilisés comme identificateurs.


`enum`

Les éléments suivants sont uniquement réservés lorsqu'ils sont trouvés en code mode strict:


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

Futurs mots-clés réservés dans les anciennes normes

Les éléments suivants sont réservés comme futurs mots-clés par les anciennes spécifications ECMAScript (ECMAScript 1 à 3).


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

De plus, les littéraux null, true et false ne peuvent pas être utilisés comme identificateurs dans ECMAScript.

Du réseau de développeurs Mozilla .

Identifiants & Identifiant

En ce qui concerne les mots réservés, il existe une petite distinction entre les "identificateurs" utilisés pour les noms de variables ou de noms de fonctions et les "noms d'identifiants" autorisés comme propriétés des types de données composites.

Par exemple, ce qui suit entraînera une erreur de syntaxe illégale:

var break = true;

SyntaxError Uncaught: rupture de jeton inattendue

Cependant, le nom est considéré comme une propriété d'un objet (à partir de ECMAScript 5+):

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

Pour citer cette réponse :

À partir de la spécification du langage ECMAScript® 5.1 :

Section 7.6
Identifier Les noms sont des jetons interprétés selon la grammaire donnée dans la section «Identifiers» du chapitre 5 du standard Unicode, avec quelques petites modifications. Un Identifier est un IdentifierName non ReservedWord (voir 7.6.1 ).

Syntaxe

Identifier ::
  IdentifierName but not ReservedWord

Par spécification, un ReservedWord est:

Section 7.6.1
Un mot réservé est un IdentifierName qui ne peut pas être utilisé comme Identifier .
ReservedWord :: 
  Keyword
  FutureReservedWord
  NullLiteral
  BooleanLiteral

Cela inclut les mots-clés, les mots-clés futurs, null littéraux null et booléens. La liste complète des mots-clés se trouve dans la section 7.6.1 et les littéraux dans la section 7.8 .

Ce qui précède (Section 7.6) implique que IdentifierName s peut être ReservedWord s, et à partir de la spécification pour les initialiseurs d’objets :

Section 11.1.5

Syntaxe

ObjectLiteral :
  { }
  { PropertyNameAndValueList }
  { PropertyNameAndValueList , }

Où PropertyName est, par spécification:

PropertyName :
  IdentifierName
  StringLiteral
  NumericLiteral

Comme vous pouvez le voir, un PropertyName peut être un IdentifierName , ce qui permet à ReservedWord s d’être PropertyName s. Cela nous indique de manière concluante que, par spécification , il est permis d’avoir des commandes ReservedWord telles que class et var tant que PropertyName non équivaut, tout comme les littéraux de chaîne ou les littéraux numériques.

Pour en savoir plus, reportez-vous à la Section 7.6 - Noms et identificateurs des identificateurs.

Remarque: le surligneur de syntaxe dans cet exemple a repéré le mot réservé et l’a toujours mis en évidence. Bien que l'exemple soit valide, les développeurs Javascript peuvent être pris par des outils de compilateur / transpiler, linter et minifier qui affirment le contraire.

Modified text is an extract of the original Stack Overflow Documentation

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

JavaScript
Mots-clés réservés

Recherche…