Soutenez-nous

FAQ JavaScriptConsultez toutes les FAQ

Nombre d'auteurs : 43, nombre de questions : 176, dernière mise à jour : 19 décembre 2013 

 
OuvrirSommaireLes expressions régulières

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.

Créé le 12 octobre 2011  par SBSTP, Bovino

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()
Créé le 12 octobre 2011  par SBSTP, Bovino

Il existe deux façons de créer des expressions régulières.
1) La création à l'aide du constructeur :

 
Sélectionnez
var regex = new RexExp(modèle, options);


2) La création littérale :

 
Sélectionnez
var regex = /modèle/options;
Créé le 12 octobre 2011  par SBSTP

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 :

 
Sélectionnez
"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 :

 
Sélectionnez
/(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
Créé le 12 octobre 2011  par SBSTP
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
Créé le 12 octobre 2011  par SBSTP
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.

Créé le 12 octobre 2011  par SBSTP
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"]
Créé le 12 octobre 2011  par SBSTP

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 :

 
Sélectionnez
"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".

Créé le 12 octobre 2011  par SBSTP

La méthode exec() :

 
Sélectionnez
/po[a-z]+/.exec("J'aime les pommes et les poires.");
// retourne "pommes" car il arrête la lecture à l'espace

La méthode test() :

 
Sélectionnez
/pommes/.test("J'aime les pommes est les poires.");
// retourne "true" car pommes est dans la chaîne

La méthode match() :

 
Sélectionnez
"J'aime les pommes et les poires.".match(/po[a-z]+/g);
// retourne "pommes","poires" car la regex à l'option g

La méthode replace() :

 
Sélectionnez
"J'aime les pommes et les poires.".replace(/po[a-z]+/, 'fraises');
// retourne "J'aime les fraises et les poires."

La méthode search() :

 
Sélectionnez
"J'aime les pommes et les poires.".search(/po[a-z]+/);
// retourne 11, la position  commence l'occurence retrouvée

La méthode split() :

 
Sélectionnez
"J'aime les pommes et le poires.".split(/po[a-z]+/);
// retourne ["J'aime les ", " et le ", "."]
Créé le 12 octobre 2011  par SBSTP
  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2004 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.