Expressions rationnelles

Les expressions régulières sont des motifs utilisés pour correspondre à certaines combinaisons de caractères au sein des chaînes de caractères. En JavaScript, les expressions régulières sont également des objets. Ces motifs sont utilisés avec les méthodes exec et test d'un objet RegExp, et les méthodes match, replace, search, et split d'un objet String. Ce chapitre explique l'utilisation des expressions régulières en JavaScript.

Créer une expression régulière

Il est possible de construire une expression régulière de deux façons :

  • Utiliser un littéral d'expression régulière, par exemple :
    var re = /ab+c/;
    

    Les littéraux d'expression régulière fournissent une compilation de l'expression lorsque le script est évalué. Il est préférable d'utiliser cette méthode lorsque l'expression régulière reste constante, afin d'avoir de meilleurs performances.

  • Appeler le constructeur de l'objet RegExp, par exemple :
    var re = new RegExp("ab+c");
    

    Cette méthode fournit une compilation de l'expression régulière à l'exécution. Elle est à utiliser lorsque le motif utilisé est variable ou provient d'une autre source (par exemple une interaction utilisateur).

Écrire une expression régulière

Un motif d'une expression régulière est composé de caractères simples (comme /abc/), ou de caractères simples et spéciaux, comme /ab*c/ ou /Chapitre (\d+)\.\d*/ . Le dernier exemple utilise des parenthèses qui permettent d'avoir une certaine mémoire. La correspondance avec le motif contenu entre parenthèses pourra être utilisée par la suite. Ceci est décrit avec Using Parenthesized Substring Matches.

Utiliser des motifs simples

Les motifs simples sont construits à partir de caractères pour lesquels on souhaite avoir une correspondance directe. Le motif /des/ correspond lorsqu'on observe exactement les caractères 'abc' ensemble et dans cet ordre précis. On pourrait utiliser ce motif et détecter une correspondance dans les chaînes suivantes : "J'ai vu des licornes ?" et "Sa description de licorne était superbe" car la chaîne de caractères 'des' y est présente. Il n'y aura pas de correspondance avec la chaîne de caractères "Toc toc" car 'des' n'est pas présente.

Utiliser des caractères spéciaux

Lorsque le motif à trouver est plus complexe qu'une simple égalité (trouver tous les B, les blancs...), le motif devra contenir des caractères spéciaux. Ainsi, le motif /ab*c/ correspond à toutes les combinaisons de caractères qui ont un seul 'a' suivi de zéro ou plusieurs 'b' (l'astérisque utilisée ici signifie que l'élément qui la précède doit être présent zéro ou plusieurs fois) qui sont immédiatement suivis d'un 'c'. Par exemple, la chaîne de caractère "cbbabbbbcdebc" correspond au motif avec la chaîne de caractères 'abbbbc'.

La tableau qui suit fournit une liste complète des caractères spéciaux pouvant être utilisés dans les expressions régulières ainsi que leur signification.

Tableau 4.1 Caractères spéciaux utilisables pour les expressions régulières.
Caractère Signification
\

Correspond selon les règles suivantes :

Une barre oblique inversée (backslash) précédant un caractère non spécial indique que le caractère qui suit est spécial et qu'il ne doit pas être interprété directement. Ainsi, un 'b', sans '\' avant, correspondra pour les 'b' minuscules quel que soit leur position. En revanche '\b' ne correspondra à aucun caractère mais indique un caractère de fin de mot.

Un backslash précédant un caractère spécial indique que le caractère qui suit doit être interprété littéralement (et pas comme un caractère spécial). Ainsi, le motif /a*/ utilise le caractère spécial '*' pour correspondre à 0 ou plusieurs 'a'. Le motif /a\*/, au contraire, rend '*' non-spécial pour correspondre aux chaînes de caractères comme 'a*'.

Il ne faut pas oublier d'échapper le caractère '\' car lui-même est un caractère d'échappement dans les chaînes de caractères. Cela est utile lorsqu'on utilise la notation RegExp("motif").

^ Correspond au début la séquence. Si le drapeau (flag) de lignes multiples vaut true, il correspondra également immédiatement après un caractère de saut de ligne.

Ainsi, /^A/ ne correspond pas au 'A' de "un A", mais correspond au 'A' de "A toi".

Le caractère '^' possède un sens différent lorsqu'il est utilisé dans un motif d'ensemble de caractères. Voir les compléments sur les ensembles de caractères pour plus de détails et d'exemples.
$

Correspond à la fin de la séquence. (flag) de lignes multiples vaut true, il correspondra également immédiatement avant un caractère de saut de ligne.

Ainsi, /t$/ ne correspond pas au 't' de "printemps", mais correspond au 't' de "aliment".

*

Correspond au caractère précédent qui est répété 0 ou plusieurs fois.

Ainsi, /bo*/ correspond à 'boo' dans "Un booléen" et à 'b' dans "Un bateau bleu", mais ne correspond à rien dans "Ce matin".

+

Correspond au caractère précédent qui est répété une ou plusieurs fois. C'est équivalent à {1,}.

Ainsi, /a+/ correspond au 'a' dans "maison" et à tous les 'a' dans "maaaaaaison".

? Correspond au caractère précédent qui est présent une fois ou pas du tout. C'est équivalent à {0,1}.

Ainsi, /e?le?/ correspond au 'el' dans "gel" et au 'le' dans "angle" mais aussi au 'l' dans "Oslo".

S'il est utilisé immédiatement après l'un des quantificateurs : *, +, ?, ou {}, il rend le quantificateur moins « gourmand » pour que le moins de caractères corresponde (le comportement par défaut, « gourmand », permettant de faire correspondre le plus de caractères possible). Par exemple /\d+/ utilisée avec "123abc" fait correspondre "123". Utiliser /\d+?/ à la même chaîne de caractères fait correspondre "1".

Ce symbole est également utilisé dans les tests de présence autour de l'expression qui sont décrits par les lignes x(?=y) et x(?!y) de ce tableau.
 
.

(Le point) correspond à n'importe quel caractère excepté un caractère de saut de ligne.

Ainsi, /.n/ correspond à  'un' et 'en' dans "Un baobab nain en cours de  croissance" mais pas à 'nain'.

(x)

Correspond à 'x' et garde la correspondance en mémoire. Les parenthèses permettent de capturer l'expression.

Les '(toto)' et '(truc)', dans le motif /(toto) (truc) \1 \2/ correspondent et gardent en mémoire les deux premiers mots de la chaîne de caractère "toto truc toto truc". Les \1 et \2 du motif correspondent aux deux derniers mots de la chaîne.

(?:x) Correspond à 'x' mais ne garde pas la correspondance en mémoire. Les parenthèses ne capturent pas l'expression et permettent d'utiliser des sous-expressions d'une expression régulière pour travailler plus finement. L'expression /(?:zoo){1,2}/ sans parenthèes non-capturantes les caractères {1,2} ne s'appliqueraient qu'au dernier 'o' de 'zoo'. Avec les parenthèses capturantes, {1,2} s'applique au mot entier 'zoo'.
x(?=y)

Correspond à 'x' seulement s'il est suivi de 'y'. On appelle cela un test de succession (lookahead).

Ainsi, /Jack(?=Sparrow)/ correspond à 'Jack' seulement s'il est suivi de 'Sparrow'. /Jack(?=Sparrow|Bauer)/ correspond à 'Jack' seulement s'il est suivi de 'Sparrow' ou de 'Bauer'. Cependant, ni 'Sparrow' ni 'Bauer' ne feront partie de la correspondance.

x(?!y)

Correspond à 'x' seulement si 'x' n'est pas suivi de 'y'.

Ainsi, /\d+(?!\.)/ correspond à un nombre qui n'est pas suivi par un point, cette expression utilisée avec la chaîne 3.141 correspondra pour '141' mais pas pour '3.141'.

x|y

Correspond à 'x' ou 'y'.

Ainsi, /vert|rouge/ correspond à 'vert' dans "feu vert" et à 'rouge' dans "feu rouge".

{n} Correspond pour exactement n occurences du caractère précédent. N doit être un entier positif.

Ainsi, /a{2}/ ne correspond pas au 'a' de "Mozilla" mais correspond à tous les 'a' de "Mozilaa" et aux deux premiers 'a' de "Mozillaaa".
{n,m}

Lorsque n et m sont des entiers positifs, cela correspond à au moins n occurences du caractère précédent et à au plus m occurrences. Lorsque m est nul, il est facultatif.

Ainsi, /a{1,3}/ ne correspond à rien dans "Mozill", au 'a' de "Mozilla", au deux premiers 'a' de "Mozilla" et au trois premiers 'a' de "Mozillaaaaa". Pour ce dernier exemple, on doit noter que le correspondance ne se fait que sur "aaa" bien qu'il y ait plus de 'a' dans la chaîne de caractères.

[xyz] Un ensemble de caractère. Ce type de motif correspond pour n'importe quel caractètre présent entre les crochets, y compris les séquences d'échappement. Les caractères spéciaux comme le point (.) et l'astérisque ne sont pas considérés comme spéciaux au sein d'un ensemble et n'ont donc pas besoin d'être échappés. Il est possible de donner un ensemble sur un éventail de caractères en utilisant un tiret (-), comme le montre l'exemple qui suit.

Le motif [a-d],  aura les mêmes correspondances que [abcd], correspondant au 'b' de "bulle" et au 'c' de "ciel". Les motifis /[a-z.]+/ et /[\w.]+/ correspondront pour la chaîne entirère : "Adre.ss.e".
[^xyz]

Exclusion d'un ensemble de caractères. Cela correspond à tout ce qui n'est pas compris entre crochets. Il est possible de fournir un éventail de caractères en utilisant un tiret (-). Les autres règles qui s'appliquent pour l'ensemble de caractères (ci-avant) s'appliquent également ici.

Par exemple, [^abc] est équivalent à [^a-c]. Ils correspondent à 'u' dans "bulle" et à 'i' dans "ciel".

[\b] Correspond pour un retour arrière (U+0008). (À ne pas confondre avec \ b.)
\b

Correspond à une limite de mot. Une limite de mot correspond à la position où un caractère d'un mot n'est pas suivi ou précédé d'un autre caractère de mot. Il faut savoir que la limite correspondante n'est pas incluse dans le résultat. Autrement dit, la longueur d'une telle correspondance est nulle. (À ne pas confondre avec [\b].)

Exemples :
/\bm/ correspond au 'm' in "mignon" ;
/no\b/ ne correspond pas au  'no' de "mignon" car 'no' est suivi de 'n' qui est un caractère de mot;
/non\b/ correspond au 'non' de "mignon" car 'non' représente la fin de la chaîne de caractère et n'est donc pas suivi par un caractère de mot.
/\w\b\w/ ne correspondra jamais à quoi que ce soit car un caractère de mot ne peut pas être suivi à la fois par un caractère de mot et un caractère n'étant pas un caractère de mot.

\B

Correspond à une « non-limite » de mot. Cela correspond pour une position où le caractère précédent et le caractère suivant sont du même type : les deux étant des caractères mot ou les deux n'étant pas des caractères de mot. Le début et la fin d'une chaîne de caractères sont considérés comme n'étant pas des caractères de mots.

Ainsi, /\B../ correspond au 'oo' de "football" (et /e\B./ correspond au 'me' dans "une mer "

\cX

Étant donné un caractère X compris entre A et Z, cela correspond au caractère de contrôle dans une chaîne de caractères.

Ainsi, /\cM/ correspond au caractère de contrôle M (U+000D) d'une chaîne de caractère.

\d

Correspond à un chiffre et est équivalent à [0-9].

Ainsi, /\d/ ou /[0-9]/ correspond à '2' dans "H2O est la molécule de l'eau".

\D

Correspond à tout caractère qui n'est pas un chiffre et est équivalent à [^0-9].

Ainsi, /\D/ ou /[^0-9]/ correspond à 'H' dans "H2O est la molécule de l'eau".

\f Correspond à un saut de page (U+000C).
\n Correspond à un saut de ligne (U+000A).
\r Correspond à un retour chariot (U+000D).
\s

Correspond à un blanc (cela comprend les espace, tabulation, saut de ligne ou saut de page). C'est équivalent à [ \f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​​\u202f\u205f​\u3000].

Ainsi, /\s\w*/ correspond à ' toto' in "truc toto".

\S

Correspond à un caractère qui n'est pas un blanc. C'est équivalent à [^ \f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u202f\u205f​\u3000].

Ainsi, /\S\w*/ correspond à 'truc' dans "truc toto".

\t Correspond à une tabulation (U+0009).
\v Correspond à une tabulation verticale (U+000B).
\w

Correspond à n'importe quel caractère alphanumérique, y compris le tiret bas. C'est équivalent à [A-Za-z0-9_].

Ainsi, /\w/ correspond à 'l' dans "licorne", à '5' dans "5,28€", et à '3' dans "3D."

\W

Correspond à n'importe quel caractère n'étant pas un caractère de mot. Cela est équivalent à [^A-Za-z0-9_].

Ainsi, /\W/ ou /[^A-Za-z0-9_]/ correspond à '%' dans "50%."

\n

Soit n un entier strictement positif, cela fait référence au groupe de la n-ième expression entre parenthèses (en comptant les parenthèses ouvrantes).

Ainsi, /pomme(,)\spoire\1/ correspond à 'pomme, poire,' dans "pomme, poire, cerise, pêche".

\0 Correspond au caractère NULL (U+0000). Il ne doit pas être suivi d'un autre chiffre car \0<chiffres> est une séquence d'échappement pour les nombres en notation octale.
\xhh Correspond au caractère dont le code hexadécimal est hh (deux chiffres hexadécimaux).
\uhhhh Correspond au caractère dont le code est hhhh (quatre chiffres hexadécimaux).

Afin d'échapper les informations saisies par l'utilisateur et de traîter les chaînes de caractères pour les utiliser au sein d'un expression régulière correspondante, il est possible d'utiliser le remplacement suivant :

function escapeRegExp(string){
  return string.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
}

Utiliser les parenthèses

Les parenthèses encadrant une partie du motif de l'expression régulière peuvent être utilisées pour garder en mémoire les correspondances. Cela pourra être utile pour réutiliser la correspondance trouvée.

Ainsi, le motif /Chapitre (\d+)\.\d*/ utilise des caractères échappés et spéciaux et indique une partie du motif à garder en mémoire. Ce motif correspond aux caractères 'Chapitre ' suivi par un ou plusieurs caractères numériques (\d correspond à un chiffre et + indiquant que une série de 1 ou plusieurs chiffres), suivis par un point (qu'il est nécessaire d'échapper car c'est un caractère spécial, on utilise donc '\' pour indiquer qu'on souhaite reconnaître le caractère '.'), suivi par 0 ou plusieurs chiffres (\d correspondant à un chiffre et l'astérisque indiquant que le caractère est présent 0 ou plusieurs fois). Les parenthèses étant utilisées pour garder en mémoire les premiers chiffres correspondant.

Ce motif est trouvé dans "Ouvrir le Chapitre 4.3 au paragraphe 6" et le chiffre '4' est gardé en mémoire. Le motif n'est pas trouvé dans  "Chapitre 3 et 4", car la chaîne de caractères ne comporte pas de point après le '3'.

Pour qu'une partie de la chaîne de caractère corresponde mais que la correspondance ne soit pas gardée en mémoire, on pourra utiliser ?:. Ainsi, (?:\d+) correspondra pour une séquence de chiffres (1 ou plusieurs chiffres) mais on ne gardera pas en mémoire les caractères correspondants.

Utiliser les expressions régulières

Les expresssions régulières sont utilisées avec les méthodes test et exec de l'objet RegExp et avec les méthodes match, replace, search, et split de l'objet String. Ces méthodes sont expliquées en détail dans la Référence JavaScript.

Tableau 4.2 Méthodes utilisant les expressions régulières
Méthode Description
exec Une méthode de l'objet RegExp qui exécute une recherche de correspondance dans une chaîne de caractères. Elle renvoie un tableau d'informations.
test Une méthode de l'objet RegExp testant la présence d'une correspondance dans une chaîne de caractères. Elle renvoie true ou false.
match Une méthode de l'objet String qui exécute une recherche de correspondance dans une chaîne de caractères. Elle renvoie un tableau d'informations ou null lorsqu'il n'y a pas de correspondance.
search Une méthode de l'objet String qui teste la présence d'une correspondance dans une chaîne de correspondance. Elle renvoie la position de la correspondance ou -1 s'il n'y en a pas.
replace Une méthode de l'objet String qui recherche une correspondance dans une chaîne de caractères et qui remplace la correspondance par une chaîne de substitution.
split Une méthode de l'objet String qui utilise une expression régulière ou une chaîne de caractères pour découper une chaîne de caractères en un tableau comprenant les fragments résultants.

Pour savoir si un motif est présent au sein d'une chaîne de caractères, les méthodes test ou search doivent être utilisées. Pour obtenir plus d'informations (moins rapidement) on utilisera les méthodes exec ou match. Si on utilise exec ou match et qu'une correspondance est trouvée, ces méthodes renverront un tableau et mettront à jour des propriétés de l'objet RegExp associé. Si aucune correspondance n'est trouvée, la méthode exec renverra null (qui correspondra à false lors d'un test conditionnel).

Dans l'exemple qui suit, le script utilise la méthode exec pour trouver une correspondance dans une chaîne de caractères.

var monExpressionReguliere = /d(b+)d/g;
var monTableau = monExpressionReguliere.exec("cdbbdbsbz");

S'il n'est pas nécessaire d'accéder aux propriétés de l'expression régulière, une autre façon de récupérer monTableau peut être :

var monTableau = /d(b+)d/g.exec("cdbbdbsbz");

Si on souhaite construire une expression régulière à partir d'une chaîne de caractères, on peut utiliser le script suivant :

var monExpressionReguliere = new RegExp("d(b+)d", "g");
var monTableau = monExpressionReguliere.exec("cdbbdbsbz");

Avec ces scripts, on obtient bien une correspondance, la méthode renvoie un tableau et met à jour les propriétés listées dans le tableau qui suit.

Tableau 4.3 Résultats dus à l'exécution d'une expression régulière.
Objet Propriété ou indice Description Pour cet exemple
monTableau   La chaîne de caractères correspondante et les fragments de chaînes gardés en mémoire. ["dbbd", "bb"]
index L'indice (compté en partant de 0) de la correspondance, compté dans la chaîne de caractère initiale. 1
input La chaîne de caractères initiale. "cdbbdbsbz"
[0] Les derniers caractères qui correspondent. "dbbd"
monExpressionRégulière lastIndex L'indice auquel débuter la prochaine correspondance. (Cette propriété n'est utilisée que si l'expression régulière utilise l'option g, décrite dans Advanced Searching With Flags.) 5
source Le texte du motif, mis à jour à la création de l'expression régulière mais pas lors de son exécution. "d(b+)d"

Comme le montre la seconde formulation de cet exemple, il est possible d'utiliser une expression régulière, créée avec un objet initialisé sans l'assigner à une variable. Cela implique qu'à chaque utilisation, on aura une nouvelle expression régulière, distincte et qu'on ne pourra pas, pour cette raison, accéder aux propriétés de l'expression régulière. Avec le script suivant :

var monExpressionReguliere = /d(b+)d/g;
var monTableau = monExpressionReguliere.exec("cdbbdbsbz");
console.log("La valeur de lastIndex est " + monExpressionReguliere.lastIndex);

L'affichage sera :

La valeur de lastIndex est 5

Si le script utilisé est :

var monTableau = /d(b+)d/g.exec("cdbbdbsbz");
console.log("La valeur de lastIndex est " + /d(b+)d/g.lastIndex);

L'affichage résultant sera :

La valeur de lastIndex est 0

Les occurences de /d(b+)d/g dans les deux instructions sont des objets différents. Leurs propriétés lastIndex respectives ont donc des valeurs différentes. Lorsqu'il est nécessaire d'accéder aux propriétés d'un objet correspondant à une expression régulière, il faudra d'abord l'assigner à une variable.

Utiliser les correspondances de groupes avec les parenthèses

Les parenthèses, utilisées dans un motif d'expression régulière, permettent de garder en mémoire un groupe (ou fragment) d'une correspondance. Ainsi, /a(b)c/ correspond aux caractères 'abc' et garde 'b' en mémoire. Pour récupérer ces fragments mémorisés, on peut utiliser les éléments du tableau array [1], ..., [n].

Le nombre de fragments qu'il est possible de garder entre parenthèses n'est pas limité. Le tableau renvoyé contiendra tout ce qui aura été trouvé. Les exemples qui suivent montrent comment utiliser cette syntaxe.

Premier exemple

Le script qui suit utilise la méthode replace() pour échanger les mots d'une chaîne de caractères. Pour remplacer le texte, le script utilise $1 et $2 qui correspondent au premier et deuxième groupe correspondant.

var re = /(\w+)\s(\w+)/;
var str = "Titi toto";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);

This prints "Toto, Titi".

Effectuer des recherches avancées en utilisant les drapeaux (flags)

Les expressions régulières peuvent être utilisées avec quatre drapeaux optionnels permettant des recherches globales et/ou ne respectant pas la casse. Ces drapeaux peuvent être utilisés séparement ou ensemble, quel que soit l'ordre. Ils font partie de l'expression régulière.

Tableau 4.4 Drapeaux utilisés avec les expressions régulières.
Drapeau (Flag) Description
g Recherche globale
i Recherche ne respectant pas la casse
m Recherche sur plusieurs lignes
y Effectue une recherche qui « adhère », en partant de la position courante de la chaîne de caractères sur laquelle la recherche est effectuée.

Note concernant Firefox 3

Le support du drapeau y a été ajouté dans Firefox 3. Le drapeau y échoue s'il n'y a pas de correspondance, à la position courante, pour la chaîne de caractère donnée.

Pour utiliser un drapeau avec une expression régulière, on utilisera la syntaxe suivante :

var re = /motif/drapeaux;

ou

var re = new RegExp("motif", "drapeaux");

Les drapeaux font partie intégrante d'une expression régulière, ils ne peuvent pas être ajoutés ou supprimés ensuite.

Ainsi, re = /\w+\s/g permet de créer une expression régulière pour trouver un ou plusieurs caractères suivis d'un espace a regular, la recherche est effectuée globalement, sur toute la chaîne de caractères.

var re = /\w+\s/g;
var str = "un deux trois quatre";
var monTableau = str.match(re);
console.log(monTableau);

Cela affichera ["un ", "deux ", "trois "]. On pourrait remplacer la ligne :

var re = /\w+\s/g;

avec la ligne :

var re = new RegExp("\\w+\\s", "g");

pour obtenir le même résultat.

Le drapeau m pourra être utilisé pour traiter une chaîne de caractères de plusieurs lignes comme plusieurs lignes distinctes. Si ce drapeau est utilisé, les caractères spéciaux ^ et $ correspondront au début ou à la fin de n'importe quelle ligne appartenant à la chaîne de caractères au lieu de correspondre simplement au début ou à la fin de la chaîne.

Exemples

Les exemples qui suivent utilisent les expressions régulières dans différents cas.

Changer l'ordre d'une saisie

L'exemple qui suit utilise les expressions régulières et string.split() et string.replace(). Le script nettoie la chaîne de caractères saisie qui contient des noms (prénom puis nom) séparés par des blancs, tabulations et points-virgules. Enfin il inverse les noms et prénoms puis trie la liste.

// La chaîne des noms contient plusieurs blancs et tabulations,
// il peut y avoir plusieurs espaces entre le nom et le prénom.
var noms = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";

var output = ["---------- Chaîne originale\n", noms + "\n"];

// Préparer deux expressions régulières pour stocker un tableau.
// et découper les chaînes dans ce tableau.

// motif: on peut avoir des blancs, un point virgule puis d'autres blancs
var motifs = /\s*;\s*/;

// Découper la chaîne de caractères en morceaux séparés par le précédent motif
// Stocker ces morceaux dans un tableau listeNoms
var listeNoms = noms.split(motif);

// nouveau motif : un ou plusieurs caractères, des blancs puis des caractères.
// On utilise des parenthèses pour garder en mémoire les groupes du motif.
// On utilisera ces groupes par la suite.
motif = /(\w+)\s+(\w+)/;

// Nouveau tableau pour enregistrer les noms traités.
var listeParNomFamille = [];

// Afficher le tableau des noms et remplir le nouveau tableau
// avec les noms et prénoms séparés par des virgules, le nom 
// de famille étant écrit en premier 
//
// La méthode replace supprime tout ce qui correspond au motif 
// et le remplace par le nom (mémorisé), une virgule, un espace
// et le prénom (mémorisé).
//
// Les variables $1 et $2 font références aux fragments gardés
// en mémoire lors de l'utilisation du motif.

output.push("---------- Après découpage avec l'expression régulière");

var i, len;
for (i = 0, len = listeNoms.length; i < len; i++){
  output.push(listeNoms[i]);
  listeParNomFamille[i] = listeNoms[i].replace(motif, "$2, $1");
}

// Afficher le nouveau tableau
output.push("---------- Noms et prénoms inversés");
for (i = 0, len = listeParNomFamille.length; i < len; i++){
  output.push(listeParNomFamille[i]);
}

// Trier par le nom de famille puis afficher le tableau trié
listeParNomFamille.sort();
output.push("---------- Triée");
for (i = 0, len = listeParNomFamille.length; i < len; i++){
  output.push(listeParNomFamille[i]);
}

output.push("---------- Fin");

console.log(output.join("\n"));

Utiliser les caractères spéciaux pour vérifier la saisie

Dans l'exemple suivant, on s'attend à ce que l'utilisateur saisissent un numéro de téléphone. Quand l'utilisateur appuie sur le bouton "Vérifier", le script vérifie la validité du numéro. Si le numéro est valide (il correspond à la séquence de caractères fournie par l'expression régulière), le script affiche un message remerciant l'utilisateur et confirmant le numéro. S'il est invalide, le script informe l'utilisateur et lui signifie que les informations saisies ne sont pas valides.

Dans les parenthèses sans mémoire (?: , l'expression régulière cherche trois chiffres /d{3} OU | une parenthèse ouvrante \( suivie par trois chiffres \d{3}, suivis par une parenthèse fermante \), (fin des parenthèses sans mémoire )), suivis par un tiret, une barre oblique ou un point en mémorisant ce caractère ([-\/\.]), suivi par trois chiffres \d{3}, suivis par un tiret ou une barre oblique ou un point selon la correspondance mémorisée auparavant \1, suivi par quatre chiffres \d{4}.

L'événement Change, provoqué quand l'utilisateur appuie sur Entrée, renseigne la valeur RegExp.input.

<!DOCTYPE html>
<html>  
  <head>  
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">  
    <meta http-equiv="Content-Script-Type" content="text/javascript">  
    <script type="text/javascript">  
      var re = /(?:\d{3}|\(\d{3}\))([-\/\.])\d{3}\1\d{4}/;  
      function testInfo(phoneInput){  
        var OK = re.exec(phoneInput.value);  
        if (!OK)  
          window.alert(RegExp.input + " n'est pas un numéro de téléphone valide!");  
        else
          window.alert("Merci, votre numéro est : " + OK[0]);  
      }  
    </script>  
  </head>  
  <body>  
    <p>Saisissez votre numéro de téléphone (avec indicatif) puis cliquez sur "Vérifier".
        <br>Le format attendu est ###-###-####.</p>
    <form action="#">  
      <input id="phone"><button onclick="testInfo(document.getElementById('phone'));">Vérifier</button>
    </form>  
  </body>  
</html>

Étiquettes et contributeurs liés au document

Contributeurs ayant participé à cette page : Goofy, SphinxKnight
Dernière mise à jour par : SphinxKnight,