Testeur d'Expressions Régulières

Testez, déboguez et visualisez vos regex en temps réel avec correspondances surlignées et groupes de capture.

/ /
Entrez une regex pour voir les correspondances...
Correspondances : 0
Groupes : 0
Temps : 0ms

Aide-mémoire Regex

Caractères

. N'importe quel caractère
\d Chiffre [0-9]
\D Non-chiffre
\w Mot [a-zA-Z0-9_]
\W Non-mot
\s Espace blanc
\S Non-espace

Quantificateurs

* 0 ou plus
+ 1 ou plus
? 0 ou 1
{n} Exactement n
{n,} n ou plus
{n,m} Entre n et m
*? Non-glouton

Ancres & Groupes

^ Début de ligne
$ Fin de ligne
\b Limite de mot
(abc) Groupe de capture
(?:abc) Groupe non-capturant
(?=abc) Lookahead positif
(?!abc) Lookahead négatif

Drapeaux

g Global (toutes les correspondances)
i Insensible à la casse
m Multi-ligne (^ et $ par ligne)
s Le point matche \n
u Support Unicode complet

Guide des expressions régulières

Pourquoi maîtriser les regex ?

Les expressions régulières sont un outil universel en programmation. Que vous validiez des formulaires, parsiez des logs, fassiez du search-and-replace dans votre IDE, ou construisiez des routes URL — les regex sont partout. Investir quelques heures pour les maîtriser vous fera gagner des centaines d'heures sur le long terme.

Construire une regex pas à pas

Prenons l'exemple de la validation d'un numéro de téléphone français :

  • 0[1-9] — commence par 0 suivi d'un chiffre de 1 à 9
  • [\s.-]? — séparateur optionnel (espace, point ou tiret)
  • \d{2} — deux chiffres
  • Répétez 4 fois les deux dernières parties : ([\s.-]?\d{2}){4}
  • Résultat : 0[1-9]([\s.-]?\d{2}){4}

Pièges courants

Le backtracking catastrophique

Des patterns comme (a+)+b peuvent causer un temps exponentiel sur certaines entrées. Utilisez des quantificateurs possessifs ou des groupes atomiques quand c'est possible.

Oublier d'échapper les métacaractères

Le point . matche tout caractère. Pour un point littéral, utilisez \.. Même chose pour * + ? ( ) [ ] { } | ^ $ \.

Glouton vs non-glouton

.* est glouton : il capture le maximum possible. .*? est non-glouton : il capture le minimum. Pour matcher une balise HTML, utilisez <.+?> plutôt que <.+>.

Validation trop permissive ou restrictive

Un pattern d'email trop simple acceptera des adresses invalides. Un trop strict rejettera des adresses valides. En production, préférez une bibliothèque de validation dédiée.

Regex dans différents langages

  • JavaScript : /pattern/flags ou new RegExp('pattern', 'flags'). Méthodes : .test(), .match(), .replace(), .matchAll()
  • Python : module re. re.search(), re.findall(), re.sub(). Support des lookbehinds de longueur variable avec le module regex
  • PHP : fonctions preg_match(), preg_match_all(), preg_replace(). Utilise le moteur PCRE2 très puissant
  • Java : classes Pattern et Matcher. Le flag Pattern.UNICODE_CHARACTER_CLASS active le support Unicode pour \d, \w, etc.

Questions fréquentes

Quelle est la différence entre match et test ?

En JavaScript, regex.test(string) retourne un booléen (true/false) — c'est le plus rapide pour vérifier si un pattern est présent. string.match(regex) retourne un tableau des correspondances ou null. string.matchAll(regex) retourne un itérateur avec tous les détails (groupes, index).

Comment valider un email avec une regex ?

Le pattern [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,} couvre la majorité des cas. Cependant, la RFC 5322 qui définit les adresses email est extrêmement complexe. En production, il est préférable d'utiliser une bibliothèque de validation dédiée et de confirmer l'adresse par un email de vérification.

Comment utiliser les groupes de capture dans un remplacement ?

Les parenthèses () créent des groupes de capture numérotés. Dans le texte de remplacement, $1 référence le premier groupe, $2 le deuxième, etc. Par exemple, avec le pattern (\w+)@(\w+) et le remplacement utilisateur=$1, domaine=$2, « marc@mivkit » devient « utilisateur=marc, domaine=mivkit ».

Comment éviter le backtracking catastrophique ?

Le backtracking catastrophique survient avec des quantificateurs imbriqués comme (a+)+ ou (a|b)* suivis d'un pattern qui échoue. Pour l'éviter : utilisez des quantificateurs possessifs (a++), des groupes atomiques ((?>...)), ou reformulez le pattern. En JavaScript, évitez les regex sur des entrées utilisateur non contrôlées, ou utilisez un timeout.

Les regex sont-elles les mêmes dans tous les langages ?

La syntaxe de base est commune (PCRE), mais il y a des différences. JavaScript ne supporte pas les lookbehinds de longueur variable (ajoutés partiellement dans ES2018), Python n'a pas de quantificateurs possessifs natifs, et Java requiert des doubles backslashes dans les strings. Notre testeur utilise le moteur JavaScript, qui est le plus universel pour le développement web.