Skip to content

Testeur Regex gratuit — Déboguez vos motifs en ligne

Testez vos expressions régulières en ligne, gratuit. Correspondances en direct, groupes de capture, aperçu de remplacement, découpe et explication du motif. Regex JavaScript, 100 % confidentialité — sans inscription.

Sans pistage Fonctionne dans le navigateur Gratuit
Tous les tests s'exécutent localement dans votre navigateur. Votre motif et votre texte ne quittent jamais cet appareil.
Drapeaux
    Correspondances surlignées
    Correspondances & groupes de capture
    Examiné pour la fidélité ECMA-262, la justesse des groupes de capture (avec et sans le drapeau /d), la parité du modèle de remplacement avec String.prototype.replace, la résistance ReDoS via budget wall-clock, et l'accessibilité (rôles ARIA, annonces de correspondances pour lecteur d'écran, gestion RTL/LTR). — Équipe Outillage de texte Go Tools · 21 mai 2026

    Qu'est-ce qu'un testeur regex ?

    Un testeur regex (testeur d'expressions régulières) est un outil qui vous permet d'écrire un motif regex, de coller un morceau de texte de test et de voir exactement ce que le motif capture — avec les groupes de capture, l'aperçu de remplacement et la décomposition des drapeaux — sans recompiler de code ni exécuter de script. Pour les développeurs, cela réduit la boucle de quelques minutes à quelques millisecondes : ajustez le motif, regardez les surlignages bouger, livrez le regex en confiance.

    Une expression régulière est un langage compact pour décrire des motifs de texte. `\d+` capture un ou plusieurs chiffres. `[A-Za-z_]\w*` capture un identifiant typique. `(?\d{4})-(?\d{2})-(?\d{2})` capture une date ISO et nomme chaque partie. Les expressions régulières sont l'épine dorsale du rechercher-remplacer dans chaque éditeur de code, de la validation dans chaque formulaire, de l'analyse de logs dans chaque pile d'observabilité, et de `grep`, `sed` et `awk` — les outils Unix sur lesquels tourne la moitié d'Internet. Elles sont aussi notoirement difficiles à écrire correctement : un quantificateur décalé d'un cran ou un échappement manquant peut capturer la mauvaise sous-chaîne, manquer entièrement une correspondance ou — pire — déclencher un retour arrière catastrophique qui prend un cœur de CPU en otage. Un bon testeur regex attrape chacun de ces modes de défaillance avant qu'il n'atteigne la production.

    Ce testeur exécute le moteur RegExp ECMA-262 natif livré dans chaque navigateur moderne — le même moteur que vous appelez depuis JavaScript, TypeScript, Node.js, Deno ou Bun. Cela signifie : groupes de capture (numérotés et nommés avec `(?...)`), assertions d'anticipation et de rétro-anticipation (`(?=...)`, `(?!...)`, `(?<=...)`, `(?

    Ce que le testeur expose au-delà des correspondances brutes : le panneau Correspondances & groupes de capture liste chaque correspondance avec ses décalages [début, fin) et la valeur de chaque groupe de capture — la même information que vous obtiendriez de `String.prototype.matchAll` avec le drapeau /d, mais disposée pour un balayage visuel. L'onglet Remplacer affiche un aperçu de substitution en direct prenant en charge l'alphabet complet de modèles $1 / $& / $` / $' / $$ / $ — exactement ce que String.replace de JavaScript accepte. L'onglet Découper applique String.split avec le regex et affiche chaque partie. L'onglet Expliquer tokenise le motif et annote chaque morceau en français clair, utile pour la revue de code, l'enseignement et le portage entre dialectes.

    Pour la confidentialité : chaque opération est locale. Votre motif et votre texte de test ne quittent jamais la page — ils ne sont pas journalisés, pas envoyés à un service d'analyse, pas stockés sur disque. Seules vos préférences d'interface (onglet actif + drapeaux que vous activez habituellement) persistent dans localStorage. Cela rend cet outil sûr pour les échantillons de logs caviardés, les motifs propriétaires, la configuration interne et les motifs contenant des indices sur le schéma de vos données. Comparé aux testeurs adossés à un serveur comme regex101, l'histoire de la confidentialité et de la latence est strictement meilleure ; le compromis est la prise en charge d'une seule saveur (JavaScript uniquement).

    Si vous êtes nouveau en regex, le menu déroulant Motifs courants livre des points de départ éprouvés au combat : adresse e-mail, URL, IPv4, UUID, couleur hex, date ISO, numéro de téléphone US, et un motif de suppression des espaces de fin. Chargez-en un, observez les correspondances sur le texte d'exemple fourni, puis mutez le motif un caractère à la fois pour sentir comment le moteur réagit. Associez cela à l'outil Diff de texte quand vous voulez comparer l'avant/après d'un nettoyage regex, à Formateur JSON quand votre entrée ou sortie attendue est en JSON, ou à Encodeur URL quand les chaînes que vous capturez sont encodées en URL.

    // 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

    Surlignage des correspondances en direct

    Chaque correspondance dans votre texte de test s'illumine dès que votre motif s'analyse. Les couleurs alternées rendent les correspondances adjacentes faciles à compter visuellement, et le badge de comptage au-dessus du résultat vous donne le total exact — pas de bouton Exécuter, pas de délai de debounce supérieur à 200 ms.

    Panneau latéral des groupes de capture

    Le panneau Correspondances & groupes de capture, à droite, liste chaque correspondance sous forme de carte avec ses décalages [début, fin), le texte complet de la correspondance et chaque groupe de capture positionnel + nommé à l'intérieur. Les groupes nommés s'étiquettent eux-mêmes $ pour que vous lisiez les données comme vous les consommerez dans le code.

    Aperçu de remplacement en direct avec $1 / $& / $

    Passez à l'onglet Remplacer pour voir votre substitution appliquée en temps réel. L'alphabet complet de remplacement ECMAScript fonctionne : $1..$N pour positionnel, $ pour nommé, $& pour toute la correspondance, $` et $' pour préfixe/suffixe, $$ pour un dollar littéral. Panneaux d'entrée et de sortie côte à côte avec copie en un clic.

    Découpe avec frontières regex

    L'onglet Découper appelle String.prototype.split avec votre regex et affiche chaque partie sous forme de liste numérotée. Les parties vides sont rendues avec un glyphe ⏎ pour que vous voyiez comment le moteur a géré les délimiteurs adjacents — utile pour déboguer le nettoyage d'entrée de type CSV.

    Explicateur de motif (jeton par jeton)

    L'onglet Expliquer tokenise votre motif en puces colorées par classe (échappement / quantificateur / classe de caractères / groupe / ancre / alternance) et annote chaque puce d'une description d'une ligne. Relisez-vous votre propre regex avant la livraison ; utilisez-le pour la revue de code ou l'enseignement.

    Sûr face au ReDoS (timeout wall-clock)

    Chaque appel de correspondance est enveloppé dans un budget de 250 millisecondes. Les formes classiques de retour arrière catastrophique comme `(a+)+`, `(a|aa)+b` et les quantificateurs profondément imbriqués avortent proprement avec un avertissement « Motif expiré » — la page reste réactive au lieu de bloquer l'onglet. Détection sans bac à sable côté serveur.

    Bibliothèque de motifs courants

    Points de départ éprouvés au combat pour les huit motifs que les développeurs cherchent le plus : e-mail, URL, IPv4, UUID v4, couleur hex, date ISO, numéro de téléphone US et suppression des espaces de fin. Chacun se charge avec un exemple correspondant pour que vous voyiez le regex fonctionner avant de l'adapter.

    Partage par permalien (sans téléversement)

    Copier le lien encode motif + drapeaux + texte d'exemple dans le hash d'URL (#p=…&f=gim&t=…). Les navigateurs ne transmettent jamais les fragments d'URL dans les requêtes, donc un lien partagé reproduit votre état sur la machine du destinataire sans toucher aux serveurs go-tools.org. Autonome, vérifiable.

    100 % confidentiel, navigateur uniquement

    Votre regex et votre texte de test ne quittent jamais votre appareil. Pas de requêtes réseau, pas de journalisation, pas d'analyse sur ce que vous tapez. Vérifiez dans DevTools → Réseau : zéro requête quand vous tapez. Sûr pour les motifs propriétaires, les logs caviardés et tout texte que vous ne colleriez pas dans regex101.

    Exemples détaillés

    Extraire toutes les adresses e-mail d'un paragraphe

    [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

    Collez le motif avec le drapeau /g activé, déposez un paragraphe dans le texte de test et chaque e-mail s'illumine dans la vue surlignée. Le panneau Correspondances & groupes de capture, à droite, liste chaque adresse avec ses décalages [début, fin) — utile lorsque vous transmettez le même regex à grep, sed ou à un éditeur de code.

    Capturer les parties d'une date avec des groupes nommés

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

    Les groupes nommés ECMA-262 apparaissent dans le panneau de droite sous la forme $, $, $. Passez à l'onglet Remplacer et essayez $/$/$ pour reformater les dates ISO en JMA d'un seul coup — la même astuce fonctionne dans tout appel JS moderne à replace.

    Rechercher/remplacer avec des références arrière $1

    (\w+) (\w+)
    Remplacement : $2, $1   →   Jack Doe → Doe, Jack

    Deux groupes de capture anonymes, un modèle de remplacement $2, $1, et l'onglet Remplacer vous donne un aperçu en direct. $&, $`, $', $$ et $ sont tous pris en charge — exactement l'alphabet de substitution de la spécification ECMAScript, donc ce que vous copiez s'exécute tel quel dans n'importe quel moteur JS.

    Supprimer les espaces de fin de ligne, ligne par ligne

    [ \t]+$
    /[ \t]+$/gm

    Combinez les drapeaux /g (global) et /m (multiligne) pour que $ s'ancre à la fin de chaque ligne, pas seulement à la fin de l'entrée. L'onglet Remplacer avec un aperçu de remplacement vide montre un diff propre : les tabulations et espaces de fin disparaissent, le texte reste en place. Le même regex avec le drapeau /s (dotAll) désactivé empêche le . de franchir les sauts de ligne.

    Détecter le retour arrière catastrophique et y survivre

    (a+)+b
    Texte de test : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac

    Les quantificateurs + imbriqués forment un motif ReDoS classique. Dans un testeur naïf, cela fige l'onglet. Ici, la garde wall-clock se déclenche après 250 ms, la bannière « Motif expiré » apparaît et la page reste réactive. Ancrez le motif, passez à une alternance non chevauchante ou utilisez des idiomes de type atomique — puis retestez.

    Découper une ligne de type CSV par délimiteurs mixtes

    [,;|]\s*
    alpha, beta; gamma | delta → ["alpha", "beta", "gamma", "delta"]

    Passez à l'onglet Découper. Toute virgule, point-virgule ou barre verticale (suivi d'un espace optionnel) devient une frontière de partie. Utile pour nettoyer des listes d'étiquettes collées, normaliser les entrées utilisateur ou prétraiter des champs de log avant un vrai analyseur CSV — voyez CSV vers JSON lorsque les données sont vraiment au format RFC 4180.

    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 $).

    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

    Oublié le drapeau /g et n'obtenu qu'une seule correspondance

    Sans /g (ou /y), le moteur s'arrête après la première correspondance. Les méthodes match, matchAll, replace et split se comportent toutes différemment autour du drapeau global. Activez /g et relancez ; le compteur au-dessus des résultats passe de 1 à N.

    ✗ Incorrect 
    Motif : /\d+/  →  '1 22 333' donne seulement ['1']
    ✓ Correct 
    Motif : /\d+/g  →  '1 22 333' donne ['1', '22', '333']

    Quantificateur gourmand qui a trop consommé

    `.+` consomme autant que possible, donc `<.+>` contre ` and ` capture ` and `, pas ``. Utilisez des quantificateurs paresseux (`.+?`), des classes de caractères plus restrictives (`[^>]+`), ou ancrez avec des look-arounds.

    ✗ Incorrect 
    Motif : /<.+>/  →  capture '<a> and <b>'
    ✓ Correct 
    Motif : /<[^>]+>/  →  capture '<a>' et '<b>' séparément

    Retour arrière catastrophique dû à des quantificateurs imbriqués

    `(a+)+b` contre une longue chaîne qui échoue explose exponentiellement. La bannière « Motif expiré » se déclenche après 250 ms ; réécrivez pour supprimer l'imbrication : `a+b` fait le même travail en temps linéaire. La simulation de groupe atomique `(?=(a+))\1b` est une autre option.

    ✗ Incorrect 
    Motif : /(a+)+b/  sur 'aaaaaaaaaaaaaaaaaaaaac'  →  timeout
    ✓ Correct 
    Motif : /a+b/  sur la même entrée  →  « aucune correspondance » instantané

    Les ancres $ et ^ ne se comportent pas comme les \A et \Z de Python

    En JavaScript, `^` et `$` signifient début-de-ligne / fin-de-ligne UNIQUEMENT quand /m est activé ; sinon ils signifient début-de-chaîne / fin-de-chaîne. Les `\A` et `\Z` de Python (qui signifient toujours les frontières de chaîne) n'existent pas en JS. Activez /m au besoin.

    ✗ Incorrect 
    Motif : /^Error/  sur un log multiligne sans /m  →  capture seulement la première ligne
    ✓ Correct 
    Motif : /^Error/m  sur la même entrée  →  capture chaque ligne commençant par Error

    Utilisé $1 dans une chaîne mais appelé replace avec une fonction

    `text.replace(re, '$1')` développe la référence arrière. `text.replace(re, () => '$1')` passe une chaîne littérale '$1' car les fonctions ne voient pas les jetons de modèle. À l'intérieur de la fonction, les groupes de capture arrivent comme arguments positionnels.

    ✗ Incorrect 
    text.replace(/(\w+)/, m => '$1')  →  donne le littéral '$1'
    ✓ Correct 
    text.replace(/(\w+)/, (_, g1) => g1.toUpperCase())  →  utilise la capture

    Caractères Unicode non capturés avec \w ou .

    Par défaut `\w` est `[A-Za-z0-9_]`. Pour capturer chaque lettre dans chaque écriture, activez /u et passez à `\p{Letter}` (`\p{L}`). Le point s'arrête aussi aux sauts de ligne par défaut — utilisez /s (dotAll) quand vous voulez un vrai any-character.

    ✗ Incorrect 
    Motif : /\w+/  capture 'hello' mais pas 'héllo' ni '你好'
    ✓ Correct 
    Motif : /\p{Letter}+/u  capture les trois

    Collé un motif PCRE ; obtenu un SyntaxError

    JavaScript ne prend pas en charge les groupes atomiques `(?>...)`, les quantificateurs possessifs `a++`, les modificateurs en ligne `(?i)`, les conditionnels `(?(1)yes|no)`, ni `\A` / `\Z`. L'erreur de l'analyseur nomme le construit fautif — réécrivez vers l'équivalent pris en charge par JS (simulation look-around, bascule de drapeau séparée, alternance).

    ✗ Incorrect 
    Motif : (?i)foo  →  SyntaxError: invalid group
    ✓ Correct 
    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 $ 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
    `(?\d{4})-(?\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 $ 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

    Mon regex ou mon texte de test est-il envoyé à votre serveur ?
    Non. Chaque opération de correspondance, remplacement, découpe et explication s'exécute en JavaScript dans votre navigateur en utilisant le moteur RegExp natif. Votre motif et votre texte ne sont pas téléversés, pas journalisés, pas stockés sur disque, pas envoyés à un tiers. Seules vos préférences d'interface (onglet actif + drapeaux que vous activez habituellement) sont enregistrées dans localStorage pour que la page s'en souvienne à la prochaine visite — jamais le motif ni le texte de test. Vous pouvez le vérifier en ouvrant DevTools → Réseau : taper dans l'une ou l'autre zone ne déclenche aucune requête. Cela rend l'outil sûr pour les motifs propriétaires, les échantillons de logs caviardés, la configuration interne et tout ce que vous ne colleriez pas dans regex101.
    Quelle saveur regex ce testeur utilise-t-il — PCRE, Python, Java, JavaScript ?
    ECMA-262 (JavaScript), le dialecte implémenté par V8, JavaScriptCore et SpiderMonkey — le même moteur que vous obtenez avec `new RegExp(pattern, flags)` dans n'importe quel navigateur, Node.js, Deno ou Bun. Les fonctionnalités prises en charge sont donc : groupes de capture (numérotés + nommés avec `(?...)`), anticipations `(?=...)` et `(?!...)`, retro-anticipations `(?<=...)` et `(?...)`, les quantificateurs possessifs `a++`, les conditionnels `(?(1)yes|no)` et les modificateurs en ligne `(?i)` déclencheront une erreur de syntaxe. `re.VERBOSE` de Python n'est pas pris en charge ici. Pour les regex Python/Java/Go, reportez le motif vers son moteur natif — la plupart des motifs simples se transfèrent tels quels, et l'explicateur ici est neutre quant à la saveur.
    À quoi servent chacun des drapeaux g, i, m, s, u, y, d ?
    g (global) — trouve toutes les correspondances, pas seulement la première ; requis pour itérer avec .matchAll et pour un remplacement global. i (insensible à la casse) — A et a correspondent au même caractère. m (multiligne) — ^ et $ s'ancrent à chaque saut de ligne, pas seulement au début/fin de toute l'entrée. s (dotAll) — . correspond aussi aux sauts de ligne ; sans /s, un point s'arrête à \n. u (unicode) — active les échappements \u{HHHH}, les échappements de propriétés Unicode (\p{Letter}), et traite le motif comme une séquence de points de code Unicode au lieu d'unités de code UTF-16. y (collant) — ancre chaque correspondance à lastIndex, utile pour les tokeniseurs. d (hasIndices, ES2022) — peuple `.indices` et `.indices.groups` avec des paires [début, fin] pour chaque capture ; ce testeur utilise /d sous le capot pour dessiner les frontières de groupe. Basculez-les via les puces au-dessus du texte de test ; le littéral canonique /motif/drapeaux est affiché dans la lecture.
    Comment écrire des groupes de capture et comment y faire référence ?
    Enveloppez un sous-motif entre parenthèses : `(\d{4})-(\d{2})-(\d{2})` vous donne trois groupes positionnels, accessibles via $1, $2, $3 dans les remplacements ou via m.groups[0..2] dans le panneau Correspondances. Utilisez `(?...)` pour les groupes nommés : `(?\d{4})-(?\d{2})` vous permet d'écrire $/$ dans le modèle de remplacement. Utilisez `(?:...)` pour un groupe non capturant lorsque vous n'avez besoin du regroupement que pour un quantificateur (`(?:foo|bar)+`) — il ne crée pas de référence arrière, ce qui garde vos $1..$N numérotés stables. Dans le même motif, faites référence à une capture antérieure avec `\1`, `\2`, etc. — pratique pour trouver des mots doublés comme `\b(\w+)\s+\1\b`.
    Comment fonctionnent l'anticipation et la rétro-anticipation, et à quoi servent-elles ?
    Les look-arounds sont des assertions de largeur nulle — ils vérifient que quelque chose correspond (ou non) sans consommer de caractères. `(?=foo)` (anticipation positive) réussit si `foo` suit la position actuelle ; `(?!foo)` (anticipation négative) réussit si `foo` ne suit PAS. `(?<=foo)` et `(?
    Pourquoi mon regex fige-t-il le navigateur, et qu'est-ce que le retour arrière catastrophique ?
    Le retour arrière catastrophique se produit quand un motif a des quantificateurs imbriqués sur des alternatives qui se chevauchent — la forme classique est `(a+)+`, `(a|aa)+`, `(\w*)*` ou `(?:a|a?)+`. Sur une entrée où la correspondance peut échouer au dernier caractère, le moteur essaie un nombre exponentiel de découpes de groupes avant d'abandonner. Sur `aaaaaaaaaaaaaaaaaaaaab` avec le motif `(a+)+b`, cela représente 2^21 ≈ 2 millions de retours arrière avant la réponse. Ce testeur enveloppe chaque appel de correspondance dans un budget wall-clock de 250 ms — si le budget est dépassé, l'itération s'arrête et vous voyez un avertissement « Motif expiré ». Corrections : ancrer le motif à ses frontières (`^...$`), préférer des alternatives non chevauchantes (`(a|b)` au lieu de `(a|aa)`), dérouler les quantificateurs imbriqués (`a+` au lieu de `(a+)+`), ou réécrire avec des idiomes de type possessif (`(?=(a+))\1` simule `a++` en JS).
    En quoi ce testeur regex diffère-t-il de regex101.com ?
    Trois différences. (1) Confidentialité : regex101 envoie chaque frappe à ses serveurs pour évaluation côté backend et stocke les motifs dans des liens communautaires partagés ; cet outil s'exécute entièrement dans votre navigateur, aucun appel réseau. (2) Vitesse : un aller-retour serveur à chaque modification ajoute 80-300 ms ; ici les correspondances se mettent à jour en moins de 10 ms même sur un long texte. (3) Focus de saveur : regex101 prend en charge PCRE, Python, Java, .NET, JavaScript, Rust et Go avec une interface à drapeaux de fonctionnalités ; cet outil se concentre sur ECMA-262 (JavaScript) — la saveur que tout navigateur, Node, Deno et Bun livrent — et l'explicateur plus les permaliens sont optimisés pour cette saveur unique. Si vous avez besoin de fonctionnalités propres à PCRE, regex101 reste le bon outil ; pour le travail JavaScript / TypeScript, celui-ci est plus rapide et plus confidentiel. Les permaliens ici sont des hachages d'URL (pas de téléversement), donc un lien partagé reproduit votre motif localement sur la machine du destinataire.
    Comment échapper les caractères spéciaux comme . | ( ) [ ] { } * + ? ^ $ \ ?
    Placez une barre oblique inverse devant : `\.`, `\|`, `\(`, `\)`, `\[`, `\]`, `\{`, `\}`, `\*`, `\+`, `\?`, `\^`, `\$`, `\\`. La barre oblique `/` n'a pas besoin d'être échappée dans un motif passé sous forme de chaîne (seulement dans les littéraux regex JS entre les barres obliques). À l'intérieur d'une classe de caractères `[...]`, la plupart des métacaractères perdent leur sens spécial, donc `[.]`, `[*]`, `[+]` correspondent tous à un caractère littéral — les seuls métacaractères qui restent spéciaux sont `]`, `\`, `^` (seulement au début pour négation) et `-` (plage entre deux caractères). En cas de doute, collez le texte littéral dans le motif et lancez l'explicateur : chaque séquence d'échappement obtient une description d'une ligne dans le panneau de décomposition.
    Puis-je partager un regex avec un collègue via un lien ?
    Oui — et le lien ne contient aucun aller-retour serveur. Cliquez sur Copier le lien dans la barre d'actions : le testeur encode votre motif, vos drapeaux, votre texte de test et l'onglet actif dans le hash de l'URL (`#p=...&f=gim&t=...&tab=match`). Quiconque ouvre le lien hydrate la page avec le même état — localement sur sa machine. Comme les données vivent dans le fragment de hash, elles ne sont jamais envoyées au serveur go-tools.org (les navigateurs ne transmettent pas les fragments dans les requêtes) et ne figurent pas dans nos journaux d'accès. La longueur du lien augmente avec la taille du texte, donc pour des échantillons supérieurs à 2 Ko, copiez le regex via Copier /motif/drapeaux et collez le texte séparément. Pour une revue regex collaborative sans partager le texte réel, partagez seulement le motif et les drapeaux — le destinataire colle son propre corpus et obtient les mêmes correspondances.
    Le testeur prend-il en charge Unicode, les emojis et les écritures non latines ?
    Oui. Activez le drapeau /u pour opter pour la gestion Unicode complète : \w correspond aux caractères de mot latins (la sémantique par défaut), mais avec /u vous pouvez correspondre à des catégories plus larges via les échappements de propriétés Unicode — `\p{Letter}` correspond à toutes les lettres de toutes les écritures, `\p{Script=Han}` aux idéogrammes chinois, `\p{Emoji}` aux emojis, `\p{Number}` à tout chiffre/numéral. Sans /u, les emojis à paires de substitution comme 👨‍💻 sont vus comme deux unités de code UTF-16 et des motifs comme `^.$` échouent à les capturer ; avec /u, le point traite chaque point de code de graphème comme un caractère. Pour les écritures de droite à gauche (arabe, hébreu), les motifs fonctionnent sans gestion spéciale — la direction est une affaire de rendu, pas du moteur regex. Le contenu CJC se compare de la même manière que le latin.
    Quelle est la différence entre .match, .matchAll, .replace et .split avec un regex ?
    String.prototype.match renvoie la première correspondance (ou un tableau de toutes les correspondances quand /g est activé) mais perd les groupes de capture quand /g est activé. String.prototype.matchAll exige /g et renvoie un itérateur de tableaux de correspondances AVEC groupes de capture et indices — ce que ce testeur utilise en interne. String.prototype.replace accepte soit un modèle de chaîne ($1, $&, etc.) soit un rappel appelé par correspondance avec (match, ...groups, offset, string, namedGroups). String.prototype.split découpe sur chaque correspondance — utile avec /g, mais le drapeau global est ignoré pour la sémantique de split. Cet outil expose match via l'onglet Correspondance, replace via Remplacer et split via Découper, vous pouvez donc prévisualiser chaque variante sans quitter la page ; le littéral /motif/drapeaux est à un clic quand vous êtes prêt à le coller dans du code.
    Pourquoi mon regex Python ou Java ne fonctionne-t-il pas ici ?
    Parce que ce testeur exécute ECMA-262 (JavaScript) — la plupart des motifs se portent proprement, une poignée non. Pièges de portage courants : (1) Les drapeaux en ligne `(?i)` et `(?x)` de Python ne sont pas valides en JS — utilisez plutôt les puces de drapeaux ci-dessus. (2) Les `\A` et `\Z` de Python sont `^` et `$` en JS (avec /m pour les ancres de ligne). (3) Les conditionnels Java/Python `(?(name)yes|no)` ne sont pas pris en charge en JS — réécrivez avec une alternance. (4) Les quantificateurs possessifs `a++` et les groupes atomiques `(?>...)` sont indisponibles en JS — simulez avec `(?=(a+))\1`. (5) `(?P...)` en Python est `(?...)` en JS. (6) `\h` pour l'espace horizontal et `\v` pour le vertical n'existent pas en JS — utilisez `[ \t]` et `[\n\r]`. Pour un portage portable, l'explicateur décompose ce que fait chaque jeton afin de pouvoir remplacer la syntaxe non prise en charge par un équivalent.
    Y a-t-il une taille de texte ou un nombre de correspondances maximal ?
    Limite pratique : environ 200 000 caractères de texte de test et 500 correspondances surlignées affichées à la fois. Au-delà de 500 correspondances, le panneau Correspondances affiche une bannière « Affichage des 500 premières » ; le badge de comptage rapporte toujours le vrai total. Le budget wall-clock de 250 ms encadre les motifs incontrôlables quelle que soit la taille. Pour les fichiers de log de plusieurs mégaoctets, exécutez le regex avec la ligne de commande `grep -oE` ou `rg` (ripgrep) — ils streament et n'atteindront pas un plafond de rendu d'interface. Pour une analyse ponctuelle de texte énorme, collez une tranche représentative dans ce testeur pour valider le motif, puis exécutez le motif validé sur le fichier complet dans votre shell.

    Outils connexes

    Voir tous les outils →

    Comparer deux textes — Diff

    Traitement de texte

    Comparez deux textes instantanément dans votre navigateur. Vue côte à côte, surlignage mot à mot, export en diff unifié, options pour ignorer casse/espaces/lignes vides. 100 % navigateur — aucun upload.

    Compteur de mots et de caractères gratuit

    Traitement de texte

    Comptez instantanément mots, caractères, phrases, paragraphes et temps de lecture. Compteur en direct avec vérifications de limites Twitter, méta description et Instagram. Gratuit, privé, sans inscription.

    Convertisseur de Base — Binaire, Hex, Décimal & Octal

    Outils de conversion

    Convertissez entre binaire, hexadécimal, décimal, octal et toute base (2-36) instantanément. Gratuit, privé, 100 % dans votre navigateur.

    Décodeur et Encodeur Base64

    Encodage et formatage

    Décodez et encodez en Base64 en ligne gratuitement. Conversion en temps réel, support UTF-8 et émojis. 100 % privé, dans votre navigateur.

    Générateur crontab et constructeur d'expressions cron

    Date et heure

    Construisez et décodez des expressions cron dans le navigateur. Aperçu en direct de la prochaine exécution en heure locale ou UTC. POSIX 5 champs, préréglages, description claire. Gratuit et privé.

    Convertisseur CSV vers JSON

    Encodage et formatage

    Convertissez du CSV en JSON dans le navigateur. RFC 4180, inférence de types, ligne d'en-tête, sûr pour grands entiers. 100 % privé, sans envoi.