Outil de Test Regex
Tester et déboguer des expressions régulières avec mise en évidence de correspondance en temps réel et génération de code
Qu'est-ce qu'une expression régulière ?
L’outil Regex aide à écrire, tester et comprendre des expressions régulières. Une expression régulière décrit des motifs de texte pour recherche, extraction, validation et remplacement, comme chaînes proches d’un e-mail, champs de logs, URLs, identifiants, dates ou formats répétés. Un testeur rend visibles correspondances, groupes capturés, flags et cas limites avant d’utiliser le motif dans du code, une pipeline de données ou un formulaire. Regex est puissant mais facile à surestimer: un motif peut capturer trop ou trop peu, devenir lent sur de grosses entrées ou mal gérer Unicode et règles locales. Pour parsers complexes, HTML ou validation critique, une bibliothèque dédiée est souvent plus sûre.
Mode d'emploi
Comment l'utiliser
- Saisissez votre expression régulière dans la zone de saisie de gauche
- Sélectionnez les drapeaux nécessaires (par ex. g pour global, i pour insensible à la casse)
- Saisissez le texte de test à droite
- Consultez les correspondances surlignées et leurs détails
Conseils sur les expressions régulières
- Testez vos motifs avec des exemples correspondants et non correspondants pour repérer plus facilement les expressions trop larges
- Méfiez-vous des quantificateurs imbriqués sur les textes longs : certains motifs peuvent devenir lents à cause d'un retour arrière excessif
Cas d’utilisation
Principe technique
Le testeur est piloté par le moteur RegExp ECMAScript défini dans la spécification du langage. Les regex ECMAScript sont une implémentation NFA à retour arrière : le moteur essaie chaque alternative de gauche à droite et revient en arrière lorsqu'un quantificateur échoue, ce qui rend les assertions arrière et les références arrière possibles mais aussi ce qui produit un retour arrière catastrophique sur les entrées adverses. Les six drapeaux reconnus sont g (global), i (insensible à la casse), m (multiligne, ancres par ligne), s (dotAll, '.' correspond au changement de ligne), u (mode Unicode) et y (sticky, ancré à lastIndex). La sémantique de correspondance change radicalement selon les drapeaux. Avec /u, le moteur traite le motif comme une séquence de points de code Unicode plutôt que d'unités de code UTF-16, de sorte que les paires de substitution correspondent à un seul caractère et que les classes de propriétés Unicode comme \p{L} (toute lettre), \p{Sc} (symbole monétaire) et \p{Script=Han} deviennent disponibles. Les groupes de capture nommés (?<nom>...) et les assertions arrière (?<=...) font partie d'ES2018 et sont disponibles dans Chromium 64+, Firefox 78+ et Safari 16.4+, mais les fonctionnalités propres à PCRE comme les groupes atomiques (?>...) et les quantificateurs possessifs (a++) ne sont toujours pas dans la spécification. Le plus grand risque en production est le ReDoS — un motif comme (a+)+b sur l'entrée 'aaaaaaaaaaaaaaaa!' explore un nombre exponentiel de chemins car deux quantificateurs imbriqués peuvent découper la même séquence de caractères de nombreuses façons. Les mesures d'atténuation sont bien connues : éviter les quantificateurs imbriqués sur la même classe de caractères, ancrer avec ^ et $ lorsque c'est possible, préférer les groupes atomiques lorsque le moteur les supporte, ou passer à un moteur en temps linéaire comme RE2 de Go (qui échange les références arrière et les assertions arrière contre une correspondance O(n) garantie). Pour les entrées non fiables destinées à la validation côté serveur, RE2 ou un analyseur écrit à la main est presque toujours le choix le plus sûr.
- Moteur : RegExp ECMAScript est un NFA à retour arrière, pas un DFA ; c'est ce qui permet les assertions arrière et les références arrière mais aussi le retour arrière catastrophique.
- Drapeaux : g (global), i (insensible à la casse), m (^/$ par ligne), s (dotAll, '.' correspond à \n), u (mode Unicode, sensible aux substitutions), y (sticky, ancré à lastIndex).
- Mode Unicode : /u active la correspondance par point de code ainsi que \p{L} (lettre), \p{Sc} (monnaie), \p{Script=Han} ; sans /u, [a-zA-Z]+ manque tous les mots non latins.
- Disponibilité de la syntaxe moderne : captures nommées (?<n>...) et assertions arrière (?<=...) disponibles dans Chromium 64+, Firefox 78+, Safari 16.4+ ; les groupes atomiques (?>...) et les quantificateurs possessifs (a++) ne font pas partie d'ECMAScript.
- ReDoS : les quantificateurs imbriqués sur la même classe comme (a+)+b explosent exponentiellement ; resserrez avec des ancres, des groupes atomiques, ou migrez vers RE2 / re2-wasm pour les entrées non fiables.
- Plancher de complexité : les motifs littéraux ancrés sur un alphabet fixe s'exécutent en O(n) ; les références arrière et les assertions arrière non bornées portent le pire cas à l'exponentiel, faites donc un benchmark sur des entrées adverses avant la mise en production.
Exemples
Correspondance d'une adresse e-mail
Motif : ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$
Flags : gi
Entrée : contact: alice@example.com, bob_2024@mail.co.uk, invalid@.com
Correspondances : alice@example.com, bob_2024@mail.co.uk (2 résultats)Extraire des adresses IPv4 d'un log
Motif : \b(?:\d{1,3}\.){3}\d{1,3}\b
Flags : g
Entrée : 2026-06-15 ERROR client 192.168.1.42 connect failed (peer 10.0.0.1)
Correspondances : 192.168.1.42, 10.0.0.1Capturer les parties d'une date avec des groupes nommés
Motif : (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
Flags : g
Entrée : Sprint window: 2026-09-01 to 2026-09-15
Groupes : {year:'2026', month:'09', day:'01'}, {year:'2026', month:'09', day:'15'}Quantificateur glouton vs paresseux
Entrée : <b>hello</b> <i>world</i>
.* (glouton) -> correspond à toute la ligne : <b>hello</b> <i>world</i>
.*? (paresseux) -> première correspondance seulement : <b>hello</b>
Le paresseux est généralement ce que l'on souhaite pour extraire entre des balises.Classe de lettres compatible Unicode
Motif : \p{L}+
Flags : gu
Entrée : Hello, 北京! Café Москва
Correspondances : Hello, 北京, Café, Россия
Sans le flag u et \p{L}, [a-zA-Z]+ raterait tout mot non latin.FAQ
Quelle saveur de regex le testeur utilise-t-il ?
Le moteur regex de JavaScript (ECMAScript). Il est similaire à PCRE pour les fonctionnalités courantes mais diffère dans les cas limites : pas de quantificateurs possessifs, pas de récursivité, le support du lookbehind nécessite un navigateur récent, les groupes nommés utilisent (?<name>...). Pour Python (re/regex), Java, .NET ou PCRE, le comportement sur le même motif peut différer — testez aussi dans l'environnement réel.
Quels drapeaux sont pris en charge ?
g (global, trouve toutes les correspondances), i (insensible à la casse), m (multiligne, ^ et $ correspondent aux limites de ligne), s (dotall, . correspond au saut de ligne), u (Unicode), y (sticky), d (hasIndices). Choisissez-les avec la rangée de bascules ; la page indique ce que chacun modifie dans votre texte de test.
Pourquoi mon motif trouve-t-il moins de résultats que prévu ?
Sans le drapeau g, regex.exec ne renvoie qu'une seule correspondance. Sans m, ^ et $ ne correspondent qu'au tout début/fin de l'entrée. Sans u, les caractères en paire de substitution (emojis) correspondent comme deux moitiés. La plupart des problèmes « pourquoi ça ne marche pas » sont dus à des drapeaux manquants.
Comment faire correspondre les emojis et les caractères CJK ?
Utilisez le drapeau u pour activer la gestion correcte d'Unicode. Utilisez les classes de caractères \p{...} (\p{Letter}, \p{Script=Han}, \p{Emoji}) pour faire correspondre par propriété Unicode. Sans u, [a-zA-Z] ne correspondra pas aux caractères accentués — étendez à [a-zA-ZÀ-ÿ] ou utilisez \p{L}.
Puis-je générer du code à partir d'un motif ?
La plupart des versions exportent le motif en syntaxe JavaScript, Python, PHP, Ruby, Go ou Java avec l'échappement approprié. Attention : le même motif peut se comporter différemment selon les moteurs (gourmandise par défaut, comportement des classes de caractères, support des assertions). Testez toujours dans la langue cible.
Quelle est la différence entre les quantificateurs gourmands et paresseux ?
Les gourmands (* + ?) correspondent à autant de caractères que possible, puis reviennent en arrière si nécessaire. Les paresseux (*? +? ??) correspondent à aussi peu que possible. Pour « extraire tout ce qui est entre A et B », .* gourmand dépassera s'il existe plusieurs B ; .*? paresseux s'arrête au premier B. Choisissez paresseux par défaut pour l'extraction de contenu interne.
Mon regex ou mon texte de test sont-ils téléversés ?
Non. La correspondance s'exécute dans votre navigateur en utilisant le moteur regex natif de JavaScript. Les motifs et les entrées ne sont pas transmis.