FAQ JavaScriptConsultez toutes les FAQ
Nombre d'auteurs : 43, nombre de questions : 175, dernière mise à jour : 6 décembre 2013
Sommaire→Les expressions régulières- Qu'est-ce qu'une expression régulière ?
- Quel est le jargon des expressions régulières ?
- Comment créer un objet regex ?
- Quels éléments trouve-t-on dans une expression régulière ?
- Quelles sont les options ?
- Quelles sont les méthodes de l'objet RegExp ?
- Quelles sont les méthodes de l'objet String ?
- Quelle est la différence entre exec et match ?
- Quelques exemples d'utilisation
Une expression régulière (ou expression rationnelle) est un élément existant dans la plupart des langages de programmation. En JavaScript, les expressions régulières sont implémentées au travers de l'objet natif RegExp.
Il s'agit d'une chaîne de caractères permettant la recherche et le remplacement de motifs. C'est une expression quasi mathématique composée d'une combinaison de codes représentants des schémas possibles de chaînes. Elle permet d'automatiser des traitements complexes sur les chaînes de caractères à des fins de recherche, d'extraction, de comparaison, de transcodage… La syntaxe d'une expression rationnelle est injustement réputée difficile. Sa notation suit des règles simples et strictes mais permet de formuler dans une expression compacte un motif complexe.
Lien : Cours sur les expressions régulières en JavaScript
Lien : Définition dans le disctionnaire developpez.com
| Terme | Explication |
|---|---|
| regex/regexp | Une façon courte de dire expression régulière |
| modèle, motif ou pattern | La chaîne correspondant à la recherche voulue |
| options ou modificateurs | Des propriétés que l'on peut ajouter à une regex pour modifier son fonctionnement |
| expression | Les parties de la chaîne testée correspondant au modèle |
| capture | Résultat des méthodes exec() ou match() |
Il existe deux façons de créer des expressions régulières.
1) La création à l'aide du constructeur :
var regex = new RexExp(modèle, options);
2) La création littérale :
var regex = /modèle/options;
Une expression régulière est composée de différents types d'éléments.
La recherche se fera en parcourant, dans le sens de lecture de la chaîne (de droite à gauche) si la chaîne à tester correspond à la chaîne attendue.
On trouvera donc souvent des caractères littéraux, par exemple, dans l'expression /abc/, on recherchera la présence de la sous-chaîne "abc" dans
la chaîne à tester.
Mais nous aurons souvent besoin (et c'est ce qui constitue l'intérêt des expressions régulières) de chercher des types de caractères un nombre de fois
prédéfini.
D'autre part, nous aurons aussi souvent besoin de retrouver des sous-parties du masque de recherche dans le résultat renvoyé.
Les crochets :
Les crochets correspondent à des classes (ou ensembles) de caractères. On place à l'intérieur tous les caractères que l'on attend à l'emplacement donné de la
chaîne.
| Expression | Explication | Exemple |
|---|---|---|
| [abc] | N'importe quel caractère dans les crochets | [abcdef] |
| [^abc] | N'importe quel caractère sauf ceux des crochets | [^abcdef] |
| [a-z] | N'importe quel caractère dans l'intervalle | [d-y], [4-7], [C-M] |
| [^a-z] | N'importe quel caractère sauf ceux dans l'intervalle | [^d-y], [^4-7], [^C-M] |
Notez que le caractère tiret ("-") permet d'indiquer une plage de caractères (par exemple,
/[a-z]/
correspond à toutes les lettres de "a" à "z"). Si vous devez rechercher le caractère tiret, vous devrez l'échapper en le faisant précéder d'un antislash ("\").
Une autre possibilité est de placer le tiret en début ou en fin de classe, dans ce cas, il perd sa signification (par exemple
/[-abc]/
pour rechercher les caractères tiret, a, b ou c.
Les parenthèses :
Les parenthèses peuvent avoir plusieurs fonctions. Elles permettent d'offrir un
choix à JavaScript. Par exemple /po(mme|ire)/, accepterait
pomme
commepoire. On
peut aussi utiliser l'expression
?!
pour exprimer la négation :
Win(?!32)
qui veut
dire
Win
sauf 32. Lorsqu'utilisées avec la méthode match(), les parenthèses disent
à JavaScript ce qu'il faut aller chercher. Par exemple :
"36 pommes".match(/([0-9]+)\spommes/);
// retourne un Array ["36 pommes", "36"]Les parenthèses peuvent aussi être utilisées avec des quantifieurs pour éviter la répétition :
/(pommes){3}/.test('pommespommespommes');Les quantifieurs :
| Expression | Explication | Exemple |
|---|---|---|
| expression{n} | L'expression 'n' fois | /[a-z]{3}/ |
| expression{n,} | L'expression au moins 'n' fois | /[a-z]{5,}/ |
| expression{n,m} | L'expression de 'n' à 'm' fois | /[a-z]{10,20}/ |
| expression+ | Équivalent de {1,} | /[a-z]+/ |
| expression* | Équivalent de {0,} | /[a-z]*/ |
| expression? | Équivalent de {0,1} | /[a-z]?/ |
Les expressions de positionnement :
| Expression | Explication | Exemple |
|---|---|---|
| /^ | Marque le début de la chaîne |
/^pommes/.test('pommes bleues'); // true
/^pommes/.test('des pommes'); // false |
| $/ | Marque la fin de la chaîne |
/pommes$/.test('des pommes'); // true
/pommes$/.test('pommes bleues'); // false |
Les caractères spéciaux (ou classes prédéfinies) :
| Caractère | Explication |
|---|---|
| . | Tous les caractères sauf \n |
| \w | [a-zA-Z0-9_] |
| \W | [^a-zA-Z0-9_] |
| \d | [0-9] |
| \D | [^0-9] |
| \s | Tout caractère d'espacement (incluant, par exemple, les tabulations) |
| \S | Tout sauf un caractère d'espacement |
| \b | Limite de mot |
| \B | Pas une limite de mot |
| \0 | NUL |
| \n | Saut de ligne |
| \r | Retour à la ligne |
| \f | Saut de page |
| \t | Tabulation |
| \v | Tabulation verticale |
| \xdd | Caractère hexadécimal |
| \uxxxx | Caractère Unicode hexadécimal |
| Option | Explication |
|---|---|
| g | Cherche le modèle sur toute la chaîne |
| i | Ignore la casse |
| m | Fait que ^ devient le début d'une ligne et que $ devient la fin d'une ligne |
| gi | Cherche le modèle sur toute la chaîne en ignorant la casse |
| Méthode | Explication | Exemple |
|---|---|---|
| compile(modèle, options); | Redéfinit la regex | regex.compile("[a-z0-9]+", "i"); |
| exec(chaîne); | Exécute l'expression | /[a-z]+([0-9]+)/.exec("abc13"); // retourne ["abc13", "13"] |
| test(chaîne); | Vérifie l'expression | /[a-z]+/.test("abcd13"); // retourne false |
Lorsque JavaScript scanne une expression régulière, un pointeur est déplacé en interne pour rechercher les correspondances. Si l'on doit faire plusieurs recherches, ce pointeur n'est pas réinitialisé, la méthode compile() permet de le faire.
| Méthode | Explication | Exemple |
|---|---|---|
| match(regex) | Cherche la regex dans la chaîne | "25 pommes".match(/[0-9]+\s([a-z]+)/); // retourne ["25 pommes", "pommes"] |
| replace(regex, nouvelle_chaîne) | Replace la regex par la chaîne | "25 pommes".replace(/[0-9]+/, '1'); // retourne "1 pommes" |
| search(regex) | Cherche la position de la regex dans la chaîne | "25 pommes".search(/[a-z]+/); // retourne 3 |
| split(regex) | Sépare la chaîne à chaque occurrence de la regex | "25 pommes 25 poires".split(/\s/g); //retourne ["25","pommes","25","poires"] |
Lorsque l'option g est appliquée à une regex et qu'on utilise la méthode match(), on retourne chaque occurrence vérifiée par l'expression :
"25 pommes, 25 poires".match(/[0-9]+\s[a-z]+/g)
// retourne ["25 pommes", "25 poires"]
Si on avait utilisé
exec()
avec la même regex, la méthode n'aurait
retourné que la première occurrence : "25 pommes".
La méthode exec() :
/po[a-z]+/.exec("J'aime les pommes et les poires.");
// retourne "pommes" car il arrête la lecture à l'espaceLa méthode test() :
/pommes/.test("J'aime les pommes est les poires.");
// retourne "true" car pommes est dans la chaîneLa méthode match() :
"J'aime les pommes et les poires.".match(/po[a-z]+/g);
// retourne "pommes","poires" car la regex à l'option gLa méthode replace() :
"J'aime les pommes et les poires.".replace(/po[a-z]+/, 'fraises');
// retourne "J'aime les fraises et les poires."La méthode search() :
"J'aime les pommes et les poires.".search(/po[a-z]+/);
// retourne 11, la position où commence l'occurence retrouvéeLa méthode split() :
"J'aime les pommes et le poires.".split(/po[a-z]+/);
// retourne ["J'aime les ", " et le ", "."]