Syntaxe des expressions régulières en JavaScript et collection

Un ensemble de règles décrivent une condition sous la forme compacte d'une expression régulière. Cela permet d'isoler une texte dans une page et éventuellement de le remplacer.
Une expression régulière est définie par un objet ou un littéral.

L'écriture litérale d'une expression à un format propre, elle est incluse entre deux barres inclinées:

var er = /xyz/

Tandis que l'objet est créé à partir d'une chaîne de caractères ordinaire, placée entre guillemets:

var er = new RegExp("xyz")

Lorsqu'on entre une expression régulière à partir d'un formulaire, on obtient une chaîne ordinaire, il convient alors d'utiliser l'objet pour assigner l'expression à une variable.

Construction d'une expression régulière, syntaxe et opérateurs

La construction dépend uniquement de la connaissance des opérateurs d'expression régulière et caractères spéciaux, ainsi que des modifieurs globaux.

Les opérateurs, intervalles et groupes

En regroupant des éléments dans une expression, on peut appliquer des opérateurs logiques. Ajoutant à cela les intervalles, il devient possible d'exprimer en peut de lettres un ensemble de règles.

Le point

Le point désigne tout caractère dans le texte à comparer. Sauf le code de fin de ligne.

Groupes

()

Les parenthèses désignent un groupe de rappel, trouve l'élément entre parenthèse et le mémorise pour le restituer dans le tableau résultat ou dans les variables de l'objet RegExp.
Le masque (.) désigne un caractère quelconque. Associé à l'opérateur +, donc (.)+ cela signifie un caractère quelconque au moins, donc un seul caractère ou une chaîne de caractères.

Par exemple (ari) permet de retrouver "ariane", ou "baril", et mais "carquois" n'est pas retenu. Puis ari est mémorisé.

(?:x)

Parenthèses non capturantes. On recherche l'élément x, mais il n'est pas mémorisé et n'apparaît pas dans le résultat pour la méthode qui retourne un tableau. Ni dans les variables internes.

[]

Les crochets désignent un groupe alternatif. On recherche l'un ou l'autre des éléments dans la liste.
Dans le cas ou l'on recherche [abc], alors "ariane", "baril", "corail" peuvent correspondre (si l'on teste la première lettre).

Intervalle

Le symbole tiret désigne entre deux lettres ou chiffres désigne un intervale.
Exemples:
a-z liste des lettres minuscules. N'importe quelle lettre dans la liste peut correspondre.
A-Z liste des majuscules.
0-9 liste des chiffres.

Opérateurs de parties

Ces symboles servent à désigner une partie spéficifique des textes à comparer avec l'expression régulière.

Spécifie que l'élément qui suit, caractère ou groupe, doit être placé au début du texte pour qu'il corresponde à la recherche. Si le masque est /^e/ le texte "enfin" est retenu et pas "terme".
Dans le cas d'un texte en plusieurs lignes, avec le modifieur "m" en option, cela s'applique au début de chaque ligne.

Spécifie que l'élément précédent, caractère ou groupe doit terminer la fin du texte. Si le masque est /e$/ le texte "enfin" n'est pas retenu, mais "ariane" le serait .
Dans le cas d'un texte en plusieurs lignes, avec le modifieur "m" en option, cela s'applique à la fin de chaque ligne.

L'élément précédant peut être présent ou non.
a? signifie qu'il peut y avoir une lettre a ou aucune. Cela permet de passer le caractère lorsqu'il est présent pour appliquer la suite de l'expression régulière sur la partie du texte qui vient après.

Opérateurs de quantité

Il doit y avoir ou moins un élément de la lettre ou du groupe précédant le symbole.

Exemples:
a+ il doit y avoir un a ou plusieurs.
[abc]+ il doit y avoir un a ou un b ou un c ou plusieurs de ces mêmes lettres (pas une combinaison).

Il peut y avoir un nombre indéterminé d'occurence du texte précédent, ou aucune.

{ n }

n représente un nombre entier quelconque. C'est le nombre d'occurences que l'on recherche.
Exemple:
a{2} On recherche une chaîne qui contient "aa".

{ x, y }

x et y représentent deux nombres entiers positifs. Il y aura au moins x occurences et au plus y occurences.
Par exemple { 2, 3 } On recherche deux ou trois occurences d'une chaîne.

Opérateurs logiques

x | y

La barre est l'opérateur OU inclusif.
Exemple: (abc | def)
On recherche la chaîne qui contient abc ou def (ou les deux).

[^]

Le symbole "^" quand il est entre crochets ne désigne pas le début d'un ensemble mais l'exclusion de cet ensemble.
Exemple:
[^xyz]
L'expression représente toutes les lettres sauf x, y ou z.

Opérateurs conditionnels

x(?=y)

Le texte correspond quand x est suivi par y.
Exemple:
moi(?=elle)
Quand moi est suivi directement par elle dans le texte, l'expression est satisfaite. Pour conserver les deux chaînes dans le tableau résultat, on écrira: moi(?=(elle))

Exemple:
(0-9)+(?=\.)(0-9)+
Représente un nombre décimal: suite de chiffres, point, et décimales. Cela peut s'écrire plus simplement: \d+\.\d+

x(?!y)

Le texte x correspond s'il n'est pas suivi par y.
Pour représenter un nombre entier on écrirait:
[0-9]+(?!\.) mais [0-9]+ serait plus simple.

Note importante

Dans une chaîne de caractères, le code "\" doit être doublé. Par exemple on écrira \\d pour représenter le symbole \d, un digit. Ce n'est pas le cas quand on entre l'expression régulière dans un formulaire, ni dans la forme litérale:

/\d+/

Les caractères spéciaux

Les caractères spéciaux sont introduits par le code d'échappement "\". Dans un littéral (ou un formulaire) mais dans une chaîne, le slash inversé est doublé.

x = /a\r/

x = new RegExp("a\\r")

Celui-ci associé à une lettre représente un code qui ne peut être affiché directement, mais il sert aussi, quand il est associé à un code opérateur, à désigner le caractère plutôt que l'opérateur d'expression régulière:

\n désigne la fin de ligne et non pas la lettre n.


\* désigne le caractère étoile et non pas l'opérateur d'expression régulière étoile.

\t  code de tabulation. \v pour une tabulation verticale.

\r  code de retour à la ligne.

\f  code de fin de page.

\s code de séparation quelconque, incluant:espace blanc, tabulation, retour à la ligne, fin de page.

\S tout caractère autre qu'un espace, c'est le contraire de \s.

\d   tout digit, autrement dit tout caractère numérique.  Equivaud à [0-9].

\D  tout caractère non numérique.  Equivaud à [^0-9].

\w tout caractère alphanumérique. Equivaud à [_A-Za-z0-9].

\W tout caractère autre qu'alphanumérique. C'est le contraire de \w et cela équivaud à  [^_A-Za-z0-9].

\nnnn où nnnn est un nombre entier positif.

\0  Représente le code 0 dans le fichier binaire (et non le chiffre 0 dans le texte).

\xhh  Où hh est un couple hexadécimal. Représente un code dans le binaire.

\uhhhh  Code hexadécimal sur 4 digits.

Les modifieurs

Ce sont des codes qui appliquent une règle générale à l'utilisation de l'expression régulière. Par exemple la lettre i signifie que l'on ne doit pas faire de différence entre majuscules et minuscules.

Les modifieurs sont les lettres i, g et m.

var er = /xyz/i

var er = new RegExp("xyz", "i")

On peut utiliser un ou plusieurs modifieurs à la fois. Par exemple:

var er = /xyz/igm

Majuscules

Le code i indique que l'on ne différencie par majuscules et minuscules dans le texte. Par exemple, si l'on applique l'expression régulière à la chaîne "untel", on aura le même résultat qu'avec la chaîne "Untel" ou "UNTEL".

Global

Le code g indique une recherche globale.

Multiple lignes

Le code m indique que l'on applique l'expression à plusieurs lignes. Les lignes sont des textes terminé par un code de fin de ligne. Dans le cas ou cette option est choisie, la comparaison est tentée pour chaque ligne.

Méthodes de RegExp et modifieur

On peut associer une méthode de l'objet RegExp à une chaîne litérale.

/xyz/i.exec("xxx")

La méthode n'est pas associée au code i mais à la chaîne /xyz/i toute entière.

Cela équivaud à:

er = /xyz/i 
er.exec("xxx");

Collection d'expressions régulières communément utilisées

Quelques exemples d'expressions régulières d'usage courant, pour reconnaître une chaîne de caractère ou pour la modifier.
Les expressions doivent être encloses entre deux barres inclinées ou des guillemets, dans le source. Elle peuvent être testées telles qu'elles dans le testeur d'expressions régulières.

Vérifier si on a un nombre entier

-?[0-9]+

Un nombre décimal

-?\d+\.\d+

Une chaîne de caractères alpha-numérique

Composée de lettre de l'alphabet, minuscules ou majuscules, ou chiffres uniquement.

^[a-zA-Z0-9]+$

Le code complet:

var re = new RegExp("^[a-zA-Z0-9]+$", "g");
if(!re.test(str)) return false;

Supprimer les guillemets

Cela peut être utile lorsqu'on parse le contenu d'un fichier HTML.

[\"\']([^\"\']*)[\"\']

var er = /[\"\']([^\"\']*)[\"\']/
var test="'un texte quelconque'";
document.write(test.length());
var arr = er.exec(test);
document.write(arr[1].length());

Comment valider une adresse email

([\w-\.]+@[\w\.]+\.{1}[\w]+)

var er = /([\w-\.]+@[\w\.]+\.{1}[\w]+)/;
if (er.test(email)) document.write("valide");

Comment valider une URL

(http://|ftp://)([\w-\.)(\.)([a-zA-Z]+)

Remplacer la fonction trim

str = str.replace(/^\s\s*/, '').replace(/\s\s*$/, '')

Outil en ligne

Un outil en ligne permet de tester les expressions régulières en JavaScript.
Des boutons correspondant aux opérateurs aident à définir une expression, qui s'applique à différents types de textes, préféfinis et modifiables par l'utilisateur.

Voir aussi

L'objet RegExpr dispose de méthodes pour effectuer des traitements globaux.