Grammaire lexicale

Caractres de contrle

Les caractres de contrle n'ont aucune reprsentation visuelle mais sont utiliss pour contrler l'interprtation du texte.

Blancs

Les caractres d'espacement (blancs) sont utiliss pour des raisons de lisibilit et permetttent de sparer les diffrents fragments entre eux. Ces caractres sont gnralement inutiles au code. Les outils de minification sont souvent utiliss pour retirer les blancs afin de rduire le volume de donnes transfrer.

Terminateurs de lignes

En plus des blancs, les caractres de fin de ligne (terminateurs de lignes) sont utiliss pour amliorer la lisibilit du texte. Cependant, dans certains cas, les terminateurs de lignes peuvent influencer l'excution du code JavaScript l o ils sont interdits. Les terminateurs de lignes affectent galement le processus d'insertion automatique des points-virgules. Les terminateurs de lignes correspondent la classe \s des expressions rationnelles.

Seuls les points de code Unicode qui suivent sont traits comme des fins de lignes en ECMAScript, les autres caractres sont traits comme des blancs (par exemple : Next Line (nouvelle ligne) : NEL, U+0085 est considr comme un blanc).

Commentaires

Les commentaires sont utiliss pour fournir des notes, des suggestions, des indications ou des avertissements sur le code JavaScript. Cela peut en faciliter la lecture et la comprhension. Ils peuvent galement tre utiliss pour empcher l'excution d'un certain code ; cela peut tre pratique lors du dbogage.

En JavaScript, Il existe actuellement deux faons de former des commentaires (cf. ci-aprs pour une troisime mthode en cours de discussion).

Commentaire sur une ligne

La premire faon est d'utiliser // (double barre oblique), pour commenter tout le texte qui suit (sur la mme ligne). Par exemple :

function comment() {
  // Voici un commentaire d'une ligne en JavaScript
  console.log("Hello world !");
}
comment();

Commentaire sur plusieurs lignes

La seconde faon est d'utiliser /* */, qui est plus flexible.

Il est possible d'utiliser cette forme sur une seule ligne :

function comment() {
  /* Voici un commentaire d'une ligne en JavaScript */
  console.log("Hello world !");
}
comment();

Mais galement sur plusieurs lignes, comme ceci :

function comment() {
  /* Ce commentaire s'tend sur plusieurs lignes. Il n'y a
    pas besoin de clore le commentaire avant d'avoir
     fini. */
  console.log("Hello world !");
}
comment();

Il est galement possible d'utiliser un commentaire au milieu d'une ligne. En revanche, cela rend le code plus difficile lire et devrait tre utilis avec attention :

function comment(x) {
  console.log("Hello " + x /* insrer la valeur de x */ + " !");
}
comment("world");

On peut galement encadrer du code pour l'empcher d'tre excut. Par exemple :

function comment() {
  /* console.log("Hello world !"); */
}
comment();

Ici, l'appel console.log() n'a jamais lieu car il fait partie d'un commentaire. On peut ainsi dsactiver plusieurs lignes de code d'un coup.

Commentaire d'environnement (hashbang)

Une troisime syntaxe, en cours de standardisation par ECMAScript, permet d'indiquer l'environnement dans lequel est excut le script via un commentaire hashbang. Un tel commentaire commence par #! et est uniquement valide au tout dbut du script ou du module (aucun espace/blanc n'est autoris avant #!). Un tel commentaire ne tient que sur une seule ligne et il ne peut y avoir qu'un seul commentaire de ce type.

#!/usr/bin/env node

console.log("Coucou le monde");

Les commentaires d'environnements sont conus pour fonctionner comme les shebangs qu'on peut trouver sous Unix et indiquent l'interprteur utiliser pour excuter le script ou le module.

Si vous souhaitez placer un commentaire en dbut de fichier sans indiquer d'environnement d'excution spcifique, on pourra utiliser le commentaire classique avec //.

Mots-cls

Mots-cls rservs selon ECMAScript 2015

• break
• case
• class
• catch
• const
• continue
• debugger
• default
• delete
• do
• else
• export
• extends
• finally
• for
• function
• if
• import
• in
• instanceof
• new
• return
• super
• switch
• this
• throw
• try
• typeof
• var
• void
• while
• with
• yield

Mots-cls rservs pour le futur

Les mots-cls qui suivent ont t rservs pour une utilisation future dans la spcification ECMAScript. Ils n'ont actuellement aucune utilit mais pourrait tre utiliss par la suite. Ils ne peuvent donc pas tre utiliss comme identifiants. Ces mots-cls ne peuvent tre utiliss ni en mode strict ni en mode non strict.

• enum
• await (lorsqu'il est utilis dans le contexte d'un module)

Les mots-cls suivants sont rservs dans du code en mode strict :

• implements
• let
• package
• protected
• static
• interface
• private
• public

Mots-cls rservs pour un usage future dans les anciens standards

Les mots-cls suivants sont rservs dans les anciennes spcifications ECMAScript (ECMAScript 1 3).

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

Par ailleurs, les littraux null, true, et false sont rservs dans ECMAScript pour leur usage normal.

Utilisation des mots-cls rservs

Les mots-cls rservs ne le sont que pour les identifiants (et non pour les IdentifierNames) . Comme dcrit dans es5.github.com/#A.1, dans l'exemple qui suit, on a, lgalement, des IdentifierNames qui utilisent des ReservedWords.

a.import
a["import"]
a = { import: "test" }.

En revanche, dans ce qui suit, c'est illgal car c'est un identifiant. Un identifiant peut tre un IdentifierName mais pas un mot-cl rserv. Les identifiants sont utiliss pour les FunctionDeclaration (dclarations de fonction), les FunctionExpression (expressions de fonction), les VariableDeclaration (dclarations de variable).

function import() {} // Illgal.

Littraux

Littral null

Voir aussi la page null pour plus d'informations.

null;

Littraux boolens

Voir aussi la page Boolean pour plus d'informations.

true;
false;

Littraux numriques

Dcimaux

1234567890;
42;

// Attention  l'utilisation de zros en dbut :

0888; // 888 est compris comme dcimal
0777; // est compris comme octal et gale 511 en dcimal

Les littraux dcimaux peuvent commencer par un zro (0) suivi d'un autre chiffre. Mais si tous les chiffres aprs le 0 sont (strictement) infrieurs 8, le nombre sera analys comme un nombre octal. Cela n'entranera pas d'erreur JavaScript, voir bug Firefox 957513. Voir aussi la page sur parseInt().

Binaires

La reprsentation binaire des nombres peut tre utilise avec une syntaxe qui comporte un zro (0) suivi par le caractre latin "B" (minuscule ou majuscule) (0b ou 0B). Cette syntaxe est apparue avec ECMAScript 2015 et il faut donc faire attention au tableau de compatibilit pour cette fonctionnalit. Si les chiffres qui composent le nombre ne sont pas 0 ou 1, cela entranera une erreur SyntaxError : "Missing binary digits after 0b".

var FLT_SIGNBIT = 0b10000000000000000000000000000000; // 2147483648
var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
var FLT_MANTISSA = 0b00000000011111111111111111111111; // 8388607

Octaux

La syntaxe pour reprsenter des nombres sous forme octale est : un zro (0), suivi par la lettre latine "O" (minuscule ou majuscule) (ce qui donne 0o ou 0O). Cette syntaxe est apparue avec ECMAScript 2015 et il faut donc faire attention au tableau de compatibilit pour cette fonctionnalit. Si les chiffres qui composent le nombre ne sont pas compris entre 0 et 7, cela entranera une erreur SyntaxError : "Missing octal digits after 0o".

var n = 0o755; // 493
var m = 0o644; // 420

// Aussi possible en utilisant des zros en dbut du nombre (voir la note ci-avant)
0755;
0644;

Hexadcimaux

Les littraux hexadcimaux ont pour syntaxe : un zro (0), suivi par la lettre latine "X" (minuscule ou majuscule) (ce qui donne 0x ou 0X). Si les chiffres qui composent le nombre sont en dehors des units hexadcimales (0123456789ABCDEF), cela entranera une erreur SyntaxError : "Identifier starts immediately after numeric literal".

0xfffffffffffffffff; // 295147905179352830000
0x123456789abcdef; // 81985529216486900
0xa; // 10

Littraux BigInt

Le type BigInt est un type numrique primitif de JavaScript qui permet de reprsenter des entiers avec une prcision arbitraire. De tels littraux s'crivent en ajoutant un n la fin d'un entier.

123456789123456789n (nombre dcimal, en base 10)
0o7777777777777777n (nombre octal, en base 8)
0x123456789ABCDEF1n (nombre hexadcimal, en base 16)
0b0101010101110101n (nombre binaire, en base 2)

Voir aussi le paragraphe sur les grands entiers/BigInt sur les structures de donnes en JavaScript.

Sparateurs numriques

Pour amliorer la lisibilit des littraux numriques, des underscores (_, U+005F) peuvent tre utiliss comme sparateurs :

1_000_000_000_000
1_050.95
0b1010_0001_1000_0101
0o2_2_5_6
0xA0_B0_C0
1_000_000_000_000_000_000_000n

Ils ont quelques limitations :

// Il ne peut pas y avoir plus d'un underscore conscutif
100__000; // SyntaxError

// Ils ne sont pas autoriss  la fin d'un littral numrique
100_; // SyntaxError

// Ils ne sont pas autoriss aprs un zro qui dbute un littral
0_1; // SyntaxError

Littraux objets

Voir aussi les pages Object et Initialisateur d'objet pour plus d'informations.

var o = { a: "toto", b: "truc", c: 42 };

// notation raccourcie depuis ES6
var a = "toto",
  b = "truc",
  c = 42;
var o = { a, b, c };
// plutt que
var o = { a: a, b: b, c: c };

Littraux de tableaux

Voir aussi la page Array pour plus d'informations.

[1954, 1974, 1990, 2014];

Littraux de chanes de caractres

Un littral de chane de caractres correspond zro ou plusieurs codets Unicode entours de simples ou de doubles quotes. Les codets Unicode peuvent galement tre reprsents avec des squences d'chappements. Tous les codets peuvent apparatre dans un littral de chane de caractres l'exception de ces trois codets :

• U+005C \ (barre oblique inverse)
• U+000D (retour chariot, carriage return, CR)
• U+000A (saut de ligne, line feed, LF)

Avant la proposition consistant rendre les chanes JSON valides selon ECMA-262, les caractres U+2028 et U+2029 taient galement interdits.

Tous les codets peuvent tre crits sous la forme d'une squence d'chappement. Les littraux de chanes de caractres sont valus comme des valeurs String ECMAScript. Lorsque ces valeurs String sont gnres, les codets Unicode sont encods en UTF-16.

'toto';
"truc";

Squence d'chappement hexadcimale

Une squence d'chappement hexadcimale consiste en la succession de \x et de deux chiffres hexadcimaux reprsentant un codet sur l'intervalle 0x0000 0x00FF.

"\xA9"; // ""

Squence d'chappement Unicode

La squence d'chappement Unicode est compose de \u suivi de quatre chiffres hexadcimaux. Chacun de ces chiffres dfinit un caractres sur deux octets selon l'encodage UTF-16. Pour les codes situs entre U+0000 et U+FFFF, les chiffres utiliser sont identiques au code. Pour les codes suprieurs, il faudra utiliser deux squences d'chappement dont chacune reprsentera un demi-codet de la paire de surrogates.

Voir aussi String.fromCharCode() et String.prototype.charCodeAt().

"\u00A9"; // "" (U+A9)

chappement de points de code Unicode

Apparu avec ECMAScript 2015, l'chappement de points de code Unicode permet d'chapper n'importe quel caractre en utilisant une notation hexadcimale. Il est possible de le faire pour chapper les points de code Unicode dont la reprsentation va jusqu' 0x10FFFF. Avec la squence simple d'chappement Unicode, il tait ncessaire d'chapper respectivement les deux demi-codets d'une paire si on voulait chapper le caractre correspondant, avec cette nouvelle mthode, ce n'est plus ncessaire de faire la distinction.

Voir galement String.fromCodePoint() et String.prototype.codePointAt().

"\u{2F804}"; // CJK COMPATIBILITY IDEOGRAPH-2F804 (U+2F804)

// avec l'ancienne mthode d'chappement, cela aurait t crit
// avec une paire de surrogates
"\uD87E\uDC04";

Littraux d'expressions rationnelles

Voir la page RegExp pour plus d'informations.

/ab+c/g

// Un littral pour une expression rationnelle
// vide. Le groupe non-capturant est utilis pour
// lever l'ambigit avec les commentaires
/(?:)/

Littraux modles (gabarits ou templates)

Voir galement la page sur les gabarits de chanes de caractres pour plus d'informations.

`chane de caractres`;

`chane de caractres ligne 1
 chane de caractres ligne 2`;

`chane1 ${expression} chane2`;

tag`chane1 ${expression} chane2`;

Insertion automatique de points-virgules

Certaines instructions JavaScript doivent finir par un point-virgule et sont donc concernes par l'insertion automatique de points-virgules (ASI pour automatic semicolon insertion en anglais) :

• Instruction vide
• instruction de variable, let, const
• import, export, dclaration de module
• Instruction d'expression
• debugger
• continue, break, throw
• return

La spcification ECMAScript mentionne trois rgles quant l'insertion de points-virgules :

1. Un point-vrigule est insr avant un terminateur de ligne ou une accolade ("}") quand celui ou celle-ci n'est pas autoris par la grammaire

{ 1 2 } 3
// est donc transform, aprs ASI, en :
{ 1 2 ;} 3;

2. Un point-virgule est insr la fin lorsqu'on dtecte la fin d'une srie de jetons en flux d'entre et que le parseur est incapable d'analyser le flux d'entre comme un programme complet.

Ici ++ n'est pas trait comme oprateur postfixe s'appliquant la variable b car il y a un terminateur de ligne entre b et ++.

a = b;
++c;

// devient, aprs ASI :

a = b;
++c;

3. Un point-virgule est insr la fin, lorsqu'une instruction, production limite pour la grammaire, est suivie par un terminateur de ligne. Les instructions concernes par cette rgle sont :

• Expressions postfixes (++ et --)
• continue
• break
• return
• yield, yield*
• module

return
a + b

// est transform, aprs ASI, en :

return;
a + b;

Spcifications

Compatibilit des navigateurs

Voir aussi

• Jeff Walden : Nombres binaires et forme octale (en anglais)
• Mathias Bynens : Squences d'chappements de caractres (en anglais)
• Boolean
• Number
• RegExp
• String