Les expressions régulières
Partie 3 sur 4
6Dans les langages et les outils
Presque tous les langages offrent les mêmes quatre opérations : tester (le texte correspond-il ?), trouver (où et quoi ?), remplacer et découper. Seuls les noms changent. Les exemples ci-dessous utilisent des textes fictifs et un domaine réservé aux exemples (example.org).
6.1JavaScript
En JavaScript (voir JavaScript dans le navigateur), un motif se crée soit par la notation entre barres obliques, const re = /\d+/g, soit avec le constructeur new RegExp("\\d+", "g") (utile quand le motif est construit pendant l’exécution ; on remarque le double antislash). Voici l’usage actuel de l’objet RegExp, avec ses propriétés et méthodes :
const re = /(?<jour>\d{2})\/(?<mois>\d{2})\/(?<an>\d{4})/;
re.test("rdv le 04/11/2026"); // true : le texte contient une date
const m = "rdv le 04/11/2026".match(re);
m.groups.an; // "2026"
"04/11/2026".replace(re, "$<an>-$<mois>-$<jour>"); // "2026-11-04"
"a1b22c333".match(/\d+/g); // ["1", "22", "333"]
"un deux".split(/\s+/); // ["un", "deux"]
Un piège classique : un motif avec le drapeau g mémorise sa position (la propriété lastIndex) entre deux appels. Écrire const re = /a/g; puis appeler deux fois re.test("a") donne true puis false, car la seconde recherche commence après le premier « a ». Cet état caché, qui surprend tout le monde une fois, est la raison pour laquelle on évite g avec test().
L’objet RegExp possède de nombreuses propriétés. Une partie d’entre elles décrit le motif lui-même et reste d’usage courant : global, ignoreCase et multiline (booléens qui indiquent si les drapeaux g, i et m sont actifs), source (le texte du motif) et lastIndex (la position où commencera la prochaine recherche). L’autre partie décrit le dernier résultat trouvé, de façon globale : RegExp.$1, input (le texte examiné, aussi noté $_), lastMatch ($&), lastParen ($+), leftContext et rightContext (le texte à gauche et à droite de la correspondance, notés avec une apostrophe inversée et une apostrophe). Ces propriétés globales existent encore dans les navigateurs pour des raisons de compatibilité, mais elles ne font pas partie de la norme, partagent un état caché entre toutes les recherches du programme, et l’on s’en passe : on lit le résultat renvoyé par match(), exec() ou matchAll(), qui est un objet propre à chaque recherche. Les méthodes de l’objet sont exec() (qui renvoie un tableau des occurrences trouvées), test() (qui renvoie vrai ou faux) et compile() (qui redéfinit le motif) ; cette dernière est obsolète, on crée simplement un nouvel objet. Les méthodes de texte search(), match() et replace(), qui servent à lire les groupes capturés, sont toujours là, complétées par matchAll() et replaceAll().
6.2PHP
Les fonctions PHP ereg(), eregi(), ereg_replace(), eregi_replace(), split() et sql_regcase() existaient autrefois. Toutes ont été supprimées : elles étaient déclarées obsolètes depuis PHP 5.3 (2009) et ont disparu de PHP 7.0 (2015). Un programme ancien qui les utilise ne fonctionne plus sur un serveur actuel (voir le langage PHP). Les anciennes fonctions renvoyaient vrai ou faux et rangeaient les occurrences trouvées dans un tableau passé en option ; ereg_replace() réutilisait les groupes sous la forme \\1. Leur remplaçante est la famille des fonctions preg_*, fondée sur PCRE. Le motif y est placé entre deux délimiteurs (le plus souvent une barre oblique ou un tilde), suivis des drapeaux :
<?php
// Tester, puis extraire avec des groupes nommés
if (preg_match('/(?<jour>\d{2})\/(?<mois>\d{2})\/(?<an>\d{4})/', 'le 04/11/2026', $m)) {
echo $m['an'] . '-' . $m['mois'] . '-' . $m['jour']; // 2026-11-04
}
// Remplacer en réutilisant les groupes (délimiteur ~ pour éviter d'échapper les /)
echo preg_replace('~(\d{2})/(\d{2})/(\d{4})~', '$3-$2-$1', '04/11/2026');
// Découper en mots, même s'il y a plusieurs espaces (remplace l'ancienne fonction split())
$mots = preg_split('/\s+/', trim('Ceci est une phrase'));
// Rendre un texte quelconque inoffensif dans un motif
$sur = preg_quote('1+1=2?', '/'); // 1\+1\=2\?
Les autres fonctions utiles sont preg_match_all() (toutes les occurrences), preg_replace_callback() (remplacer en appelant une fonction pour fabriquer chaque remplacement, utile pour calculer) et preg_last_error() (savoir si la recherche a échoué à cause d’une limite interne, ce qui arrive en cas d’emballement de la partie 8). L’exemple classique qui isole le titre d’une page web avec eregi("<title>(.*)</title>") montre aussi une limite de principe : analyser du code HTML avec des expressions régulières est fragile (partie 9).
6.3Python
Python (voir le langage Python) fournit le module re. On y écrit les motifs dans des chaînes brutes (préfixe r) :
import re
re.search(r"(?P<jour>\d{2})/(?P<mois>\d{2})/(?P<an>\d{4})", "le 04/11/2026").groupdict()
# {'jour': '04', 'mois': '11', 'an': '2026'}
re.sub(r"(\d{2})/(\d{2})/(\d{4})", r"\3-\2-\1", "04/11/2026") # '2026-11-04'
re.findall(r"\b(\w+) \1\b", "le le chat dort dort") # ['le', 'dort']
re.fullmatch(r"[A-Za-z]+", "café") # None : le « é » n'est pas dans A-Za-z
Une différence à connaître : re.match() n’essaie que le début du texte, re.search() cherche partout, et re.fullmatch() exige que tout le texte corresponde, ce qui évite d’oublier les ancres. Depuis Python 3.11, les quantificateurs « possessifs » et les groupes « atomiques » sont aussi disponibles (voir partie 8).
6.4En ligne de commande : grep et sed
Dans un terminal (voir le shell), grep -E affiche les lignes d’un fichier qui correspondent à une expression étendue, et sed -E remplace du texte. Avec un fichier f.txt contenant « ligne 12 », « autre » et « ligne 7 » :
grep -E '^ligne [0-9]+$' f.txt # ligne 12 / ligne 7 sed -E 's/([0-9]+)/<\1>/' f.txt # ligne <12> / autre / ligne <7>
Sans l’option -E, grep et sed lisent la syntaxe « basique », où les signes +, ?, |, (, ), {, } sont ordinaires tant qu’on ne les fait pas précéder d’un antislash : c’est l’inverse du principe habituel, et une source de confusion permanente. L’option -P de certaines versions de grep active la syntaxe PCRE.
6.5Les éditeurs de texte et les bases de données
La plupart des éditeurs de code proposent une recherche avec expression régulière (souvent une case à cocher « .* »), très pratique pour modifier mille lignes d’un coup. Les systèmes de bases de données (voir le langage SQL) disposent d’opérateurs de même nature, dont la syntaxe varie : REGEXP ou REGEXP_LIKE dans MySQL, ~ dans PostgreSQL. MySQL écrivait autrefois la frontière de mot sous la forme [[:<:]] ; les versions récentes de MySQL ont adopté une bibliothèque Unicode et utilisent le \b habituel.
Pour s’exercer
Exercice 5 : extraire d’un journal
Voici une ligne : 192.0.2.17 - - [04/Nov/2026:10:12:01 +0100] "GET /index.html HTTP/1.1" 200 512. Écrivez un motif à deux groupes qui extrait l’adresse et le chemin demandé. Quelle limite a-t-il ?
Voir la réponse
^(\d{1,3}(?:\.\d{1,3}){3}) .*"GET (\S+). Le groupe 1 reconnaît quatre nombres de un à trois chiffres séparés par des points ; le groupe non capturant évite de numéroter les sous-parties. Après l’espace, .* traverse la date, puis "GET annonce la méthode, et (\S+) prend les caractères non blancs, soit le chemin. Résultat : « 192.0.2.17 » et « /index.html ». Limites : \d{1,3} accepte « 999 » ; le motif ne traite que la méthode GET ; il suppose un format de ligne précis. Pour un usage de sécurité, on adapte le motif à chaque format de journal et on teste des lignes anormales.
7Glouton ou paresseux ?
C’est le sujet où les débutants se trompent le plus souvent. Appliquons le motif <b>.*</b> au texte suivant :
<b>un</b> et <b>deux</b>
On pourrait espérer obtenir « <b>un</b> » puis « <b>deux</b> ». On obtient en fait une seule correspondance : tout le texte. La raison : les quantificateurs *, +, ? et {n,m} sont gloutons. Ils prennent le plus de texte possible tant que le reste du motif peut encore correspondre. Ici, .* avale tout jusqu’à la fin du texte, puis recule juste assez pour pouvoir lire le dernier « </b> ».
La solution est le quantificateur paresseux (on dit aussi « non gourmand », en anglais lazy ou non-greedy), obtenu en ajoutant un point d’interrogation : *?, +?, ??, {n,m}?. Il prend le moins de texte possible. Le motif <b>.*?</b> donne bien les deux correspondances séparées. Une autre approche, souvent préférable parce qu’elle est plus rapide et plus explicite, consiste à interdire ce qui ne doit pas être traversé : <b>[^<]*</b> (« tout sauf un crochet pointu ouvrant »).
Il existe une troisième famille, les quantificateurs possessifs (*+, ++) et les groupes atomiques ((?>…)), qui prennent le plus de texte possible et ne reculent jamais. Ils servent à empêcher le retour arrière et donc à accélérer ou sécuriser un motif (partie 8). Python 3.11, PCRE et Java connaissent les deux ; .NET connaît les groupes atomiques ; JavaScript ni l’un ni l’autre.
L’exemple de la page de titre <title>(.*)</title>, fonctionne tant que la page ne contient qu’une balise de titre sur une ligne. S’il y en a plusieurs (ce qui arrive avec les images vectorielles incluses dans une page), le motif glouton avalera tout ce qu’il y a entre la première ouverture et la dernière fermeture.
8Sous le capot : comment le moteur travaille
Comprendre le fonctionnement du moteur (le programme qui applique le motif au texte) explique à la fois les comportements surprenants et les failles de sécurité. Deux grandes familles existent.
8.1Le moteur à retour arrière
La famille de Perl, de PCRE, de JavaScript, de Python, de Java et de .NET utilise la méthode du retour arrière (en anglais backtracking). Le moteur lit le motif de gauche à droite et essaie de faire correspondre chaque élément au texte. Quand un choix existe (une alternative, un quantificateur), il en retient un et mémorise les autres. S’il échoue plus loin, il revient en arrière jusqu’au dernier choix mémorisé et essaie le suivant, comme quelqu’un qui, dans un labyrinthe, revient au dernier carrefour quand il se heurte à un mur.
Cette méthode est simple et puissante : elle permet les références arrière, les assertions et les groupes. Son défaut est que, dans le pire des cas, le nombre de chemins à essayer augmente de façon exponentielle avec la longueur du texte : chaque caractère de plus peut doubler le travail.
8.2Un exemple qui s’emballe
Considérons le motif (a+)+$ : « un ou plusieurs groupes, chacun composé d’un ou plusieurs “a”, puis la fin du texte ». Appliquons-le au texte « aaaa…ab » (n fois la lettre « a », puis un « b »). Comme le « b » final empêche toujours la correspondance, le moteur va essayer toutes les manières de découper la série de « a » en groupes avant de renoncer. Pour n lettres « a », il y a exactement 2 puissance (n−1) découpages possibles (on choisit, entre deux « a » consécutifs, de couper ou non). La figure 3 compare cette croissance avec celle d’un motif sûr.
Sur un ordinateur ordinaire, des essais avec le moteur de Python donnent un temps de moins d’un dixième de seconde pour 20 lettres, un quart de seconde pour 22, près d’une seconde pour 24 et plus de trois secondes pour 26 : le temps double environ à chaque lettre ajoutée. Avec 30 lettres, on attendrait plusieurs dizaines de secondes ; avec 40, plus d’une demi-journée. Le motif équivalent a+$, qui exprime la même idée sans répétition imbriquée, traite 5 000 lettres en une fraction de milliseconde.
8.3Le moteur à temps garanti
L’autre famille travaille sans retour arrière. Elle transforme le motif en automate, c’est-à-dire en une petite machine à états : le texte est lu une seule fois, caractère par caractère, et la machine suit simultanément tous les chemins possibles. Le temps de calcul est alors proportionnel à la longueur du texte, quoi qu’il arrive. C’est la méthode des outils Unix historiques et d’un travail que Ken Thompson avait publié en 1968. Elle a été remise en avant en 2007 par l’ingénieur Russ Cox, puis mise en œuvre dans la bibliothèque RE2 de Google, que le langage Go utilise (son module regexp suit la syntaxe de RE2), ainsi que la bibliothèque regex du langage Rust (voir Go et Rust).
Ces moteurs ne proposent pas les références arrière ni les assertions arrière, qui sont par nature incompatibles avec une lecture unique. C’est un choix : on perd quelques fonctions, on gagne la certitude qu’aucun texte ne pourra bloquer le programme. Cette garantie est précieuse partout où le texte à analyser vient d’inconnus.
8.4Se prémunir en pratique
- Éviter les répétitions imbriquées : des motifs comme
(a+)+,(a*)*,(a|aa)+ou([a-z]+\s?)*sont des signaux d’alarme, surtout quand deux façons différentes de lire le texte sont possibles. - Rendre le motif précis :
[^,]*plutôt que.*quand on sait que le champ ne contient pas de virgule. - Limiter la taille du texte analysé avant de lui appliquer un motif, et configurer un délai maximal quand le langage ou la bibliothèque le permet.
- Choisir un moteur à temps garanti pour les textes venant de l’extérieur, quand c’est possible.
- Utiliser possessifs et groupes atomiques quand le dialecte les offre.
Pour s’exercer
Exercice 6 : un motif qui s’emballe
Un site valide un nom avec ^([A-Za-z]+\s?)*$. Un visiteur envoie vingt-quatre lettres suivies d’un point d’exclamation, et le serveur reste figé plus d’une seconde (davantage avec une lettre de plus). Expliquez, puis proposez deux corrections.
Voir la réponse
Le motif répète un groupe (*) qui contient lui-même une répétition ([A-Za-z]+) suivie d’un espace facultatif. Pour une suite de lettres, il existe un très grand nombre de façons de la découper en blocs, et le point d’exclamation final, que le motif ne peut jamais accepter, force le moteur à les essayer toutes avant d’échouer : le travail double à chaque lettre ajoutée. Correction 1 : supprimer l’ambiguïté, ^[A-Za-z]+(?:\s[A-Za-z]+)*$ (les mots sont obligatoirement séparés par un espace, il n’y a plus qu’une manière de lire le texte). Correction 2 : limiter la longueur du texte (par exemple 60 caractères) avant d’appliquer le motif. En complément, on peut utiliser un moteur à temps garanti.