Testez les expressions régulières en ligne. Analysez les correspondances, corrigez les erreurs et créez des modèles efficaces pour la recherche de données.
Aucune correspondance trouvée
Aucun contenu non correspondant
Permet de vérifier les modèles RegExp en temps réel, ce qui simplifie le développement et le débogage de modèles de recherche complexes.
Permet de prendre en compte la sensibilité à la casse, la recherche globale, le mode multiligne et d'autres paramètres utilisés dans les langages de programmation.
Permet de créer rapidement des expressions pour le traitement automatique de grands tableaux textuels, de journaux et de code HTML.
Les expressions régulières (Regex) sont un langage de motifs utilisé pour rechercher, valider et traiter du texte.
Avec les regex, vous pouvez :
trouver des fragments de texte spécifiques (par exemple : email, URL, nombres)
valider des formats de données (validation de formulaires)
remplacer et nettoyer du texte
extraire des données structurées à partir de chaînes
Les regex sont largement utilisées en développement, en analyse de données, en SEO et en automatisation.
Cet outil permet de tester des expressions régulières en temps réel et de voir immédiatement le résultat.
Avec lui, vous pouvez :
vérifier si une chaîne correspond à un motif
afficher toutes les correspondances dans un texte
déboguer des expressions complexes
tester différentes variantes de regex sans écrire de code
Les expressions régulières ne sont pas totalement universelles. La prise en charge de la syntaxe dépend du langage de programmation et du moteur utilisé.
Moteur | Utilisation | Particularités |
|---|---|---|
JavaScript (ECMAScript) | Navigateurs, Node.js | Lookbehind limité (selon la version) |
PCRE | PHP, de nombreux outils | L’un des moteurs les plus puissants |
Python (re) | Python | Certaines fonctionnalités de PCRE sont absentes |
Java (Pattern) | Java | Syntaxe stricte |
.NET | C# | Fonctionnalités étendues |
Testez toujours votre regex dans l’environnement cible. Tenez compte des différences de prise en charge du lookbehind et d’Unicode. Pour des solutions multiplateformes, privilégiez une syntaxe plus simple.
Les flags sont des modificateurs qui changent la manière dont le motif est interprété. Ils permettent de contrôler la casse, la portée de recherche (une seule ligne ou plusieurs lignes) et l’interprétation des caractères.
Flag | Signification |
|---|---|
i | Ignore la casse |
g | Recherche globale |
m | Mode multiligne |
s | Dotall (inclut \n dans .) |
u | Unicode |
Taper | Symbole | Description |
|---|---|---|
Ancres (positions) | ^ | Début de chaîne |
Ancres (positions) | $ | Fin de chaîne |
Ancres (positions) | \b | Limite de mot |
Ancres (positions) | \B | Pas une limite de mot |
Métacaractères | . | Correspond à n’importe quel caractère sauf le saut de ligne (\n) |
Métacaractères | | | Opérateur OU |
Métacaractères | \ | Caractère d’échappement |
Littéraux | a | Caractère « a » |
Littéraux | ab | Chaîne « ab » |
Quantificateurs | * | 0 répétition ou plus |
Quantificateurs | ? | 0 ou 1 répétition |
Quantificateurs | + | 1 répétition ou plus |
Quantificateurs | {5} | Exactement 5 répétitions |
Quantificateurs | {5,} | 5 répétitions ou plus |
Quantificateurs | {5,10} | Entre 5 et 10 répétitions |
Classes de caractères | \s | Espace blanc |
Classes de caractères | \S | Non-espace blanc |
Classes de caractères | \w | Caractère de mot (alphanumérique + underscore) |
Classes de caractères | \W | Caractère non-mot |
Classes de caractères | \d | Chiffre |
Classes de caractères | \D | Caractère non numérique |
Séquences d’échappement | [\b] | Retour arrière (backspace) |
Séquences d’échappement | \c | Caractère de contrôle |
Séquences d’échappement | \n | Saut de ligne |
Séquences d’échappement | \t | Tabulation |
Séquences d’échappement | \r | Retour chariot |
Séquences d’échappement | \ZZZ | Caractère octal |
Séquences d’échappement | \xZZ | Caractère hexadécimal |
Séquences d’échappement | \0 | Caractère nul |
Séquences d’échappement | \v | Tabulation verticale |
Groupes | (xyz) | Groupe capturant |
Groupes | (?:xyz) | Groupe non capturant |
Ensembles et plages | [xyz] | N’importe quel caractère parmi x, y ou z |
Ensembles et plages | [^xyz] | Tout caractère sauf x, y ou z |
Ensembles et plages | [a-q] | Intervalle de a à q |
Ensembles et plages | [0-7] | Intervalle de 0 à 7 |
Motifs de remplacement | $` | Texte avant la correspondance |
Motifs de remplacement | $' | Texte après la correspondance |
Motifs de remplacement | $+ | Dernier groupe capturé |
Motifs de remplacement | $& | Correspondance complète |
Motifs de remplacement | $n | Groupe capturé n (par ex. $1, $2) |
Lookarounds | (?=xyz) | Lookahead positif |
Lookarounds | (?!xyz) | Lookahead négatif |
Lookarounds | (?<=xyz) | Lookbehind positif |
Lookarounds | (?<!xyz) | Lookbehind négatif |
Commentaires | (?#comment) | Commentaire (ignoré par le moteur) |
Tâche | Regex |
|---|---|
Chiffres uniquement | ^\d+$ |
Lettres latines uniquement | ^[A-Za-z]+$ |
Date (DD.MM.YYYY) | \d{2}\.\d{2}\.\d{4} |
Domaine | ^[a-z0-9.-]+\.[a-z]{2,}$ |
URL | https?:\/\/[^\s]+ |
Slug | ^[a-z0-9-]+$ |
Email (basique) | ^[^\s@]+@[^\s@]+\.[^\s@]+$ |
Email (strict) | ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$ |
Téléphone (générique) | ^\+?\d{7,15}$ |
Balises HTML | <[^>]+> |
Mot de passe fort | ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W_]).{12,}$ |
UUID | ^[0-9a-fA-F-]{36}$ |
Couleur HEX | ^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$ |
IP (IPv4) | ^(\d{1,3}\.){3}\d{1,3}$ |
Adresse MAC | ^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$ |
Les expressions régulières paraissent souvent simples, mais elles contiennent de nombreuses subtilités. Voici les erreurs les plus courantes qui conduisent à des résultats incorrects.
Oubli d’échappement : . correspond à n’importe quel caractère, pas à un point littéral → utilisez \.
Mauvaise utilisation des quantificateurs : *, +, {} s’appliquent à l’élément précédent, pas à toute la chaîne
Confusion entre expressions gourmandes et non gourmandes : .* est gourmand → utilisez .*? pour une correspondance minimale
Absence des ancres ^ et $ : sans elles, la regex peut trouver une correspondance n’importe où dans la chaîne
Sensibilité à la casse : "Test" ≠ "test" → utilisez le flag i si nécessaire
Mauvaise gestion des espaces : \s inclut les tabulations, retours à la ligne, etc., pas uniquement l’espace
Utilisation de \w pour Unicode : dans la plupart des moteurs, \w = [A-Za-z0-9_] (pas de cyrillique, etc.)
Tentative d’analyser des formats complexes (HTML, JSON) avec regex : peu fiable → utilisez des parseurs dédiés
Expressions trop complexes : difficiles à maintenir et à déboguer
Quantificateurs imbriqués : par exemple (.*)+ peut provoquer un backtracking catastrophique
Motifs non bornés : .* sans limites peut ralentir fortement le traitement sur de longues chaînes
Notez que les expressions régulières dans cet outil sont traitées selon le standard ECMAScript (RegExp JavaScript). Cela signifie que le comportement des modèles correspond à celui qu'ils ont dans un navigateur ou dans du code JavaScript. Certains éléments, tels que l'échappement des caractères (/ et /), peuvent se comporter de manière identique, même s'ils apparaissent différemment. Si vous êtes habitué aux expressions régulières dans d'autres langages (par exemple, Python, PHP, .NET ou POSIX), notez qu'il peut y avoir des différences dans la syntaxe et la logique de correspondance.
Cet outil vous permet de tester les expressions régulières (RegEx) et de vérifier leur fonctionnement. Les RegEx sont largement utilisées en programmation, en traitement de données et en analyse SEO.
Avec son aide, vous pouvez rechercher, remplacer et analyser des modèles textuels, simplifiant ainsi le travail avec de grands volumes de données.
Les expressions régulières (regex) sont de puissants outils de correspondance de motifs pour rechercher, valider et manipuler du texte. Elles sont essentielles pour la validation des données, les opérations de recherche et les tâches de traitement de texte.
Notre testeur d'expressions régulières vous permet de saisir des motifs et des chaînes de test pour voir les correspondances en temps réel. Vous pouvez expérimenter différents motifs et voir quelles parties de votre texte correspondent à l'expression.
Les motifs courants incluent la validation d'e-mails, de numéros de téléphone, de dates, d'URL et de codes postaux. Apprenez les métacaractères de base tels que ., *, +, ?, ^, $ et les classes de caractères telles que \d, \w, \s.
Les drapeaux couramment utilisés incluent i (ignorer la casse), g (recherche globale), m (mode multiligne) et u (prise en charge Unicode). Ils aident à contrôler la recherche et la correspondance plus précisément.
Les motifs complexes avec rétroaction peuvent être lents sur de grands textes. Optimisez en étant spécifique, en évitant les quantificateurs imbriqués et en utilisant des ancres (^ et $) si possible. Testez les performances avec des tailles de données réalistes.
Les groupes de capture sont des parties d'une expression régulière (définies par des parenthèses) qui vous permettent d'extraire des sous-sections spécifiques du texte qui correspondent au motif. C'est utile pour reformater ou extraire des données spécifiques.
Un quantificateur 'gourmand' (par exemple, `.*`) essaiera de faire correspondre autant de caractères que possible. Un quantificateur 'paresseux' (par exemple, `.*?`) essaiera de faire correspondre aussi peu de caractères que possible. Le choix dépend du comportement de correspondance souhaité.
La plupart des implémentations modernes d'expressions régulières prennent en charge Unicode, ce qui permet de faire correspondre des caractères dans différentes langues et alphabets. Cependant, la prise en charge exacte peut varier entre les langages de programmation et les outils.
