Testeur d'Expressions Régulières

Recommandations connexes

Cas d'utilisation

• Tester en ligne si les expressions régulières pour e-mail, téléphone, pièce d'identité, URL, etc. sont correctes lors du développement de règles de validation de formulaires
• Extraire les horodatages, messages d'erreur et adresses IP des journaux de niveau ERROR/INFO à l'aide de regex lors de l'analyse de logs
• Prévisualiser les effets de remplacement regex pendant le nettoyage de données/ETL, comme la conversion de formats de date, le masquage d'informations sensibles (astérisques au milieu des numéros de téléphone)
• Vérifier si les regex d'extraction de contenu correspondent exactement aux fragments HTML ou champs JSON cibles lors de l'écriture de crawlers web
• Comprendre la signification de chaque métacaractère et quantificateur via le panneau「Explication」lors de l'apprentissage des expressions régulières, et se familiariser rapidement avec les modèles
• Envoyer des expressions régulières douteuses à des collègues via un lien de partage pendant le Code Review, pour déboguer et optimiser ensemble

Fonctionnalités

• Exécution en sandbox Web Worker : les regex s'exécutent dans un thread Worker indépendant avec interruption automatique après 500 ms, empêchant complètement le ReDoS de bloquer le navigateur
• Correspondance en temps réel + surlignage coloré : les résultats s'affichent instantanément lors de la saisie, avec 5 couleurs pour distinguer les différentes correspondances, et panneau de détails lié au survol
• Groupes de capture + groupes nommés : chaque correspondance se développe automatiquement pour afficher tous les groupes de capture ($1/$2) et groupes nommés ($<name>), avec statistiques récapitulatives
• Aperçu de remplacement : saisissez une chaîne de remplacement pour voir un aperçu en temps réel, avec boutons rapides pour la syntaxe $1/$&/$`/$'/$<name>
• Explication de la syntaxe regex : analyse automatiquement l'expression régulière et explique élément par élément la signification des métacaractères, quantificateurs, groupes, ancres, etc.
• 12 modèles courants : inclut 12 modèles regex fréquents comme e-mail/URL/téléphone/chinois/IPv4/UUID/date/logs/balises HTML, remplissables en un clic
• Basculement de 6 indicateurs : boutons visuels pour basculer g/i/m/s/u/y, pas besoin de mémoriser la syntaxe
• Lien de partage : génère une URL incluant pattern/flags/text en un clic, copiez-la à des collègues pour reproduire directement la scène de test
• Statistiques d'exécution : affiche en temps réel le nombre de correspondances, le temps d'exécution (ms), le nombre total de groupes de capture et la quantité de groupes nommés
• Limite de 1500 correspondances : troncature automatique pour éviter les ralentissements de page dus à un texte trop long, et messages d'erreur conviviaux pour les regex avec erreurs de syntaxe

Comment utiliser

1. Saisissez une expression régulière dans le champ de saisie entre / / en haut (pas besoin d'ajouter vous-même les barres obliques), saisissez les indicateurs (comme g, gi, gim) à droite ou cliquez sur les boutons ci-dessous pour les basculer
2. Collez ou saisissez le contenu textuel à faire correspondre dans la zone「Texte de test」; les résultats de correspondance seront surlignés en couleurs en temps réel
3. Cliquez sur le panneau「Détails de correspondance」à droite pour voir la position, le contenu, les groupes de capture et groupes nommés de chaque correspondance
4. Basculez vers l'onglet「Zone de remplacement」, saisissez une chaîne de remplacement (compatible avec les références telles que $1/$&/$<name>) et prévisualisez le résultat du remplacement en temps réel
5. Basculez vers l'onglet「Explication d'expression」pour voir l'explication élément par élément de la syntaxe regex générée automatiquement
6. Lorsque vous avez besoin de modèles courants, cliquez sur「Bibliothèque de modèles par catégorie」à gauche pour sélectionner le modèle correspondant et le remplir en un clic ; après le débogage, cliquez sur「Partager」pour générer un lien

FAQ

Qu'est-ce qu'une Expression Régulière (Regex/RegExp) ?

术语表

Regex / RegExp

Abréviation de Regular Expression (expression régulière), une syntaxe de chaîne décrivant des motifs de correspondance de texte, utilisée pour rechercher, remplacer et valider du texte.

Groupe de Capture (Capture Group)

Sous-expression entourée de parenthèses (pattern), les résultats correspondants peuvent être référencés par position à l'aide de $1, $2.

Groupe Nommé (Named Group)

Groupe de capture défini avec la syntaxe (?<name>pattern), peut être référencé par nom à l'aide de $<name>, avec une meilleure lisibilité que les références numériques.

ReDoS

Regular Expression Denial of Service (déni de service par expression régulière), causé par un retour arrière catastrophique qui fait croître exponentiellement le temps d'exécution regex, bloquant le navigateur ou le serveur.

Retour Arrière (Backtracking)

Mécanisme du moteur NFA par lequel, lorsqu'une tentative de correspondance échoue, il revient à des positions antérieures pour essayer d'autres possibilités ; des regex complexes peuvent provoquer un retour arrière exponentiel.

Indicateurs (Flags)

Paramètres modifiant le comportement de correspondance regex ; les courants sont g(global), i(ignore casse), m(multiligne), s(dotAll), u(Unicode), y(adhésif).

Assertions de Recherche (Lookaround)

Assertions de largeur nulle, incluant l'assertion positive avant (?=...), l'assertion négative avant (?!...), l'assertion positive arrière (?<=...), l'assertion négative arrière (?<!...), elles ne font que juger la position sans consommer de caractères.

PCRE

Perl Compatible Regular Expressions (expressions régulières compatibles Perl), un standard de syntaxe regex largement utilisé adopté par la plupart des langages tels que PHP, Java, Python.

Web Worker

API du navigateur fournissant des threads d'arrière-plan indépendants du thread principal ; cet outil l'utilise pour exécuter des regex dans des Workers, de sorte que même si un ReDoS se produit, l'UI n'est pas bloquée.

Quantificateur (Quantifier)

Syntaxe spécifiant le nombre de répétitions de l'élément précédent : *(0 ou plus), +(1 ou plus), ?(0 ou 1), {n}(exactement n fois), {n,m}(n à m fois).

Tableau de référence rapide des métacaractères regex courants

Modèles de référence rapide d'expressions régulières courantes

Code Examples

// Valider le format d'e-mail
const emailRe = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
console.log(emailRe.test('user@example.com')); // true

// Extraire les groupes nommés (analyse de dates)
const dateRe = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = '会议时间：2026-03-12，截止：2026-04-01';
const matches = [...text.matchAll(dateRe)];
for (const m of matches) {
  console.log(m.groups.year, m.groups.month, m.groups.day);
}

// Remplacement : conversion de format de date YYYY-MM-DD → MM/DD/YYYY
const reformatted = text.replace(dateRe, '$<month>/$<day>/$<year>');
console.log(reformatted);
// Heure de réunion : 03/12/2026, échéance : 04/01/2026

import re

# Rechercher toutes les correspondances
text = '联系：alice@example.com，bob@test.org'
emails = re.findall(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', text)
print(emails)  # ['alice@example.com', 'bob@test.org']

# Extraction avec groupes nommés (Python utilise la syntaxe ?P<name>)
date_pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
m = re.search(date_pattern, '发布于 2026-03-12')
if m:
    print(m.group('year'), m.group('month'), m.group('day'))

# Remplacement : masquer les 4 chiffres centraux du numéro de téléphone
phone_re = r'(1[3-9]\d)\d{4}(\d{4})'
result = re.sub(phone_re, r'\1****\2', '手机号：13812345678')
print(result)  # Téléphone : 138****5678

import java.util.regex.*;

class RegexDemo {
    public static void main(String[] args) {
        String text = "Error [2026-03-12 18:05:09] Connection failed";

        // Compiler la regex (en production, il faut mettre en cache l'instance Pattern)
        Pattern p = Pattern.compile(
            "(?<level>INFO|WARN|ERROR)\\s+\\[(?<time>[^\\]]+)\\]\\s+(?<message>.+)"
        );
        Matcher m = p.matcher(text);

        if (m.find()) {
            System.out.println("级别: " + m.group("level"));
            System.out.println("时间: " + m.group("time"));
            System.out.println("消息: " + m.group("message"));
        }

        // Remplacer tous les chiffres
        String cleaned = "abc123def456".replaceAll("\\d+", "*");
        System.out.println(cleaned); // abc*def*
    }
}

Authoritative References

• MDNMDN : Documentation officielle RegExp
• WikipediaExpressions régulières - Wikipédia
• OWASPOWASP : Guide de protection contre les attaques ReDoS