| [ Web Proxy ] |
| Viewing: https://developer.mozilla.org/fr/docs/Web/JavaScript/Guide/Grammar_and_types | [Back] [Original] |
Get to know MDN better
Cette page a t traduite partir de l'anglais par la communaut. Vous pouvez contribuer en rejoignant la communaut francophone sur MDN Web Docs.
Ce chapitre dcrit les bases de la grammaire et des types de donnes JavaScript.
JavaScript emprunte la plupart des lments de sa syntaxe Java, C et C++ mais sa syntaxe est galement influence par Awk, Perl et Python.
JavaScript est sensible la casse et utilise l'ensemble de caractres Unicode. On pourrait donc tout fait utiliser le mot frh comme nom de variable :
var frh = "toto";
typeof Frh; // undefined car JavaScript est sensible la casse
En JavaScript, les instructions sont appeles (statements) et sont spares par des points-virgules.
Il n'est pas ncessaire d'inclure un point-virgule si l'on crit une instruction sur une nouvelle ligne. Mais si vous voulez crire plus d'une dclaration sur une seule ligne, alors elles doivent tre spares par un point-virgule. Ceci tant dit, la bonne pratique est d'inclure un point-virgule aprs chaque instruction. Les espaces, les tabulations et les caractres de nouvelles lignes sont considrs comme des blancs. Il existe aussi un ensemble de rgles pour ajouter automatiquement des points-virgules la fin des instructions (ASI pour Automatic Semicolon Insertion). Cependant, il est conseill de toujours ajouter des points-virgules la fin des instructions afin d'viter des effets de bord nfastes.
Le texte d'un code source JavaScript est analys de gauche droite et est converti en une srie d'units lexicales, de caractres de contrle, de fins de lignes, de commentaires et de blancs. ECMAScript dfinit galement certains mots-cls et littraux. Pour plus d'informations, voir la page sur la grammaire lexicale de JavaScript dans la rfrence JavaScript.
La syntaxe utilise pour les commentaires est la mme que celle utilise par le C++ et d'autres langages :
// un commentaire sur une ligne
/* un commentaire plus
long sur plusieurs lignes
*/
/* Par contre on ne peut pas /* imbriquer des commentaires */ SyntaxError */
Note :
Vous pourrez galement rencontrer une troisime forme de commentaires au dbut de certains fichiers JavaScript comme #!/usr/bin/env node. Ce type de commentaire indique le chemin d'un interprteur JavaScript spcifique pour excuter le script. Pour plus de dtails, voir la page sur les commentaires d'environnement.
Il existe trois types de dclarations de variable en JavaScript.
varOn dclare une variable, ventuellement en initialisant sa valeur.
letOn dclare une variable dont la porte est celle du bloc courant, ventuellement en initialisant sa valeur.
constOn dclare une constante nomme, dont la porte est celle du bloc courant, accessible en lecture seule.
Les variables sont utilises comme des noms symboliques dsignant les valeurs utilises dans l'application. Les noms des variables sont appels identifiants. Ces identifiants doivent respecter certaines rgles.
Un identifiant JavaScript doit commencer par une lettre, un tiret bas (_) ou un symbole dollar ($). Les caractres qui suivent peuvent tre des chiffres (0 9). noter : puisque Javascript est sensible aux majuscules et minuscules: les lettres peuvent comprendre les caractres de A Z (en majuscule) mais aussi les caractres de a z (en minuscule).
On peut aussi utiliser la plupart lettres Unicode ou ISO 8859-1 (comme et , pour plus de dtails, voir ce billet de blog, en anglais) au sein des identifiants. Il est galement possible d'utiliser les \uXXXX squences d'chappement Unicode comme caractres dans les identifiants.
Voici des exemples d'identifiants valides : Nombre_touches, temp99, $credit, et _nom.
Il est possible de dclarer des variables de plusieurs faons :
var, par exemple : var x = 42. Cette syntaxe peut tre utilise pour dclarer des variables locales ou globales selon le contexte d'excution.const ou le mot-cl let, par exemple avec let y = 13. Cette syntaxe peut tre utilise pour dclarer une variable dont la porte sera celle du bloc. Voir le paragraphe sur les portes des variables ci-aprs.Il est galement possible d'affecter une valeur une variable sans utiliser de mot-cl (ex. x = 42). Cela crera une variable globale non-dclare. Cette forme gnrera galement un avertissement avec le mode strict. Attention, les variables globales non-dclares peuvent mener des comportements inattendus et sont considres comme une mauvaise pratique.
Une variable dclare grce l'instruction var ou let sans valeur initiale dfinie vaudra undefined.
Tenter d'accder une variable qui n'a pas t dclare ou tenter d'accder un identifiant dclar avec let avant son initialisation provoquera l'envoi d'une exception ReferenceError.
var a;
console.log("La valeur de a est " + a); // La valeur de a est undefined
console.log("La valeur de b est " + b); // La valeur de b est undefined
var b; // La dclaration de la variable est "remonte" (voir la section ci-aprs)
console.log("La valeur de x est " + x); // signale une exception ReferenceError
let x;
let y;
console.log("La valeur de y est " + y); // La valeur de y est undefined
Il est possible d'utiliser undefined pour dterminer si une variable possde une valeur. Dans l'exemple qui suit, la condition de l'instruction if sera valide car la variable n'a pas t initialise (elle a simplement t dclare) :
var input;
if (input === undefined) {
faireCeci();
} else {
faireCela();
}
La valeur undefined se comporte comme le boolen false lorsqu'elle est utilise dans un contexte boolen. Ainsi, le fragment de code qui suit excutera la fonction maFonction puisque le premier lment de monTableau n'est pas dfini :
var monTableau = new Array();
if (!monTableau[0]) {
maFunction();
}
La valeur undefined est convertie en NaN (pour Not a Number : n'est pas un nombre ) lorsqu'elle est utilise dans un contexte numrique.
var a;
a + 2; // NaN
Une variable valant null sera toujours considre comme 0 dans un contexte numrique et comme false dans un contexte boolen. Par exemple, on aura :
var n = null;
console.log(n * 32); // Le log affichera 0
Lorsqu'une variable est dclare avec var en dehors des fonctions, elle est appele variable globale car elle est disponible pour tout le code contenu dans le document. Lorsqu'une variable est dclare dans une fonction, elle est appele variable locale car elle n'est disponible qu'au sein de cette fonction.
Avant ECMAScript 2015 (ES6), JavaScript ne dfinissait pas de porte pour une instruction de bloc ; les lments du bloc seront locaux pour le code qui contient le bloc (que ce soit une fonction ou le contexte global). Ainsi, l'exemple qui suit affichera 5 car la porte de x est la fonction (ou le contexte global) dans lequel x est dclar, pas le bloc (correspondant l'instruction if dans ce cas) :
if (true) {
var x = 5;
}
console.log(x); // x vaut 5
La dclaration let, introduite avec ECMAScript 2015, ajoute un nouveau comportement :
if (true) {
let y = 5;
}
console.log(y); // ReferenceError: y is not defined
Une autre chose peut paratre trange en JavaScript : il est possible, sans recevoir d'exception, de faire rfrence une variable qui est dclare plus tard. Ce concept est appel remonte (hoisting en anglais) car, d'une certaine faon, les variables sont remontes en haut de la fonction ou de l'instruction. En revanche, les variables qui n'ont pas encore t initialises renverront la valeur undefined. Ainsi, mme si on dclare une variable et qu'on l'initialise aprs l'avoir utilise ou y avoir fait rfrence, la valeur utilise la plus haute sera toujours undefined.
/**
* Exemple 1
*/
console.log(x === undefined); // donne "true"
var x = 3;
/**
* Exemple 2
*/
// renverra undefined
var maVar = "ma valeur";
(function () {
console.log(maVar); // undefined
var maVar = "valeur locale";
})();
Les exemples prcdents peuvent tre reformuls plus explicitement ainsi :
/**
* Exemple 1
*/
var x;
console.log(x === undefined); // donne "true"
x = 3;
/**
* Exemple 2
*/
var maVar = "ma valeur";
(function () {
var maVar;
console.log(maVar); // undefined
maVar = "valeur locale";
})();
C'est pourquoi il est conseill de placer les instructions var ds que possible dans le code. De plus, cette bonne pratique aide rendre le code plus lisible.
Avec ECMAScript 2015, let (const) remontera la variable en haut du bloc mais ne l'initialisera pas. Aussi, si on fait rfrence la variable dans le bloc avant la dclaration, on obtient une ReferenceError car la variable est dans une zone morte temporelle . entre le dbut du bloc et le traitement de la dclaration
function faire_quelquechose() {
console.log(toto); // ReferenceError
let toto = 2;
}
En ce qui concerne les fonctions, seules les dclarations de fonctions sont remontes. Pour les expressions de fonctions, il n'y a pas de telle remonte car la variable associe n'a pas encore t affecte avec la valeur finale (comme vu avant) :
/* Dclaration de fonction */
toto(); // "truc"
function toto() {
console.log("truc");
}
/* Expression de fonction */
machin(); // erreur TypeError : machin n'est pas une fonction
var machin = function () {
console.log("titi");
};
Les variables globales sont en ralit des proprits de l'objet global. Dans les pages web, l'objet global est window, et on peut donc accder ou modifier la valeur de variables globales en utilisant la syntaxe suivante : window.variable .
Ainsi, il est possible d'accder des variables dclares dans une fentre ou dans un cadre depuis une autre fentre ou depuis un autre cadre (frame) en spcifiant son nom. Si, par exemple, une variable appele numTlphone est dclare dans un document FRAMESET, il est possible d'y faire rfrence, depuis un cadre fils, avec la syntaxe parent.numTlphone.
Il est possible de crer des constantes en lecture seule en utilisant le mot-cl const. La syntaxe d'un identifiant pour une constante est la mme que pour les variables (elle doit dbuter avec une lettre, un tiret du bas, un symbole dollar et peut contenir des caractres numriques, alphabtiques et des tirets bas voire des caractres Unicode).
const prfixe = "212";
Une constante ne peut pas changer de valeur grce une affectation ou tre re-dclare pendant l'excution du script.
Les rgles de porte des constantes sont les mmes que pour les variables, l'exception du mot-cl const qui est obligatoire. S'il est oubli, l'identifiant sera considr comme celui d'une variable.
Il est impossible de dclarer une constante avec le mme nom qu'une autre variable ou fonction dans la mme porte.
// Renverra une erreur
function f() {}
const f = 5;
// Renverra galement une erreur
function f() {
const g = 5;
var g;
//instructions
}
Cependant, les proprits des objets qui sont affects comme constantes ne sont pas protges, on pourra ainsi excuter sans problme le code suivant :
const MON_OBJET = { cl: "valeur" };
MON_OBJET.cl = "autreValeur";
De mme, le contenu d'un tableau peut tre modifi sans alerte :
const MON_TABLEAU = ["HTML", "CSS"];
MON_TABLEAU.push("JavaScript");
console.log(MON_TABLEAU); // ["HTML", "CSS", "JavaScript"]
La dernire version du standard ECMAScript dfinit sept types de donnes :
Six types de donnes primitifs :
true et false.null), un mot-cl spcial pour indiquer une valeur nulle (au sens informatique). JavaScript tant sensible la casse, null n'est pas Null, NULL, ou toute autre variante.undefined).42 ou 3.14159.BigInt, par exemple 9007199254740992n.et un type pour les objets (Object)
Bien que cette description couvre peu de types de donnes, ceux-ci vous permettent d'implmenter une grande varit de fonctions au sein de vos applications. Les objets et les fonctions sont parmi les briques fondamentales du langage. On peut considrer, premire vue, les objets comme des conteneurs de valeurs et de fonctions pour une application.
JavaScript est un langage typage dynamique. Cela signifie qu'il n'est pas ncessaire de spcifier le type de donnes d'une variable lors de sa dclaration. Les types de donnes sont convertis automatiquement durant l'excution du script. Ainsi, il est possible de dfinir une variable de cette faon :
var rponse = 42;
Et plus tard, d'affecter une chane de caractres cette mme variable :
rponse = "Merci pour le dner...";
JavaScript utilisant un typage dynamique, cette dernire instruction ne renverra pas d'erreur.
Lorsque des expressions impliquent des chanes de caractres et des valeurs numriques ainsi que l'oprateur +, JavaScript convertit les nombres en chanes de caractres :
x = "La rponse est " + 42; // "La rponse est 42"
y = 42 + " est la rponse"; // "42 est la rponse"
Avec des instructions impliquant d'autres oprateurs, JavaScript ne convertit pas ncessairement les valeurs numriques en chanes de caractres. Ainsi, on aura :
"37" - 7; // 30
"37" + 7; // "377"
Si un nombre est reprsent en mmoire par une chane de caractres, il y a des mthodes pour effectuer la bonne conversion :
parseInt renverra uniquement des nombres entiers, tant ainsi inapproprie pour la manipulation de nombre dcimaux. Une bonne pratique pour cette fonction est de toujours inclure l'argument qui indique dans quelle base numrique le rsultat doit tre renvoy (base 2, base 10...).
parseInt("101", 2); // 5
Une autre mthode pour rcuprer un nombre partir d'une chane de caractres consiste utiliser l'oprateur +.
"1.1" + "1.1" = "1.11.1"
+"1.1" = 1.1 // fonctionne seulement avec le + unaire
Les littraux sont utiliss pour reprsenter des valeurs en JavaScript. Ce sont des valeurs fixes, pas des variables, qui sont fournies littralement au script. Cette section dcrit les diffrents types de littraux :
Un littral de tableau est une liste de zro ou plusieurs expressions, dont chacune reprsente l'lment d'un tableau, encadres par des crochets ([]). Lorsqu'un tableau est cr partir d'un littral, il est initialis avec les valeurs spcifies qui sont ses lments, sa longueur correspondant au nombre d'arguments donns.
L'exemple suivant cre ainsi le tableau cafs avec trois lments et une taille gale 3 :
var cafs = ["Brsilien", "Colombien", "Kona"];
Note : Un littral de tableau est du type d'un initialisateur d'objets. Voir l'utilisation d'initialisateurs d'objets.
Si un tableau est cr en utilisant un littral dans un script du plus haut niveau, JavaScript interprte le tableau chaque fois qu'il value l'expression contenant le littral. De plus, un littral utilis dans une fonction est cr chaque fois que la fonction est appele.
Les littraux de tableaux sont galement des objets Array. Voir la page sur l'objet Array pour plus de dtails.
Il n'est pas ncessaire de dfinir tous les lments dans un littral de tableau. Si vous utilisez deux virgules, l'une la suite de l'autre, le tableau utilisera la valeur undefined pour les lments non dfinis. L'exemple qui suit utilise le tableau poisson :
var poisson = ["Clown", , "Chat"];
Ce tableau possde deux lments ayant une valeur et un lment vide (poisson[0] vaut "Clown", poisson[1] vaut undefined, et poisson[2] vaut "Chat").
Si une virgule est ajoute la fin de la liste des lments, elle est ignore. Dans le prochain exemple, la longueur du tableau est gale 3. Il n'y a pas d'lment maListe[3]. Les autres virgules indiquent un nouvel lment.
Note : Avec d'anciennes versions de navigateurs, les virgules de fin peuvent causer des erreurs, il est fortement conseill de les retirer.
var maListe = ["maison", , "cole"];
Dans l'exemple qui suit, la longueur du tableau est gale 4 et maListe[0] et maListe[2] sont manquants.
var maListe = [, "maison", , "cole"];
Dans l'exemple qui suit, la longueur du tableau est gale 4 et maListe[1] et maListe[3] sont manquants.
var maListe = ["maison", , "cole", ,];
Comprendre le fonctionnement des virgules supplmentaires est important. Cependant, lorsque vous crivez du code, veillez, ds que c'est possible, dclarer les lments manquants avec undefined : cela amliorera la lisibilit de votre code et il sera ainsi plus facile maintenir.
Le type boolen possde deux valeurs littrales : true et false.
Il ne faut pas confondre les valeurs true et false du type primitif boolen et les valeurs true et false de l'objet Boolean. L'objet Boolean permet de crer un objet autour du type de donne boolen. Voir la page sur l'objet Boolean pour plus d'informations.
Les nombres Number et les grands entiers BigInt peuvent tre exprims en notation dcimale (base 10), hexadcimale (base 16), octale (base 8) et binaire (base 2).
0xa = 0xA = 10 et 0xf = 0xF = 15).Voici des exemples pour ces littraux :
0, 117, -345, 123456789123456789n (notation dcimale, base 10) 015, 0001, -077, 0o7777777777777n (notation octale, base 8) 0x1123, 0x00111, -0xF1A7, 0x123456789ABCDEFn (notation hexadcimale, base 16) 0b11, 0B0011, -0b11, 0b11101001010101010101n (notation binaire, base 2)
Pour plus d'informations, voir les littraux numriques dans la grammaire lexicale de JavaScript.
Un littral de nombre dcimal peut tre compos de ces diffrentes parties :
L'exposant est la partie du nombre dcimal commenant par un e ou un E , suivie d'un entier pouvant tre sign (prcd d'un + ou d'un - ). Un littral de nombre dcimal doit comporter au moins un chiffre et soit un point (sparateur dcimal) soit un e ou un E .
Des exemples sont : 3.1415, -3.1E12, .1e12, et 2E-12.
On peut raccourcir cette syntaxe en :
[(+|-)][chiffres].[chiffres][(E|e)[(+|-)]chiffres]
Par exemple :
3.14 2345.789 .3333333333333333333
Un littral d'objet - ou 'objet littral' - est une liste de zro ou plusieurs proprits dfinies par des paires de noms/valeurs. Ces paires sont dlimites par des accolades ({}). N'utilisez pas un tel littral en dbut d'instruction. En effet, l'accolade ouvrante sera mal interprte (dbut de bloc) et causera une erreur ou un comportement incohrent.
L'exemple qui suit montre l'utilisation d'un littral d'objet. Le premier lment de l'objet voiture dfinit une proprit maVoiture, le deuxime lment : la proprit getVoiture invoque une fonction (carTypes("Honda")), le troisime lment, la proprit special utilise une variable existante (soldes).
var soldes = "Toyota";
function carTypes(nom) {
return nom === "Honda" ? nom : "Dsol, nous ne vendons pas de " + nom + ".";
}
var voiture = {
maVoiture: "Saturn",
getVoiture: carTypes("Honda"),
spcial: soldes,
};
console.log(voiture.maVoiture); // Saturn
console.log(voiture.getVoiture); // Honda
console.log(voiture.spcial); // Toyota
Il est galement possible d'utiliser un littral numrique ou un littral de chane de caractres pour dsigner le nom d'une proprit ou pour imbriquer un objet dans un autre. L'exemple qui suit illustre cette possibilit :
var voiture = { plusieursVoitures: { a: "Saab", b: "Jeep" }, 7: "Mazda" };
console.log(voiture.plusieursVoitures.b); // Jeep
console.log(voiture[7]); // Mazda
Les noms des proprits d'objets peuvent tre n'importe quelle chane de caractres, y compris la chane vide. Si le nom de la proprit n'est pas un identifiant valide, il faudra qu'il soit plac entre guillemets. Les noms de proprits qui ne sont pas des identifiants valides ne peuvent pas tre utiliss pour accder la valeur en utilisant la notation pointe (objet.proprit). En revanche, il est possible d'y accder avec la notation utilisant les crochets ("[]") comme pour les tableaux.
var nomsBizarres = {
"": "Chane vide",
"!": "Bang !"
}
console.log(nomsBizarres.""); // SyntaxError: Unexpected string
console.log(nomsBizarres[""]); // Chane vide
console.log(nomsBizarres.!); // SyntaxError: Unexpected token !
console.log(nomsBizarres["!"]); // Bang !
Avec ES2015, les littraux d'objets permettent de dfinir le prototype lors de la construction de l'objet, permettent d'utiliser les affectations en notation raccourcie : toto: toto, de dfinir des mthodes, d'appeler les mthodes de l'objet parent avec super et d'utiliser des noms de proprits calcules.
var obj = {
// __proto__
__proto__: lePrototypeDeLObjet,
// Notation raccourcie pour handler: handler
handler,
// Mthodes
toString() {
// Appelle les mthodes de l'objet parent
return "d " + super.toString();
},
// Noms de proprits calculs dynamiquement
["prop_" + (() => 42)()]: 42,
};
Attention :
var toto = { a: "alpha", 2: "deux" };
console.log(toto.a); // alpha
console.log(toto[2]); // deux
//console.log(toto.2); // Erreur: parenthse ) manquante aprs la liste d'argument
//console.log(toto[a]); // Erreur: a n'est pas dfini
console.log(toto["a"]); // alpha
console.log(toto["2"]); // deux
Un littral d'expression rationnelle est un motif encadr par deux barres obliques. Par exemple :
var re = /ab+c/;
Un littral de chane de caractres consiste en zro ou plusieurs caractres encadrs par des guillemets droits doubles (") ou des guillemets droits simples ('). Une chane de caractres doit tre encadre par des symboles du mme type (guillemets droits doubles ou guillemets droits simples) :
"toto"'truc'"1234""Une ligne \n une autre ligne""Aujourd'hui j'ai mang une pomme"Il est possible d'utiliser les mthodes de String sur un tel littral. JavaScript convertira automatiquement le littral en un objet String, appellera la mthode puis dtruira l'objet String. On peut galement utiliser la proprit String.length sur un littral de chane de caractre :
console.log("j'ai mang une pomme".length);
// Affichera le nombre de caractres (y compris les blancs).
// Dans ce cas, 20.
Il est prfrable d'utiliser des littraux de chanes de caractres s'il n'est pas spcifiquement ncessaire d'utiliser un objet String. Voir la page sur l'objet String pour plus de dtails sur les objets String.
Avec ECMAScript 2015, on peut galement utiliser des littraux sous forme de gabarits (templates) en utilisant le caractre accent grave (`) comme sparateur. Les gabarits de chanes de caractres sont semblables aux fonctionnalits d'interpolation existantes en Python, Perl, etc. Ces gabarits permettent d'utiliser des balises afin d'adapter la construction de chanes.
// Littral simple pour une chane
`Un saut de ligne '\n' en JavaScript.` // On peut crire une chane sur plusieurs
// lignes
`Dans les gabarits, on peut crire
sur plusieurs lignes. `;
// Interpolation de chane
var nom = "Robert",
jour = "aujourd'hui";
`Bonjour ${nom}, comment allez-vous ${jour} ?`;
// On peut construire un prfixe HTTP
// afin de construire plus facilement
// des requtes via des substitutions
POST`http://toto.org/truc?a=${a}&b=${b}
Content-Type: application/json
X-Credentials: ${credentials}
{ "toto": ${toto},
"truc": ${truc}}`(myOnReadyStateChangeHandler);
En plus des caractres classiques , il est possible d'insrer des caractres spciaux dans les chanes de caractres. Voici un exemple :
"une ligne \n une autre ligne";
Voici un tableau listant les caractres spciaux qu'il est possible d'utiliser dans les chanes de caractres JavaScript :
| Caractre | Signification |
|---|---|
\0 |
Octet null |
\b |
Retour arrire |
\f |
Saut de page |
\n |
Nouvelle ligne |
\r |
Retour chariot |
\t |
Tabulation |
\v |
Tabulation verticale |
\' |
Apostrophe ou guillemet droit simple |
\" |
Guillemet droit double |
\\ |
Barre oblique inverse |
\XXX |
Le caractre dont l'encodage Latin-1 est spcifi grce , au plus, 3 chiffres octaux XXX entre 0 et 377. \251, par exemple reprsente le caractre copyright. |
\xXX |
Le caractre dont l'encodage Latin-1 est spcifi par deux chiffres hexadcimaux entre 00 et FF. Ainsi, \xA9 correspond la squence hexadcimale pour le caractre copyright. |
\uXXXX |
Le caractre Unicode spcifi par quatre chiffres hexadcimaux XXXX. Ainsi, \u00A9 correspondra la squence Unicode du symbole copyright. Voir Les caractres d'chappement Unicode. |
\u{XXXXX} |
chappement de codes Unicode. Par exemple, \u{2F804} est quivalent la combinaison d'chappements simples \uD87E\uDC04. |
Pour les caractres qui ne font pas partie du tableau prcdent, les barres obliques inverses (backslash) les prcdant sont ignores. Cependant, cet usage est obsolte et devrait tre vit.
En prcdant d'une barre oblique inverse les guillemets droits doubles, on chappe ces caractres. Voici un exemple :
var citation = "Il lit \"Bug Jargal\" de V. Hugo.";
console.log(citation);
Le rsultat serait alors
Il lit "Bug Jargal" de V. Hugo.
Pour inclure une barre oblique inverse dans une chane de caractres, il faut aussi l'chapper. Par exemple, pour stocker le chemin c:\temp dans une chane de caractres, on utilisera le code suivant :
var chemin = "c:\\temp";
Il est galement possible d'chapper des sauts de lignes de la mme faon. La barre oblique inverse et le saut de ligne seront alors ignors dans la valeur de la chane de caractres.
var str =
"cette chane \
est casse \
sur plusieurs \
lignes.";
console.log(str); // cette chane est casse sur plusieurs lignes.
Avant ECMAScript 2015 (ES6), JavaScript ne disposait pas d'une syntaxe permettant de traiter les chanes de caractres comme des contenus de fichier, il est possible d'ajouter un caractre de saut de ligne chapp et un saut de ligne en fin de ligne en utilisant cette faon :
var pome =
"Les roses sont rouges,\n\
Les violettes sont bleues.\n\
Le miel est sucr,\n\
Et moi je suis.";
Grce ES6, on peut utiliser des littraux de gabarits qui offrent de nouvelles fonctionnalits dont une qui permet d'avoir des chanes de caractres crites sur plusieurs lignes :
var pome = `Les roses sont rouges,
Les violettes sont bleues,
Le miel est sucr,
Et moi je suis.`;
Ce chapitre est centr sur les bases de la syntaxe, les dclarations et les types utiliss en JavaScript. Pour en savoir plus sur les diffrents composants du langage, voir les chapitres suivants du guide:
Dans le chapitre suivant, on abordera les structures conditionnelles, permettant de diriger le flux d'instructions et la gestion des erreurs.
Cette page a t modifie le 22 mai 2026 par les contributeurices du MDN.
Certaines parties de ce contenu sont protges par le droit d'auteur 19982026 des contributeurs individuels de mozilla.org. Contenu disponible sous une licence Creative Commons.
| Web Proxy Viewer | New URL | Original Page |