Guide JavaScript 1.5:À propos:Caractéristiques du langage

Un article de MDC.

Sommaire 1 Valeurs 1.1 Conversion entre types de données 2 Variables 2.1 Déclarer une variable 2.2 Évaluer une variable 2.3 Portée d'une variable 2.4 Variables globales 3 Constantes 4 Constantes littérales 4.1 Tableaux 4.2 Valeurs booléennes 4.3 Entiers 4.4 Nombres à virgule flottante 4.5 Objets 4.6 Chaînes 4.6.1 Utiliser des caractères spéciaux à l'intérieur des chaînes 4.6.2 Échappement des caractères 5 Unicode 5.1 Compatibilité d'Unicode avec ASCII et ISO 5.2 Séquences d'échappement Unicode 5.3 Caractères Unicode dans les fichiers JavaScript 5.4 Afficher des caractères Unicode

[modifier] Valeurs

JavaScript reconnaît les types de valeurs suivants :

• Les nombres, par exemple 42 ou 3.14159.
• Les valeurs logiques (ou booléennes), true ou false.
• Les chaînes, par exemple "Cool !"
• null, un mot-clé spécial qui dénote l'absence de valeur ; null constitue aussi une valeur primitive. Comme JavaScript est sensible à la casse, null n'est pas la même chose que Null, NULL ou toute autre variante.
• undefined, une propriété de haut niveau dont la valeur est indéfinie ; undefined constitue aussi une valeur primitive.

Cet ensemble relativement restreint de types de valeurs, ou types de données, vous permet d'effectuer quelques actions utiles à l'intérieur de vos applications. Il n'y a pas de distinction explicite entre nombre entier et nombre réel ; il n'y a pas non plus de type de données explicite pour représenter les dates en JavaScript. Toutefois, vous pouvez utiliser l'objet Date et ses méthodes associées afin de travailler avec des dates.

Les objets et fonctions constituent les autres éléments fondamentaux du langage. Vous pouvez penser aux objets comme des conteneurs portant un nom et regroupant valeurs et fonctions au sein d'une même entité, les fonctions faisant office de procédures que votre application peut utiliser.

[modifier] Conversion entre types de données

JavaScript est un langage typé dynamiquement. Cela signifie qu'il n'est pas nécessaire de spécifier le type de données d'une variable lors de sa déclaration, et aussi que les types de données sont convertis automatiquement dès que cela s'avère nécessaire au cours de l'exécution du script. Ainsi, à titre d'exemple, vous pourriez définir une variable de la manière suivante :

 var reponse = 42

Et, plus tard, vous pourriez affecter à cette même variable une chaîne :

reponse = "Encore merci pour le poisson..."

Comme JavaScript est typé dynamiquement, cette affectation ne déclenche aucun message d'erreur.

Pour les expressions appliquant l'opérateur + à des valeurs numériques et des chaînes, JavaScript convertit les valeurs numériques en chaînes. Par exemple, observez la paire d'instructions suivante :

x = "La réponse est " + 42 // renvoie "La réponse est 42"
y = 42 + " est la réponse" // renvoie "42 est la réponse"

Pour les instructions utilisant d'autres opérateurs, JavaScript ne convertit pas les valeurs numériques en chaînes. À titre d'exemple :

"37" - 7 // renvoie 30
"37" + 7 // renvoie "377"

[modifier] Variables

Une variable est un nom symbolique désignant une valeur de votre application. Les noms de variables, appelés identifiants, se conforment à certaines règles.

Un identifiant JavaScript doit commencer par une lettre, un tiret bas (_) ou un signe dollar ($) ; les caractères suivants peuvent être tout cela plus des chiffres (0 à 9). Comme JavaScript est sensible à la casse, les lettres constituent à la fois les caractères A à Z (caractères majuscules) et les caractères a à z (caractères minuscules).

À partir de JavaScript 1.5, vous pouvez utiliser des lettres ISO-8859-1 ou Unicode dans vos identifiants, par exemple å et ü. Vous pouvez aussi utiliser certaines séquences d'échappement Unicode \uXXXX dans vos identifiants (les séquences d'échappement Unicode pouvant être utilisées sont décrites sur la page Séquences d'échappement Unicode).

Par exemple, Nombre_de_hits, temp99 et _prénom sont des noms légaux.

[modifier] Déclarer une variable

Une variable peut être déclarée de deux manières :

• Grâce au mot-clé var. Par exemple, var x = 42. Cette syntaxe peut être utilisée pour déclarer des variables tant locales que globales.
• En lui assignant simplement une valeur. Par exemple, x = 42. Cette syntaxe déclare toujours une variable globale et génère un avertissement strict en JavaScript. Cette variante ne devrait pas être utilisée.

[modifier] Évaluer une variable

Une variable déclarée avec l'instruction var sans valeur initiale aura la valeur undefined.

Toute tentative d'accéder à une variable non déclarée provoquera le déclenchement d'une exception ReferenceError :

var a;
print("La valeur de a est " + a); // affiche "La valeur de a est undefined"
print("La valeur de b est " + b); // déclenche une exception ReferenceError

Vous pouvez utiliser undefined pour déterminer si une variable possède une valeur. Dans le code suivant, la variable input ne s'est pas vue affecter de valeur et la condition de l'instruction if est vraie (true) :

var input;
if(input == undefined) {
  faireCeci();
} else {
  faireCela();
}

La valeur undefined est considérée comme fausse (false) lorsqu'elle est utilisée dans un contexte booléen. À titre d'exemple, le code suivant exécute la fonction maFonction car l'élément du tableau monTableau n'est pas défini :

monTableau = new Array();
if (!monTableau[0])
  maFonction();

Lorsque vous évaluez une variable nulle, la valeur null est considérée comme 0 lorsque convertie en valeur numérique et comme fausse (false) lorsqu'utilisée dans un contexte booléen. À titre d'exemple :

var n = null;
n * 32; // Renvoie 0

[modifier] Portée d'une variable

Lorsqu'une variable est définie en dehors de toute fonction, elle est dite globale car elle est disponible pour tout autre code du document actuel. Lorsqu'une variable est déclarée à l'intérieur d'une fonction, elle est dite locale car elle n'est disponible que pour cette fonction. JavaScript ne possède pas de portée correspondant aux blocs ; une variable déclarée à l'intérieur d'un bloc a pour portée la même portée que le code dans lequel réside le bloc. Par exemple, le code qui suit affichera 0 plutôt que de provoquer une exception si condition vaut false :

if (condition) {
  var x = 5;
}
print(x ? x : 0);

Une autre chose inhabituelle à propos des variables en JavaScript est qu'il est possible de se référer à une variable déclarée plus tard sans déclencher d'exception :

 print(x === undefined); // affiche "true"
 var x = 3;

[modifier] Variables globales

Les variables globales sont en fait des propriétés de l'objet global. Dans les pages Web, l'objet global est window, il est donc possible de définir et d'accéder à des variables globales en utilisant la syntaxe window.variable.

Par conséquent, il est possible d'accéder aux variables globales déclarées dans une fenêtre ou un cadre à partir d'une autre fenêtre ou d'un autre cadre en spécifiant le nom de la fenêtre ou du cadre correspondant. À titre d'exemple, si une variable nommée numéroDeTel est déclarée à l'intérieur d'un document contenant une balise FRAMESET, vous pouvez faire référence à cette variable à partir d'un cadre-fils en écrivant parent.numéroDeTel.

[modifier] Constantes

Vous pouvez créer une constante en lecture seule portant un nom grâce au mot-clé const. La syntaxe des identifiants de constantes est la même que pour les identifiants de variables : ils doivent commencer par une lettre ou un tiret bas et peuvent contenir des caractères alphabétiques ou numériques ou des tirets bas.

 const prefixe = '212';

Une constante ne peut pas se voir affecter une nouvelle valeur ou être redéclarée pendant l'exécution du script.

Les règles de portée concernant les constantes sont les mêmes que pour les variables, sauf que le mot-clé const sera toujours requis, et ce même pour les constantes globales. Si le mot-clé const est omis, l'identifiant est supposé représenter une variable.

Vous ne pouvez pas déclarer une constante portant le même nom qu'une fonction ou variable située dans la même portée. À titre d'exemple :

// CECI PROVOQUERA UNE ERREUR
function f() {};
const f = 5;

// CECI PROVOQUERA AUSSI UNE ERREUR
function f() {
  const g = 5;
  var g;

  // instructions

}

[modifier] Constantes littérales

Les constantes littérales servent à représenter des valeurs en JavaScript. Elles constituent des valeurs fixes, et non des variables. On les appelle ainsi car elles sont spécifiées de manière littérale dans le script. Cette section décrit les types suivants de constantes littérales :

• Tableaux
• Valeurs booléennes
• Nombres à virgule flottante
• Entiers
• Objets
• Chaînes

[modifier] Tableaux

Une constante littérale représentant un tableau est une liste d'expressions (zéro ou plus) entre crochets ([]). Chacune d'entre elles correspond à un élément du tableau. Lorsque qu'un tableau est créé à partir d'une telle constante, celui-ci se voit affecter les valeurs spécifiées en tant qu'éléments et le nombre d'expressions spécifiées constitue la longueur du tableau.

L'exemple suivant crée un tableau baptisé cafés contenant trois éléments et ayant une longueur de trois :

cafés = ["Arabica", "Expresso", "Cappuccino"];

Note : Les constantes littérales représentant des tableaux constituent un type particulier d'initialisateurs d'objets. Voir la page Utilisation des initialisateurs d'objets.

Si un tableau est utilisé directement comme une constante littérale dans un script de premier niveau, JavaScript l'interprète à chaque fois qu'il évalue l'expression contenant la constante littérale. De plus, une constante littérale à l'intérieur d'une fonction est créée à chaque appel de la fonction.

Les constantes littérales représentant des tableaux sont aussi des objets Array. Voir la page concernant l'objet Array pour plus de détails concernant les objets Array.

Virgules supplémentaires

Il n'est pas nécessaire de spécifier tous les éléments d'un tableau dans une constante littérale. Si vous écrivez deux virgules à la suite, l'objet Array allouera de l'espace pour les éléments non-spécifiés. L'exemple suivant crée un tableau poissons :

poissons = ["Lion", , "Clown"];

Cet objet Array possède deux éléments ayant une valeur et un élément vide (poissons[0] est "Lion", poissons[1] est undefined et poissons[2] est "Clown").

Si une virgule est placée à la fin de la liste des éléments, elle est ignorée. Dans l'exemple suivant, la longueur de maListe est trois. Il n'existe pas d'élément maListe[3]. Toutes les autres virgules de la liste indiquent la présence d'un nouvel élément.

maListe = ['maison', , 'école', ];

Dans l'exemple suivant, la longueur de maListe est quatre, alors que maListe[0] et maListe[2] ne sont pas définis.

maListe = [, 'maison', , 'école'];

Dans l'exemple suivant, la longueur de maListe est quatre, alors que maListe[1] et maListe[3] ne sont pas définis. Seule la virgule finale est ignorée : elle est facultative.

maListe = ['maison', , 'ecole', ,];

[modifier] Valeurs booléennes

Le type booléen possède deux constantes littérales : true et false.

Ne confondez pas les valeurs booléennes primitives true et false avec les valeurs true et false de l'objet Boolean. L'objet Boolean enchâsse le type booléen primitif. Voir la page concernant l'objet Boolean pour plus d'informations.

[modifier] Entiers

Les entiers peuvent être exprimés en base 10 (décimal), base 16 (hexadécimal) et base 8 (octal). Un entier décimal est constitué d'une série de chiffres sans 0 (zéro) au début. Un 0 (zéro) au début d'un entier indique que c'est un entier octal ; 0x (ou 0X) au début d'un entier indique que l'entier est hexadécimal. Les entiers hexadécimaux peuvent contenir des chiffres (de 0 à 9) et les lettres a à f ou A à F. Les entiers octaux ne peuvent contenir que les chiffres 0 à 7.

Les entiers octaux sont obsolètes et ont été supprimés du standard ECMA-262 édition 3. JavaScript 1.5 continue à les prendre en charge pour des raisons de compatibilité.

Quelques exemples d'entiers :

• 0, 117 et -345 (entiers décimaux, base 10)
• 015, 0001 et -077 (entiers octaux, base 8)
• 0x1123, 0x00111 et -0xF1A7 (entiers hexadécimaux, base 16)

[modifier] Nombres à virgule flottante

Un nombre à virgule flottante peut posséder les parties suivantes :

• Un entier décimal
• Une virgule décimale (c'est en fait un « . » en anglais)
• Une fraction (un autre nombre décimal)
• Un exposant

La partie exposant est constituée d'un e minuscule ou E majuscule suivi d'un entier, celui-ci pouvant être signé (c'est-à-dire précédé d'un + ou d'un -). Un nombre à virgule flottante doit posséder au moins un chiffre, avec une virgule ou e (ou E).

Quelques exemples de nombres à virgule flottante : 3.1415, -3.1E12, .1e12 et 2E-12.

[modifier] Objets

Un objet littéral est une liste de paires (zéro ou plus) entre accolades ({}), chaque paire associant un nom de propriété à sa valeur. Il est déconseillé d'utiliser un objet littéral au début d'une instruction. Cela provoquera une erreur ou un comportement inattendu, car l'accolade { sera interprétée comme le début d'un bloc.

Le code suivant donne un exemple d'objet littéral. Le premier élément de l'objet littéral voiture définit une propriété, maVoiture. Le deuxième élément, qui définit la propriété obtVoiture, invoque la fonction TypesDeVoiture("Honda"). Le troisième élément, qui définit la propriété special, utilise une variable existante (Vente).

var Vente = "Toyota";

function TypesDeVoiture(nom) {
  if(nom == "Honda")
     return nom;
  else
     return "Désolés, nous ne vendons pas de modèles " + nom + ".";
}

voiture = {maVoiture: "Saturn", obtVoiture: TypesDeVoiture("Honda"), special: Vente}

document.write(voiture.maVoiture);  // Saturn
document.write(voiture.obtVoiture); // Honda
document.write(voiture.special);    // Toyota

De plus, vous pouvez utiliser une constante littérale numérique ou une chaîne comme nom de propriété, ainsi qu'enchâsser un objet à l'intérieur d'un autre. L'exemple suivant fait usage de ces fonctionnalités :

voiture = {plusieursVoitures: {a: "Saab", b: "Jeep"}, 7: "Mazda"}

document.write(voiture.plusieursVoitures.b); // Jeep
document.write(voiture[7]); // Mazda

Remarquez également que :

toto = {a: "alpha", 2: "deux"}
document.write (toto.a)   // alpha
document.write (toto[2])  // deux
//document.write (toto.2)  // Erreur : une parenthèse ) manque après la liste d'arguments
//document.write (toto[a]) // Erreur : a n'est pas défini
document.write (toto["a"]) // alpha
document.write (toto["2"]) // deux

[modifier] Chaînes

Une chaîne est constituée de zéro caractère ou plus inclus entre guillemets double (") ou simple ('). Une chaîne doit être délimitée par des guillemets du même type, c'est-à-dire deux guillemets doubles ou deux guillemets simples. Voici des exemples de chaînes :

• "beurk"
• 'beurk'
• "1234"
• "une ligne \n une autre ligne"
• "Le chat de Jean"

Vous pouvez appeler les méthodes de l'objet String à partir d'une chaîne littérale - JavaScript convertit automatiquement la chaîne littérale en un objet String temporaire, appelle la méthode puis se débarasse de l'objet String temporaire. Vous pouvez aussi utiliser la propriété String.length avec une chaîne littérale :

"Le chat de Jean".length

Il est conseillé d'utiliser les chaînes littérales à moins que vous ayez tout particulièrement besoin d'utiliser un objet String. Voir la page concernant l'objet String pour plus de détails sur les objets String.

[modifier] Utiliser des caractères spéciaux à l'intérieur des chaînes

En plus des caractères ordinaires, vous pouvez aussi inclure des caractères spéciaux à l'intérieur de vos chaînes, comme le montre l'exemple suivant.

"une ligne \n une autre ligne"

Le tableau suivant dresse la liste des caractères spéciaux que vous pouvez utiliser dans les chaînes JavaScript.

Caractère	Signification
\b	Retour arrière
\f	Saut de page
\n	Nouvelle ligne
\r	Retour chariot
\t	Tabulation
\v	Tabulation verticale
\'	Apostrophe ou guillemet simple
\"	Guillemet double
\\	Caractère antislash (\)
\XXX	Le caractère du codage Latin-1 correspondant aux trois chiffres octaux XXX (entre 0 et 377). À titre d'exemple, \251 constitue la séquence octale correspondant au symbole « copyright ».
\xXX	Le caractère du codage Latin-1 correspondant aux deux chiffres hexadécimaux XX (entre 00 et FF). À titre d'exemple, \xA9 constitue la séquence hexadécimale correspondant au symbole « copyright ».
\uXXXX	Le caractère Unicode correspondant aux quatre chiffres hexadécimaux XXXX. À titre d'exemple, \u00A9 constitue la séquence Unicode correspondant au symbole « copyright ». Voir la page Séquences d'échappement Unicode.

Tableau 2.1 : Caractères spéciaux de JavaScript

[modifier] Échappement des caractères

Pour les caractères qui ne sont pas présents dans le tableau 2.1, tout antislash précédant un tel caractère sera ignoré mais cet emploi de l'antislash est obsolète et il est conseillé de l'éviter.

Vous pouvez insérer un guillemet à l'intérieur d'une chaîne en le précédant d'un antislash. Ce procédé est connu sous le nom d'échappement du guillemet. À titre d'exemple :

var citation = "J'ai lu \"Les misérables\" de Victor Hugo."
document.write(citation)

Pour inclure un caractère antislash littéral à l'intérieur d'une chaîne, vous devez échapper l'antislash. À titre d'exemple, pour affecter le chemin d'accès c:\temp à une chaîne, utilisez le code suivant :

var accueil = "c:\\temp"

[modifier] Unicode

Unicode est un standard universel en matière de codage de caractères, qui garantit l'affichage et l'échange des principales langues écrites. Unicode prend en charge les langues d'Amérique, d'Europe, du Moyen-Orient, d'Afrique, de l'Inde, d'Asie et du Pacifique, ainsi que quelques écritures historiques et des symboles techniques. Unicode autorise aussi bien l'échange, le traitement et l'affichage de textes multilingues que l'emploi de symboles techniques ou mathématiques courants. Son ambition est de résoudre les problèmes d'internationalisation inhérents à l'informatique multilingue, tels que les problèmes liés à la variété des standards nationaux en matière de codage de caractères. Toutes les écritures modernes ou archaïques ne sont cependant pas encore totalement prises en charge.

Le jeu de caractères Unicode peut être utilisé pour tous les encodages connus. Unicode est construit à partir du jeu de caractères ASCII (American Standard Code for Information Interchange). Unicode associe une valeur numérique et un nom à chaque caractère. Le codage de caractères utilisé spécifie quant à lui l'identité de chaque caractère ainsi que sa valeur numérique (sa position codée) et sa représentation en bits. La valeur numérique, codée sur 16 bits (valeur codée), est définie par un nombre hexadécimal et un préfixe U; à titre d'exemple, U+0041 représente la lettre A. Le nom unique associé à cette valeur est LATIN CAPITAL LETTER A (LETTRE MAJUSCULE LATINE A).

Unicode n'est pas pris en charge par les versions de JavaScript antérieures à la version 1.3.

[modifier] Compatibilité d'Unicode avec ASCII et ISO

Unicode est entièrement compatible ISO/IEC 10646-1; 1993, un standard international faisant partie de la norme ISO 10646.

Plusieurs standards dédiés au codage (tels que UTF-8, UTF-16 et ISO UCS-2) sont utilisés afin de représenter physiquement les caractères Unicode en bits.

Le codage UTF-8 d'Unicode est compatible avec les caractères ASCII et est pris en charge par de nombreux programmes. Les 128 premiers caractères Unicode correspondent aux caractères ASCII et possèdent la même valeur sont codés de la même façon sur un octet. Les caractères Unicode U+0020 à U+007E sont équivalents aux caractères ASCII 0x20 à 0x7E. Contrairement à ASCII, qui prend en charge uniquement l'alphabet latin et utilise un jeu de caractères codés sur 7 bits, UTF-8 peut utiliser de un à quatre octets pour la représentation de chaque caractère. Ceci permet la représentation de millions de caractères. Un autre standard dédié au codage, UTF-16, utilise deux octets pour la représentation des caractères Unicode. Une séquence d'échappement permet avec UTF-16 de représenter n'importe quel caractère Unicode sur quatre octets.

Le standard ISO UCS-2 (Universal Character Set) utilise deux octets (ou 16 bits).

JavaScript et Mozilla prennent en charge UTF-8/Unicode ; cela signifie que vous pouvez utiliser des caractères non-latins, internationaux et localisés (plus quelques symboles techniques spéciaux) dans vos programmes JavaScript. Unicode fournit une méthode standard de codage de textes multilingues. Comme le codage UTF-8 d'Unicode est compatible ASCII, les programmes peuvent aussi utiliser des caractères ASCII. Vous pouvez utiliser des caractères Unicode non-ASCII dans les commentaires, les chaînes littérales, les identifiants et les expressions régulières de JavaScript.

[modifier] Séquences d'échappement Unicode

Vous pouvez utiliser la séquence d'échappement Unicode à l'intérieur des chaînes littérales, des expressions régulières et des identifiants. La séquence d'échappement est constituée de six caractères ASCII : \u et un nombre hexadécimal à quatre chiffres. À titre d'exemple, \u00A9 représente le symbole « copyright ». En JavaScript, chaque séquence d'échappement Unicode est interprétée comme un caractère.

Le code suivant renvoie le symbole « copyright » et la chaîne « Netscape Communications ».

x = "\u00A9 Netscape Communications"

Le tableau suivant dresse la liste des caractères spéciaux fréquemment utilisés ainsi que leur valeur Unicode associée.

Catégorie	Valeur Unicode	Nom	Nom du format
Blancs	\u0009	Tabulation	<TAB>
	\u000B	Tabulation verticale	<VT>
	\u000C	Saut de page	<FF>
	\u0020	Espace	<SP>
Fins de ligne	\u000A	Saut de ligne	<LF>
	\u000D	Retour chariot	<CR>
Autres	\u0008	Retour arrière	<BS>
	\u0009	Tabulation horizontale	<HT>
	\u0022	Guillemet double	"
	\u0027	Guillemet simple	'
	\u005C	Antislash	\

Tableau 2.2 : Valeurs Unicode de quelques caractères spéciaux

L'emploi qui est fait par JavaScript de la séquence d'échappement Unicode est différent de celui de Java. En JavaScript, la séquence d'échappement n'est jamais interprétée en tant que caractère spécial en début de phase d'interprétation. À titre d'exemple, une séquence d'échappement correspondant à une fin de ligne, à l'intérieur d'une chaîne, ne termine pas la chaîne avant son interprétation par la fonction. JavaScript ignore de plus les séquences d'échappement au sein des commentaires. En Java, si une séquence d'échappement est utilisée dans un commentaire sur une seule ligne, celle-ci est interprétée comme un caractère Unicode. À l'intérieur d'une chaîne littérale, le compilateur Java interprète en premier lieu les séquences d'échappement. Par exemple, si une séquence d'échappement correspondant à une fin de ligne (\u000A) est utilisée en Java, elle termine la chaîne littérale et cela conduit à une erreur car en Java les fins de ligne spécifiées avec séquences d'échappement Unicode ne sont pas autorisées dans les chaînes littérales. Il est uniquement possible d'utiliser \n pour changer de ligne au sein d'une chaîne littérale. En JavaScript, par contre, la séquence d'échappement fonctionne exactement comme \n.

[modifier] Caractères Unicode dans les fichiers JavaScript

Les premières versions de Gecko supposaient que le codage de caractères des fichiers JavaScript chargés à partir de XUL était le codage Latin-1. À partir de Gecko 1.8, le codage de caractères est déduit du codage du fichier XUL. Veuillez voir la page Caractères internationaux dans du JavaScript XUL pour plus d'informations.

[modifier] Afficher des caractères Unicode

Vous pouvez utiliser Unicode pour afficher les caractères de différentes langues, ou encore des symboles techniques. Pour que les caractères soient affichés correctement, le client (comme Mozilla Firefox ou Netscape) doit prendre en charge Unicode. De plus, une police Unicode appropriée doit être disponible pour le client et la plateforme sous-jacente doit prendre en charge Unicode. Souvent, les polices Unicode ne peuvent pas afficher tous les caractères Unicode. De plus, certaines plateformes comme Windows 95 n'offrent de plus qu'une prise en charge partielle d'Unicode.

Pour recevoir une entrée composée de caractères non-ASCII, le client doit envoyer cette entrée en utilisant le codage Unicode. Avec un clavier étendu standard, le client ne peut pas entrer facilement les caractères supplémentaires pris en charge par Unicode. Quelques fois, le seul moyen d'entrer des caractères Unicode est d'utiliser des séquences d'échappement Unicode.

Pour plus d'informations sur Unicode, consultez le site Web du consortium Unicode et le standard Unicode, version 2.0 (publié en anglais chez Addison-Wesley en 1996 sous le titre The Unicode Standard, Version 2.0).