Testeur et Débogueur Regex

Testez et déboguez vos expressions régulières JavaScript localement dans le navigateur.

Aucun téléversementSans inscriptionRésultats instantanés
Drapeaux g · i · m · s · u · v · yGroupes capturants et nommés + Remplacement100% Local • Zéro Envoi
Tester l'expression régulière
Moteur hors ligne prêtEspace 100% privé dans le navigateur • Aucun transfert cloud
100 % Privé • Aucun fichier envoyé sur un serveur

Pourquoi utiliser Testeur et Débogueur Regex gratuitement sur Utiliome ?

Conçu pour garantir une confidentialité stricte, sans inscription ni abonnement requis.

Parité Native avec le Moteur RegExp ECMA-262

S'exécute directement sur le moteur d'expressions régulières ECMAScript de votre navigateur avec activation instantanée des drapeaux global (g), insensible à la casse (i), multiligne (m), dotAll (s), Unicode (u) et adhérent (y).

Inspecteur de Captures Indexées et Nommées

Extrait les intervalles d'unités de code UTF-16 [start, end) basés sur zéro, les sous-correspondances numérotées ($1 à $99) et les dictionnaires de captures nommées ((?<name>...)) pour chaque occurrence sur des contenus multilignes.

Aperçu en Direct des Substitutions et Références Arrière

Évalue les modèles String.prototype.replace et replaceAll en temps réel à l'aide des jetons $1, $<name>, $& (correspondance complète), $' (suffixe après correspondance) et de l'échappement littéral $$.

Détection ReDoS et Confidentialité Sans Envoi Serveur

Met en évidence les quantificateurs imbriqués sujets au backtracking catastrophique tout en conservant vos journaux de production sensibles, jetons Bearer et données personnelles (PII) strictement dans la mémoire locale du navigateur.

Utiliome vs alternatives cloud traditionnelles

Comparez notre moteur local WebAssembly aux outils cloud anciens.

Fonctionnalité Utiliome (Navigateur local) Convertisseurs cloud anciens
Parité Native avec le Moteur RegExp ECMA-262 S'exécute directement sur le moteur d'expressions régulières ECMAScript de votre navigateur avec activation instantanée des drapeaux global (g), insensible à la casse (i), multiligne (m), dotAll (s), Unicode (u) et adhérent (y). Options limitées sans personnalisation avancée
Inspecteur de Captures Indexées et Nommées Extrait les intervalles d'unités de code UTF-16 [start, end) basés sur zéro, les sous-correspondances numérotées ($1 à $99) et les dictionnaires de captures nommées ((?<name>...)) pour chaque occurrence sur des contenus multilignes. Nécessite des outils externes ou un traitement manuel
Confidentialité et Traitement 100 % local dans le navigateur (zéro envoi serveur) Envoie les données vers des serveurs cloud tiers
Tarif et Inscription 100 % gratuit à vie, sans compte ni filigrane Inscription obligatoire ou abonnement payant
Comment ça marche

Comment utiliser Testeur et Débogueur Regex en 3 étapes simples

Aucune installation requise. Tout s'exécute directement dans votre navigateur web.

1

Saisir le Motif et Activer les Drapeaux du Moteur

Tapez le corps de votre expression régulière sans les barres obliques englobantes et activez les drapeaux ECMAScript exacts (g, i, m, s, u, y) utilisés par votre environnement d'exécution JavaScript ou TypeScript.

2

Coller le Texte d'Exemple et Inspecter les Captures

Collez vos chaînes de test ou chargez un fichier de logs local pour inspecter les délimitations des correspondances surlignées, les plages d'index de caractères, les emplacements de capture numérotés et les mappages de groupes (?<name>...).

3

Prévisualiser les Substitutions et Copier l'Expression

Saisissez une chaîne de remplacement facultative avec des références $1, $<name> ou $& pour vérifier en direct le texte transformé, puis copiez votre littéral regex validé.

Débogage de Journaux Structurés avec Groupes de Capture Nommés et Substitutions en Direct

Réponse rapide: Combinez les groupes de capture nommés ((?<name>...)) avec les drapeaux global (g) et multiligne (m) pour analyser des lignes de logs structurés en dictionnaires clé-valeur, vérifier les offsets UTF-16 exacts et prévisualiser les transformations de chaînes $<name> avant la mise en production.

Lors du dépannage d'expressions régulières sur des journaux d'accès ou de télémétrie multilignes, de subtiles erreurs d'ancrage ou de quantificateurs provoquent souvent des échecs de correspondance silencieux ou un décalage des groupes numérotés. Prenons deux lignes de journal d'application structurées contenant des horodatages ISO-8601, des niveaux de sévérité, des identifiants de service, des identifiants de trace hexadécimaux sur 16 caractères, des codes de statut HTTP et des latences à virgule flottante :

2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7
2026-11-01T14:22:09.004Z [INFO] svc=inventory trace_id=00f067aa0ba902b7 status=200 latency_ms=12.3

Pour analyser chaque ligne de manière déterministe sans dépendre d'un indexage positionnel fragile, associez chaque champ à un groupe de capture nommé ECMAScript ((?<name>...)), enveloppez le suffixe décimal optionnel des millisecondes dans un groupe non capturant ((?:...)), et activez à la fois g (itération globale) et m (ancres ^ et $ par ligne) :

^(?<ts>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[(?<level>ERROR|WARN|INFO)\]\s+svc=(?<service>[a-z0-9_-]+)\s+trace_id=(?<trace>[0-9a-f]{16})\s+status=(?<status>\d{3})\s+latency_ms=(?<ms>\d+(?:\.\d+)?)$

Sans le drapeau m, les ancres ^ et $ se fixent exclusivement à l'index 0 et à la fin de l'intégralité du tampon, ce qui fait échouer l'expression dès qu'un saut de ligne (\n) sépare les enregistrements. Avec gm actif, le débogueur de groupes de capture résout chaque itération à la fois en sous-correspondances positionnelles (indexées à partir de 1) et en un objet groups structuré :

{
  "matchIndex": 0,
  "span": [0, 99],
  "fullMatch": "2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7",
  "captures": [
    "2026-11-01T14:22:08.419Z",
    "ERROR",
    "checkout",
    "4bf92f3577b34da6",
    "502",
    "184.7"
  ],
  "groups": {
    "ts": "2026-11-01T14:22:08.419Z",
    "level": "ERROR",
    "service": "checkout",
    "trace": "4bf92f3577b34da6",
    "status": "502",
    "ms": "184.7"
  }
}

Une fois les limites de capture vérifiées, vous pouvez tester le formatage String.prototype.replaceAll directement dans le panneau de substitution. En fournissant le modèle [$<level>] $<service>: HTTP $<status> ($<ms>ms, trace=$<trace>), vous obtenez immédiatement une sortie normalisée :

[ERROR] checkout: HTTP 502 (184.7ms, trace=4bf92f3577b34da6)
[INFO] inventory: HTTP 200 (12.3ms, trace=00f067aa0ba902b7)

Sémantique du Moteur RegExp ECMA-262, Mécanique des Drapeaux et Backtracking Catastrophique

Réponse rapide: Les expressions régulières JavaScript s'exécutent sur un automate fini non déterministe (NFA) à retour sur trace défini par la section 22.2 d'ECMA-262, opérant sur des unités de code UTF-16 de 16 bits sauf si le drapeau u active la correspondance sur les valeurs scalaires Unicode complètes. Éviter les quantificateurs imbriqués ambigus prévient les blocages d'exécution ReDoS exponentiels en O(2^n).

Exécution NFA par Backtracking et Propriété à État `lastIndex`

Contrairement aux moteurs à automate fini déterministe (DFA) pur, les moteurs ECMAScript (V8 Irregexp, JavaScriptCore Yarr, SpiderMonkey) implémentent un automate fini non déterministe (NFA) à retour sur trace (backtracking) afin de prendre en charge les références arrière (\1, \k<name>) et les assertions lookaround arbitraires ((?=...), (?!...), (?<=...), (?<!...)). Les alternatives séparées par | sont évaluées de gauche à droite ; les quantificateurs gourmands (*, +, ?, {m,n}) consomment autant de caractères que possible avant de revenir en arrière pas à pas pour satisfaire les jetons suivants, tandis que les quantificateurs paresseux (*?, +?, ??, {m,n}?) tentent d'abord l'expansion la plus courte.

Lorsque g (global) ou y (adhérent / sticky) est défini, RegExp.prototype.exec() lit et modifie la propriété lastIndex de l'instance :

  • Global (g) : Recherche à partir de lastIndex ou après, en avançant lastIndex jusqu'à l'offset de fin de chaque correspondance (ou en l'incrémentant d'un point de code Unicode lors d'une correspondance de longueur nulle) et en le réinitialisant à 0 en cas d'échec.
  • Adhérent (y) : Ancre la correspondance strictement à lastIndex sans parcourir la chaîne plus loin. Si aucune correspondance ne commence exactement à lastIndex, l'évaluation échoue immédiatement et remet lastIndex à 0, ce qui rend y idéal pour construire des analyseurs lexicaux sans copie.

Terminateurs de Ligne, Paires de Substituts UTF-16 et Drapeau `u`

La norme ECMA-262 reconnaît exactement quatre points de code terminateurs de ligne : \n (U+000A), \r (U+000D), le séparateur de ligne (U+2028) et le séparateur de paragraphe (U+2029). L'activation de m permet à ^ et $ de correspondre aux limites adjacentes à ces quatre points de code ; l'activation de s (dotAll) permet à . de les capturer.

Par défaut, les chaînes JavaScript sont indexées sous forme de séquences d'unités de code UTF-16 de 16 bits. Les caractères Unicode supplémentaires au-delà de U+FFFF (tels que les émojis ou les symboles mathématiques) occupent une paire de substituts (surrogate pair) de deux unités (substitut haut 0xD800–0xDBFF suivi d'un substitut bas 0xDC00–0xDFFF). Sans u, /^.$/.test("🚀") renvoie false car "🚀".length vaut 2. L'activation de u bascule l'évaluation sur des valeurs scalaires Unicode de 21 bits, débloque les séquences d'échappement de propriétés Unicode (\p{Letter}, \p{Script=Latin}, \P{Control}) et désactive les échappements d'identité permissifs hérités de l'Annexe B afin que les séquences invalides échouent dès la compilation.

Grammaire de Remplacement `GetSubstitution` d'ECMA-262

Le remplacement en direct suit la table standard GetSubstitution :

  • $$ : Insère un caractère $ littéral unique.
  • $& : Insère la sous-chaîne entière correspondante (match[0]).
  • $' : Insère la sous-chaîne qui suit la plage correspondante.
  • $n / $nn : Insère la capture numérotée n indexée à partir de 1 (1 à 99).
  • $<name> : Insère la chaîne capturée par (?<name>...), ou une chaîne vide "" lorsque le groupe nommé n'a pas participé à la branche de correspondance actuelle.

Prévention du Backtracking Catastrophique (ReDoS)

Le déni de service par expression régulière (ReDoS) survient lorsque des quantificateurs imbriqués ou qui se chevauchent — tels que (a+)+$, ([a-zA-Z0-9]+\s?)*$ ou (.*a){12} — correspondent à des sous-chaînes identiques via un nombre exponentiel de partitions (O(2^n) étapes) avant d'échouer sur un caractère final. Comme ECMA-262 n'inclut pas les quantificateurs possessifs (++) ni les groupes atomiques ((?>...)), renforcez vos motifs en appliquant ces règles :

  1. Ensembles de Caractères Mutuellement Exclusifs : Remplacez les .* gourmands entre délimiteurs par des classes niées comme [^,\r\n]* afin que le moteur ne puisse pas franchir les limites des délimiteurs.
  2. Déroulement des Délimiteurs (Unrolling) : Réécrivez ^(\w+-?)+$ (ambigu lorsque - est absent) sous la forme ^\w+(?:-\w+)*$, réduisant la complexité dans le pire des cas à un temps strictement linéaire O(n).
  3. Émulation Atomique par Lookahead : Lorsque le retour sur trace dans une sous-expression doit être interdit, capturez à l'intérieur d'un lookahead positif et consommez immédiatement via une référence arrière : (?=(\w+))\1.

Testeur de Regex vs Générateur de Regex : Lequel Choisir ?

Réponse rapide: Utilisez le Testeur et Débogueur Regex lorsque vous possédez déjà un motif et devez inspecter les offsets de correspondance, déboguer des groupes de capture nommés, basculer les drapeaux ECMAScript ou tester des remplacements $<name> sur des données réelles. Utilisez le Générateur de Regex pour assembler visuellement une nouvelle expression ou exporter du code regex multilingue.

Bien que le test et la synthèse fassent partie du même flux de travail autour des expressions régulières, ils répondent à des problématiques d'ingénierie distinctes. Testeur et Débogueur Regex est un atelier de diagnostic interactif conçu pour inspecter le comportement d'un motif ECMAScript existant face à des données réelles complexes. Si vous avez plutôt besoin de composer une nouvelle expression à partir de blocs visuels, de partir d'un modèle conforme aux RFC ou d'exporter du code prêt à l'emploi pour Python, Go ou Rust, passez au Générateur de Regex.

Capacité Testeur et Débogueur Regex Générateur de Regex
Tâche d'Ingénierie Principale Déboguer les correspondances, plages de capture, drapeaux et remplacements sur des motifs existants Construire visuellement de nouveaux motifs à partir de blocs ou de modèles RFC vérifiés
Données d'Entrée Expression regex brute, drapeaux ECMAScript et texte de test ou fichiers de logs multilignes Blocs de jetons composables ou modèles développeur (UUID, SemVer, IPv4, ISO-8601)
Débogage des Groupes de Capture Plages d'offsets [start, end) complètes, emplacements $1–$99 et dictionnaire (?<name>...) Validation de réussite/échec sur des jeux de tests positifs et négatifs
Substitution de Chaînes en Direct Aperçu replace / replaceAll en temps réel avec $1, $<name>, $& et $$ Non orienté sur les modèles de transformation de texte
Export de Code Multilingue Littéral regex et sortie de motif ECMAScript / JavaScript Extraits de code idiomatiques pour JavaScript, Python (re), Go (regexp) et Rust (regex)
Architecture Moteur Ciblée Sémantique native NFA à backtracking ECMA-262 et détection ReDoS Portabilité inter-moteurs entre ECMA-262, Python re et RE2 en temps linéaire

Flux de Travail Recommandé

Commencez dans le Générateur de Regex lors de la création de règles de validation pour des identifiants structurés tels que des versions sémantiques, des UUID RFC 9562 ou des slugs d'URL au sein de services polyglottes. Une fois qu'un motif est déployé dans un pipeline frontend ou Node.js — ou lorsqu'une expression manque de façon inattendue un cas limite dans les logs de production — collez l'expression et l'échantillon de journal brut ici dans le Testeur et Débogueur Regex pour inspecter les plages de caractères par correspondance, les interactions des drapeaux avec lastIndex et les modèles de substitution.

FAQ

FAQ et guide technique sur Testeur et Débogueur Regex

Tout ce qu'il faut savoir sur l'utilisation en ligne gratuite de testeur regex en ligne.

Pourquoi une regex globale renvoie-t-elle alternativement true et false avec RegExp.prototype.test() en JavaScript ?

Lorsque le drapeau global (g) ou adhérent (y) est défini sur un objet RegExp JavaScript, l'appel à .test() ou .exec() modifie la propriété lastIndex de l'instance pour pointer immédiatement après la sous-chaîne correspondante. L'appel suivant à .test() reprend l'analyse à partir de lastIndex au lieu de l'index 0 ; une fois qu'il atteint la fin de la chaîne sans trouver d'autre correspondance, il renvoie false et réinitialise lastIndex à 0. Pour une validation booléenne sans état, omettez le drapeau g ou réinitialisez explicitement regex.lastIndex = 0.

Quelle est la différence entre les groupes de capture indexés, les groupes non capturants et les groupes de capture nommés ?

Les parenthèses standard (...) stockent les sous-chaînes correspondantes dans des emplacements de capture séquentiels indexés à partir de 1 ($1, $2) ainsi que dans le tableau renvoyé par exec(). Les groupes non capturants (?:...) regroupent des jetons pour leur appliquer des quantificateurs ou une alternance sans enregistrer de sous-correspondance ni décaler les index $n suivants. Les groupes de capture nommés (?<name>...) alimentent à la fois leur emplacement numéroté séquentiel et match.groups.name (accessible via $<name> dans les chaînes de remplacement), évitant ainsi la casse des index lorsque le motif évolue.

Quand dois-je activer le drapeau Unicode (u) dans les expressions régulières ECMAScript ?

Activez u dès que vous analysez du texte utilisateur non-ASCII, des émojis, des idéogrammes CJK supplémentaires ou des catégories de caractères Unicode. Sans u, JavaScript évalue les chaînes comme des unités de code UTF-16 de 16 bits, ce qui amène . ou les classes niées comme [^x] à scinder les paires de substituts de 4 octets au-delà de U+FFFF en demi-substituts corrompus. L'activation de u bascule la correspondance sur des points de code Unicode complets de 21 bits, active les séquences de propriétés \p{...} telles que \p{Letter} et \p{Number}, et applique une validation syntaxique stricte sur les échappements non reconnus.

Comment fonctionnent les jetons de remplacement comme $&, $1 et $<name> dans l'aperçu de substitution en direct ?

Les aperçus de substitution implémentent l'algorithme GetSubstitution d'ECMA-262 utilisé par String.prototype.replace() et replaceAll(). $& insère l'intégralité de la sous-chaîne correspondante, $1 à $99 insèrent le groupe de capture numéroté correspondant, $<name> insère le texte capturé par (?<name>...), $' insère tout ce qui suit la correspondance, la séquence dollar-accent grave insère tout ce qui précède la correspondance, et $$ produit un caractère $ littéral.

Qu'est-ce qui provoque le backtracking catastrophique (ReDoS) et comment réécrire les motifs vulnérables ?

Le backtracking catastrophique se produit dans les moteurs NFA à retour sur trace lorsque des quantificateurs imbriqués ou qui se chevauchent — tels que (a+)+b ou ^([a-zA-Z0-9]+\s?)*$ — peuvent partitionner la même séquence d'entrée de O(2^n) manières avant d'échouer sur un caractère final inattendu. Éliminez l'ambiguïté en remplaçant les séquences gourmandes .* par des classes de caractères niées ([^,\r\n]*), en déroulant les séparateurs optionnels sous la forme ^[a-zA-Z0-9]+(?:\s[a-zA-Z0-9]+)*$ et en bornant les quantificateurs ouverts avec des limites explicites ({1,64}). Pour construire dès le départ des motifs compatibles RE2 en temps linéaire, utilisez le Générateur de Regex.