Einen regulären Ausdruck testen

Dashboard
Dokumentation
API

testet einen regulären Ausdruck (regex) gegen einen Text und zeigt Übereinstimmungen und erfasste Gruppen an

À quoi sert un testeur d'expression régulière ?

Un regex tester permet de vérifier qu'un motif d'expression régulière (regex) correspond bien au texte attendu, sans avoir à lancer le code applicatif. On colle le motif, on colle le texte d'entrée, on coche les options (flags), et l'outil affiche immédiatement la liste des correspondances trouvées ainsi que les groupes capturés. C'est l'équivalent en ligne de preg_match_all() en PHP, de String.matchAll() en JavaScript ou de re.findall() en Python.

Les regex sont à la fois puissantes et piégeuses. Une virgule, une parenthèse mal placée, un quantificateur glouton qui aspire trop de caractères : et la chaîne extraite n'est plus celle que l'on attendait. Le testeur évite l'aller-retour avec un éditeur, un terminal et un fichier de test : on itère le motif jusqu'à voir le bon résultat.

Comment écrire le motif ?

Saisissez la regex sans les délimiteurs. Pas de /.../, pas de #...#. Par exemple, pour capturer les adresses email d'un texte, entrez seulement [\w.+-]+@[\w-]+\.[\w.-]+. Les options (flags) sont contrôlées par les cases à cocher.

L'option u (Unicode) est cochée par défaut. Elle est presque toujours souhaitée : sans elle, \w ne reconnaît pas les accents, et certains motifs renvoient une erreur PCRE silencieuse sur les chaînes UTF-8.

Les options PCRE

i (case-insensitive) : [a-z] reconnaît aussi les majuscules.
m (multiline) : ^ et $ matchent les débuts et fins de chaque ligne, plus seulement le début et la fin de la chaîne globale.
s (dotall) : . reconnaît aussi les sauts de ligne. Utile pour des motifs qui doivent traverser des paragraphes.
u (unicode) : interprète le motif et le sujet en UTF-8. Indispensable dès que le texte contient des caractères non-ASCII (accents, emoji, idéogrammes).

Exemples de regex courantes

Adresse email : [\w.+-]+@[\w-]+\.[\w.-]+ (forme simplifiée, suffisante pour la plupart des cas pratiques ; la RFC 5322 stricte est très complexe).
URL HTTP/HTTPS : https?://[\w.-]+(?:/[\w./?%&=-]*)?
Numéro de téléphone français : (?:\+33|0)\s?[1-9](?:[\s.-]?\d{2}){4}
Code postal français : \b\d{5}\b
Date ISO (YYYY-MM-DD) : \b\d{4}-\d{2}-\d{2}\b
Adresse IPv4 : \b(?:\d{1,3}\.){3}\d{1,3}\b
Mot entier : \bfoo\b (les word boundaries évitent de matcher football).
Hashtag : #\w+
Numéro de version sémantique : \d+\.\d+\.\d+(?:-[\w.-]+)?
Identifiant Twitter / X : @\w{1,15}

Groupes capturés

Une regex peut contenir des groupes entre parenthèses, qui isolent une portion du match pour la réutiliser. Par exemple, le motif (\w+)@(\w+\.\w+) appliqué à alice@example.com capture deux groupes : alice et example.com. L'outil affiche ces groupes dans une colonne dédiée, à côté de chaque match. Les groupes nommés ((?P<name>...)) sont également listés, indexés par leur nom.

Pour grouper sans capturer (utile pour appliquer un quantificateur sans polluer la liste des groupes), on utilise (?:...).

Protection contre le ReDoS

Le moteur PCRE de PHP peut entrer en catastrophic backtracking sur certains motifs pathologiques : un motif comme (a+)+$ appliqué à une longue chaîne de a non terminée peut bloquer le serveur pendant plusieurs secondes. Pour éviter ce déni de service par expression régulière (ReDoS), l'outil applique deux limites :

un set_time_limit(2) côté worker (le traitement abandonne au bout de 2 secondes) ;
une réduction de pcre.backtrack_limit à 100 000, ce qui fait échouer rapidement les motifs qui explorent trop de combinaisons.

En cas de motif trop coûteux, l'outil affiche le message d'erreur PCRE (preg_last_error_msg()), typiquement Backtrack limit was exhausted. Reformulez votre motif en utilisant des quantificateurs possessifs (a++) ou des groupes atomiques ((?>...)) pour éviter le backtracking.

Questions fréquentes

Pourquoi ma regex ne match pas alors qu'elle marche en JavaScript ?

Le moteur de cet outil est PCRE (PHP), proche de Perl. La syntaxe est très similaire à JavaScript mais quelques fonctionnalités diffèrent : les lookbehinds de longueur variable, certains alias Unicode, ou la gestion par défaut de la sensibilité à la casse. Si vous comptez exécuter le motif côté navigateur, testez aussi dans un environnement JS.

Pourquoi mon \w ne capture pas les accents ?

Sans le flag u, \w reconnaît seulement [A-Za-z0-9_]. Avec u (Unicode), il reconnaît toutes les lettres au sens UCD, y compris les caractères accentués. Pour aller plus loin, utilisez les classes Unicode : \p{L} (lettre), \p{N} (chiffre), \p{P} (ponctuation).

L'outil conserve-t-il mon texte ?

Non. Le motif et le sujet sont traités en RAM par le worker PHP, sans persistance. Aucune donnée soumise n'est journalisée.

Que faire si je reçois un message "Backtrack limit was exhausted" ?

Votre motif fait trop de retours en arrière. Cherchez les nested quantifiers du type (a+)+ ou (\w+)*, qui sont des cas typiques de ReDoS. Remplacez-les par une forme non ambiguë : par exemple \w+ au lieu de (\w+)*.

Puis-je tester un motif multiligne ?

Oui. Cochez l'option m pour que ^ et $ reconnaissent les débuts et fins de chaque ligne. Cochez en plus s si vous voulez que . traverse les sauts de ligne.

Beispielanfrage

curl -X POST https://cdrn.fr/api/v1/tools/regex-tester/execute \
  -H "Content-Type: application/json" \
  -d '{"pattern":"...","subject":"...","flag_i":false,"flag_m":false,"flag_s":false,"flag_u":true}'

Eingabeschema

Feld	Typ	Erforderlich	Standard
`pattern`	string	✓	–
`subject`	text	✓	–
`flag_i`	boolean	✓	`false`
`flag_m`	boolean	✓	`false`
`flag_s`	boolean	✓	`false`
`flag_u`	boolean	✓	`true`

Endpunkte

GET https://cdrn.fr/api/v1/tools - listet alle verfügbaren Tools auf
GET https://cdrn.fr/api/v1/tools/regex-tester - liefert das Schema dieses Tools
POST https://cdrn.fr/api/v1/tools/regex-tester/execute - führt dieses Tool mit einem JSON-Payload aus