Testeur Regex gratuit — Déboguez vos motifs en ligne

Qu'est-ce qu'un testeur regex ?

// The pattern you build in this tester drops straight into JavaScript.
// Example: extract every ISO date from a string with named groups.

const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = 'shipped 2026-05-21, scheduled 2026-06-30';

for (const m of text.matchAll(pattern)) {
  console.log(m.groups.year, m.groups.month, m.groups.day);
  // → 2026 05 21
  // → 2026 06 30
}

// Same regex, used in a replace with $<name> templates:
text.replace(pattern, '$<day>/$<month>/$<year>');
// → 'shipped 21/05/2026, scheduled 30/06/2026'

// With the /d flag, every match carries [start, end] indices
// per capture group — the Matches panel uses this to paint offsets.
const p2 = /(?<year>\d{4})-(?<month>\d{2})/gd;
const m = [...text.matchAll(p2)][0];
m.indices.groups.year; // [8, 12]

Fonctionnalités clés

Exemples détaillés

[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}

/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g

(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})

/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g

(\w+) (\w+)

Remplacement : $2, $1   →   Jack Doe → Doe, Jack

[ \t]+$

/[ \t]+$/gm

(a+)+b

Texte de test : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac

[,;|]\s*

alpha, beta; gamma | delta → ["alpha", "beta", "gamma", "delta"]

Comment utiliser le testeur regex

1. 1

   Tapez votre motif entre les barres obliques

   Déposez n'importe quelle expression régulière ECMA-262 dans le champ /…/. Les motifs invalides se surlignent en rouge avec un message de l'analyseur ; les motifs valides passent à la correspondance en direct.

2. 2

   Activez les drapeaux dont vous avez besoin

   g (global), i (insensible à la casse), m (multiligne), s (dotAll), u (unicode), y (collant), d (indices). Chaque puce s'allume quand elle est activée ; la lecture à droite du motif affiche le littéral canonique.

3. 3

   Collez votre texte de test

   Les correspondances se surlignent en couleurs alternées à mesure que vous tapez. Le panneau Correspondances & groupes de capture, à droite, liste chaque correspondance avec ses décalages [début, fin) et la valeur de chaque groupe de capture (les groupes nommés étiquetés $<name>).

4. 4

   Changez d'onglet pour Remplacer, Découper ou Expliquer

   Remplacer prévisualise un modèle de substitution à côté de l'entrée. Découper coupe à chaque frontière de correspondance. Expliquer décompose le motif jeton par jeton avec une description en français clair par élément.

5. 5

   Copiez le littéral ou partagez un permalien

   Copier /motif/drapeaux dépose le littéral regex canonique dans votre presse-papiers pour une utilisation directe dans JavaScript / TypeScript / Node. Copier le lien encode l'état complet dans un hash d'URL (pas de téléversement) pour qu'un collègue puisse le reproduire localement.

Erreurs regex courantes

Motif : /\d+/  →  '1 22 333' donne seulement ['1']

Motif : /\d+/g  →  '1 22 333' donne ['1', '22', '333']

Motif : /<.+>/  →  capture '<a> and <b>'

Motif : /<[^>]+>/  →  capture '<a>' et '<b>' séparément

Motif : /(a+)+b/  sur 'aaaaaaaaaaaaaaaaaaaaac'  →  timeout

Motif : /a+b/  sur la même entrée  →  « aucune correspondance » instantané

Motif : /^Error/  sur un log multiligne sans /m  →  capture seulement la première ligne

Motif : /^Error/m  sur la même entrée  →  capture chaque ligne commençant par Error

text.replace(/(\w+)/, m => '$1')  →  donne le littéral '$1'

text.replace(/(\w+)/, (_, g1) => g1.toUpperCase())  →  utilise la capture

Motif : /\w+/  capture 'hello' mais pas 'héllo' ni '你好'

Motif : /\p{Letter}+/u  capture les trois

Motif : (?i)foo  →  SyntaxError: invalid group

Motif : foo avec drapeau /i activé  →  même effet

Qui utilise cet outil

Valider les entrées de formulaire avant la livraison

Confirmez que votre regex e-mail / téléphone / code postal / nom d'utilisateur capture ce que vous attendez — et rejette ce que vous ne voulez pas — sur les cas limites (noms unicode, plus-aliasing, formats internationaux) avant que la validation n'atteigne la production et ne fasse rebondir de vrais utilisateurs.

Extraire des données de logs et de configurations

Construisez un motif qui extrait des ID de requête, des codes de statut, des latences ou des lignes de trace de pile d'une tranche de log arbitraire. Les groupes nommés rendent les données auto-documentées ; le panneau Correspondances affiche les décalages pour que vous puissiez ensuite transmettre le même regex à rg --replace ou grep -oE.

Rechercher/remplacer dans une base de code

Esquissez un motif de refactorisation (ex. (\w+)\.apply\(null,\s*\[(.*?)\]\) → $1($2)) ici, prévisualisez la substitution sur des extraits représentatifs, puis collez le regex validé dans le rechercher/remplacer à l'échelle du projet de votre éditeur, en confiance.

Vérifier la cohérence d'un motif trouvé en ligne

Collé un regex depuis StackOverflow ou un blog ? Déposez-le dans l'onglet Expliquer — chaque jeton est annoté en français clair. Attrape les problèmes subtils (.+? là où vous vouliez .+, ancres ^/$ manquantes, quantificateurs gourmands par accident) avant que le regex n'atterrisse dans votre code.

Enseigner le regex à un coéquipier

Ouvrez l'onglet Expliquer sur un motif fonctionnel et parcourez-le jeton par jeton. Le codage couleur (échappement / quantificateur / classe de caractères / groupe / ancre / alternance) permet à l'apprenant de voir la forme structurelle du regex, pas seulement les caractères.

Porter un motif entre langages

Vous avez un regex Python ou PCRE à utiliser en JavaScript ? Collez-le ici. S'il s'analyse, l'explicateur vous montre la sémantique équivalente en JS ; s'il ne s'analyse pas, l'erreur de l'analyseur nomme le construit fautif (groupes atomiques, quantificateurs possessifs, (?i) en ligne) pour que vous sachiez exactement quoi réécrire.

Déboguer un regex de production lent

Si un regex serveur est suspecté de retour arrière catastrophique, collez-le dans ce testeur avec un échantillon de l'entrée. La garde wall-clock de 250 ms se déclenche sur les cas pathologiques, vous donnant un diagnostic immédiat avant de sortir l'outillage de profilage — et l'explicateur pointe la cause racine du quantificateur imbriqué.

Notes sur le moteur et l'algorithme

Moteur RegExp ECMA-262 (natif du navigateur)

Utilise new RegExp(pattern, flags) et le moteur livré avec V8 / JavaScriptCore / SpiderMonkey — la même sémantique regex que vous obtenez en JavaScript partout. Les motifs qui se valident ici s'exécutent sans modification dans Node.js, Deno, Bun et chaque navigateur moderne.

Itération de correspondance via String.matchAll

L'itération globale utilise text.matchAll(regex) plutôt qu'une boucle manuelle sur lastIndex, donc chaque correspondance porte ses groupes de capture, ses groupes nommés et (avec /d) ses indices [début, fin]. Les correspondances de largeur nulle sont gérées avec l'avance standard de +1 sur lastIndex pour éviter les boucles infinies.

Timeout wall-clock pour la protection ReDoS

Un budget de 250 millisecondes enveloppe chaque appel de match, replace et split. Le moteur peut toujours faire du retour arrière en interne sur une seule tentative de correspondance, mais l'itération externe coopère avec le budget — les motifs pathologiques avortent avec timedOut: true et l'interface affiche un avertissement au lieu de bloquer l'onglet.

Réimplémentation du modèle de remplacement

L'onglet Remplacer analyse $1..$N, $&, $, $', $$ et $<name> manuellement au lieu de déléguer à String.replace`, pour que l'aperçu se comporte de manière identique entre les moteurs (anciens Safari, anciens Node) où les modèles à groupes nommés ont des cas limites. La sortie est exactement ce que produisent les moteurs JavaScript actuels.

Tokeniseur de motif pour l'explicateur

L'onglet Expliquer exécute un tokeniseur écrit à la main qui classe chaque fragment de motif (échappement / métacaractère / quantificateur / classe de caractères / ouverture-groupe / fermeture-groupe / ancre / alternance). Les constructions inconnues retombent sur literal avec une note générique, l'explicateur ne laisse donc jamais tomber silencieusement de contenu.

Permaliens via hash d'URL (jamais transmis)

L'état de partage est encodé dans le fragment location.hash (#p=…&f=…&t=…&tab=…). Les navigateurs ne transmettent jamais le fragment dans les requêtes HTTP, donc les serveurs go-tools.org ne reçoivent aucune donnée lorsqu'un permalien est ouvert. L'hydratation se passe entièrement sur l'appareil du destinataire.

Bonnes pratiques regex

Ancrez les motifs quand vous le voulez vraiment

^motif$ capture une chaîne exacte ; motif capture n'importe où. Le mauvais choix est le bug le plus courant en validation de formulaire : un ^ manquant laisse passer un préfixe attacker.com/ devant un contrôle de domaine ; un $ manquant laisse passer des déchets en fin. Utilisez l'onglet Correspondance contre des échantillons délibérément cassés pour confirmer ce qui est rejeté.

Préférez les groupes non capturants pour la structure pure

(?:foo|bar)+ et (foo|bar)+ sont fonctionnellement identiques, mais le premier n'alloue pas de groupe de capture. Optez pour (?:…) chaque fois que le groupe n'existe que pour un quantificateur ou une alternance — garde vos $1..$N numérotés stables et économise un infime travail du moteur.

Utilisez le drapeau /u pour tout ce qui dépasse l'ASCII

Sans /u, le point et \w traitent les caractères à paires de substitution (emojis, points de code hors BMP) comme deux unités UTF-16. Avec /u, ils sont chacun un point de code — ce que vos utilisateurs percevront. /u active aussi \p{Letter} et d'autres échappements de propriétés. Par défaut, mettez /u sur les nouveaux motifs, sauf raison spécifique de ne pas le faire.

Nommez vos groupes de capture

(?<year>\d{4})-(?<month>\d{2}) est auto-documenté. Six mois plus tard quand vous relisez le regex, m.groups.year est manifestement l'année — m[1] non. Les modèles de remplacement avec $<name> survivent aussi au réordonnancement des groupes : les modèles positionnels cassent dès que quelqu'un ajoute un autre groupe.

Testez les cas d'échec, pas seulement de succès

Un testeur regex sert aux échecs. Confirmez ce que votre motif capture, puis mutez délibérément le texte de test pour voir ce qu'il ne capture pas — espaces en tête, espaces en fin, parties manquantes, parties en trop, mauvaise casse, écritures mélangées. Les motifs qui passent une entrée valide mais acceptent les déchets sont les bugs que la production expose en premier.

Questions fréquentes