Testeur Regex

Testeur d'expressions régulières gratuit. Validez et déboguez vos regex avec surlignage temps réel, groupes de capture et gestion des drapeaux. Idéal pour les développeurs et spécialistes SEO qui manipulent du texte.

Vous avez des commentaires ? Signalez des bugs, suggérez des fonctionnalités ou partagez vos idées — nous lisons tout

Testeur Regex - Tester et déboguer vos expressions régulières

Outil avancé pour écrire, tester et comprendre vos expressions régulières. Affichage temps réel des correspondances, surlignage du texte, groupes capturés et prise en charge de tous les drapeaux JavaScript. Parfait pour les développeurs, analystes de données et rédacteurs techniques.

Qu'est-ce qu'une expression régulière et à quoi sert-elle?

Une expression régulière (regex ou regexp) est une séquence de caractères qui définit un motif de recherche, utilisée pour la correspondance de chaînes, la validation, l'extraction et la substitution. Le concept a été formalisé par Stephen Kleene dans les années 1950 et rendu pratique par la commande grep de Ken Thompson en 1968. Les moteurs modernes alimentent la validation d'entrées (e-mails, numéros de téléphone, codes postaux), l'analyse de logs, la recherche et le remplacement dans les éditeurs, le routage d'URL dans les frameworks web et l'analyse lexicale dans les compilateurs. Chaque grand langage embarque un moteur regex: RegExp en JavaScript, re en Python, Pattern en Java, Regex en .NET, et PCRE en PHP. Bien que la syntaxe varie entre saveurs (POSIX BRE, ERE, PCRE, RE2, ECMAScript), les blocs de base — classes de caractères, quantificateurs, ancres, groupes et alternance — sont universels.

Quelle est la différence entre quantificateurs gourmands, paresseux et possessifs?

Par défaut, les quantificateurs comme *, +, ? et {n,m} sont gourmands: ils correspondent au maximum tout en laissant le motif global réussir. Le motif <.+> sur <b>gras</b> capture toute la chaîne, pas seulement <b>, car + consomme jusqu'au dernier >. Les quantificateurs paresseux (non gourmands) ajoutent ? — <.+?> capture seulement <b>, prenant la plus petite sous-chaîne qui fonctionne. Les possessifs ajoutent + (++, *+, ?+) et ne rebroussent jamais après correspondance, améliorant les performances et empêchant le retour arrière catastrophique, mais peuvent échouer là où le gourmand réussirait. PCRE, Java et Ruby supportent les possessifs; JavaScript et Python non (utilisez les groupes atomiques (?>...) si disponibles).

Que sont les ancres, lookahead et lookbehind?

Les ancres correspondent à des positions, pas à des caractères. ^ marque le début (ou de ligne en mode multiline), $ la fin, \b une limite de mot, et \A / \Z le début / fin absolu. Lookahead (?=...) et négatif (?!...) affirment ce qui suit sans consommer: q(?=u) capture q uniquement s'il est suivi de u. Lookbehind (?<=...) et (?<!...) affirment ce qui précède: (?<=\$)\d+ capture un nombre précédé du signe dollar. JavaScript a gagné le lookbehind en ES2018; les anciens navigateurs et RE2 (utilisé par Go et Cloudflare) ne le supportent pas. Les lookarounds sont de largeur nulle: ils affectent la correspondance mais n'ajoutent aucun caractère au résultat.

Comment diffèrent les groupes de capture, non-capture et nommés?

Les parenthèses (abc) créent un groupe de capture qui regroupe pour les quantificateurs et sauvegarde la sous-chaîne pour les rétroréférences (\1) ou l'extraction. Les groupes non-capturants (?:abc) regroupent sans sauvegarder, sont plus rapides et n'encombrent pas le tableau de résultats — utilisez-les chaque fois que vous n'avez besoin que de grouper. Les groupes nommés (?<nom>abc) (PCRE/Python/.NET/ES2018+) sauvegardent sous un nom lisible accessible via match.groups.nom, rendant les motifs auto-documentés. Un regex comme (?<annee>\d{4})-(?<mois>\d{2})-(?<jour>\d{2}) décompose une date ISO en champs étiquetés. Les rétroréférences \k<nom> ou \1 permettent de re-correspondre au même texte — utile pour trouver des mots dupliqués comme \b(\w+)\s+\1\b.

Testeur Regex — Testeur d'expressions régulières gratuit. Validez et déboguez vos regex avec surlignage temps réel, groupes de capture e — **Testeur Regex**

Quels sont les flags courants (g, i, m, s, u, y) et que font-ils?

Les flags modifient le comportement global du regex. g (global) retourne toutes les correspondances, requis pour replaceAll en JavaScript. i (insensible à la casse) fait que [A-Z] correspond aussi à a-z. m (multiline) change ^ et $ pour des limites de ligne au lieu de chaîne. s (dotall, ES2018+) permet à . de correspondre aux retours à la ligne. u (unicode) active le mode Unicode complet avec paires de substitution et échappements \p{Script=Latin}. y (sticky) ancre la correspondance à lastIndex, utile pour les tokeniseurs. Python utilise les constantes re.IGNORECASE, re.MULTILINE, re.DOTALL au lieu de lettres. Combinez les flags: /motif/gim ou (?gim) inline.

Pourquoi certains regex figent-ils le navigateur? (retour arrière catastrophique)

Le retour arrière catastrophique survient quand un regex tente exponentiellement plein de façons de correspondre avant d'abandonner. L'exemple classique est (a+)+b sur aaaaaaaaaaaaaaaaaa (sans b): le moteur essaie chaque partition des a entre les + interne et externe, soit 2^n tentatives. Les attaques ReDoS (Déni de Service par Regex) exploitent cela — une seule entrée malveillante peut figer un serveur pendant des minutes. Le guide ReDoS de l'OWASP recommande: éviter les quantificateurs imbriqués ((a+)+, (a*)*), éviter les alternances qui se chevauchent ((a|a)+), préférer les groupes atomiques (?>a+)+ ou les quantificateurs possessifs a++, et utiliser des moteurs en temps linéaire comme RE2 (Go, Cloudflare) ou le crate regex de Rust pour les entrées non fiables. Testez les motifs avec le débogueur de regex101 ou le linter regexploit.

Quelles sont les différences entre POSIX BRE, ERE, PCRE et RE2?

POSIX BRE (Basique, utilisé par sed et grep) requiert des barres obliques inverses devant les métacaractères: $groupe$, \{2,3\}, \+ est littéral. POSIX ERE (Étendu, utilisé par egrep, awk) traite ces caractères comme spéciaux par défaut — plus proche de la syntaxe moderne. PCRE (Compatible Perl, utilisé par PHP, NGINX et beaucoup d'outils) est le standard moderne de facto: il supporte lookaround, groupes nommés, rétroréférences, récursion et conditionnels. RE2 (Google, utilisé par Go, Cloudflare, Sourcegraph) omet délibérément les rétroréférences et le lookaround pour garantir un temps linéaire, éliminant ReDoS. Le regex ECMAScript (JavaScript) est proche de PCRE mais manque certaines fonctions (récursion, conditionnels) et ajoute le flag y. Consultez toujours la doc du moteur cible — un motif PCRE qui fonctionne peut échouer dans RE2 ou grep.

Comment échapper les caractères spéciaux et gérer Unicode correctement?

Douze métacaractères nécessitent un échappement par barre oblique inverse: . ^ $ * + ? ( ) [ ] { } | \. Pour correspondre à un point littéral, utilisez \.. À l'intérieur des classes [...], seuls ] \ ^ - ont besoin d'échappement, et ^ uniquement en position 1. Pour les motifs dynamiques construits à partir d'entrées utilisateur, utilisez une fonction d'échappement de la bibliothèque (proposition RegExp.escape, re.escape en Python, preg_quote en PHP) — ne concaténez jamais l'entrée brute. Pour Unicode, activez le flag u et utilisez les échappements de propriété: \p{L} (toute lettre), \p{N} (chiffre), \p{Script=Han} (caractères chinois), \p{Emoji}. Le \w obsolète ne correspond qu'à l'ASCII par défaut — pour les noms internationaux utilisez [\p{L}\p{N}_]. Les paires de substitution (emojis, CJK rares) ne fonctionnent correctement qu'avec le flag u en JavaScript.