Aide-mémoire regex — tous les tokens avec exemples
Chaque token d’expression régulière avec un exemple fonctionnel, sa prise en charge en JavaScript, PCRE/PHP, Python, Go, Java et .NET, et un lien Essayer qui ouvre le testeur de regex prérempli.
Dernière vérification : 2026-10-18, d’après ECMAScript 2025 (MDN), PCRE2 10.45, Python 3.14 re, Go 1.27 regexp/syntax, Java 25 Pattern et la référence des regex .NET. Sources : MDN regular expressions, PCRE2 pattern syntax, Python re, Go regexp/syntax, Java Pattern, .NET regex quick reference.
Caractères et échappements
La plupart des caractères se trouvent eux-mêmes. Ces douze-là ont un sens spécial et doivent être précédés d’une barre oblique inverse pour être pris littéralement : \ ^ $ . | ? * + ( ) [ { (et ] } à certaines positions).
.N’importe quel caractèreUn seul caractère quelconque, sauf un saut de ligne. Ajoutez le drapeau s (dotAll) pour inclure les sauts de ligne.
/h.t/g
sur “hat hot h t hit h↵t”
trouve “hat” “hot” “h t” “hit”- Python re : Exclut seulement \n ; JavaScript exclut aussi \r, \u2028 et \u2029.
- Go RE2 : Exclut seulement \n.
\. \$ \(Échapper un métacaractèreUne barre oblique inverse rend littéral le caractère spécial qui suit : \. est un vrai point, \$ un signe dollar.
/\$\d+\.\d{2}/g
sur “Total $45.00, tax $3.15, tip 5”
trouve “$45.00” “$3.15”\t \n \rTabulation, saut de ligne, retour chariotLes caractères de contrôle par leur nom. Les fins de ligne Windows sont \r\n ; \r?\n trouve les deux styles.
/\w+\t\w+/g
sur “name⇥age↵ana⇥31”
trouve “name⇥age” “ana⇥31”\xhhCaractère par code hexadécimalExactement deux chiffres hexadécimaux : \x41 est A, \x20 une espace.
/\x41/g
sur “A b A”
trouve “A” “A”\uhhhhCaractère par unité de code UnicodeQuatre chiffres hexadécimaux pour un caractère du plan multilingue de base : \u00e9 est é.
/\u00e9/g
sur “café résumé”
trouve “é” “é” “é”- PCRE / PHP : Utilisez \x{e9}.
- Go RE2 : Utilisez \x{e9}.
\u{1F600}N’importe quel point de code (y compris hors BMP)Point de code entre accolades, nécessaire pour les emoji et les autres caractères au-delà de U+FFFF. JavaScript exige le drapeau u ou v.
/\u{1F600}/gu
sur “Hi 😀 there 😀”
trouve “😀” “😀”- PCRE / PHP : Écrivez \x{1F600} (PHP exige le modificateur u).
- Python re : Écrivez \U0001F600 (huit chiffres hexadécimaux).
- Go RE2 : Écrivez \x{1F600}.
- Java : Écrivez \x{1F600}.
- .NET : Seulement \uhhhh ; un emoji fait deux unités de code UTF-16, par ex. \uD83D\uDE00.
Classes de caractères
Une classe trouve exactement un caractère parmi un ensemble. Entre [ ], la plupart des métacaractères perdent leur sens ; seuls ] \ ^ et - demandent de l’attention.
[abc]L’un des caractèresUn caractère de la liste.
/gr[ae]y/g
sur “gray grey groy”
trouve “gray” “grey”[^abc]Aucun des caractèresUn caractère absent de la liste (un ^ ailleurs qu’en première position est littéral). Trouve aussi les sauts de ligne.
/[^aeiou\s]/g
sur “regex”
trouve “r” “g” “x”[a-z]PlageLes caractères entre deux points de code. Combinez les plages : [A-Fa-f0-9] est un chiffre hexadécimal. Un - en première ou dernière position est littéral.
/[A-Fa-f0-9]+/g
sur “x: 3fA9 zz”
trouve “3fA9”\d \DChiffre / non-chiffre\d est un chiffre, \D tout le reste.
/\d+/g
sur “Order 66, room 101”
trouve “66” “101”- Python re : Dans les motifs str, \d trouve n’importe quel chiffre Unicode (par ex. ٣) ; utilisez re.ASCII pour 0-9 uniquement.
- .NET : Trouve n’importe quel chiffre Unicode, sauf si RegexOptions.ECMAScript est défini.
\w \WCaractère de mot / autreLettres, chiffres et tiret bas. En JavaScript et en Go, cela signifie ASCII uniquement : \w ne trouve pas é.
/\w+/g
sur “snake_case and kebab-case”
trouve “snake_case” “and” “kebab” “case”- PCRE / PHP : ASCII, sauf avec PCRE2_UCP (PHP : modificateur u plus (*UCP)).
- Python re : Lettres et chiffres Unicode par défaut dans les motifs str.
- Java : ASCII, sauf si le drapeau U (UNICODE_CHARACTER_CLASS) est activé.
- .NET : Lettres, chiffres et ponctuation de connexion Unicode.
\s \SEspace blanc / autreEspace, tabulation, sauts de ligne et (dans la plupart des moteurs) les autres espaces Unicode.
/\s+/g
sur “a b⇥c”
trouve “ ” “⇥”- Go RE2 : Espaces blancs ASCII uniquement : \t \n \f \r et l’espace.
[[:alpha:]]Classe POSIX entre crochetsClasses nommées comme [:alpha:], [:digit:], [:space:], [:punct:], utilisées entre crochets.
[[:alpha:]]+- JavaScript : Utilisez [A-Za-z] ou \p{L} avec le drapeau u.
- Java : Utilisez \p{Alpha}, \p{Digit}, \p{Punct}.
[\p{L}--[a-z]]Soustraction / intersection de classesOpérations ensemblistes dans une classe. JavaScript exige le drapeau v (ES2024) : -- soustrait, && fait l’intersection.
/[\p{L}--[a-z]]+/gv
sur “abcÉtéXYZ”
trouve “É” “éXYZ”- PCRE / PHP : PCRE2 10.45+ uniquement, avec la syntaxe de classe étendue (?[ … ]).
- Java : Intersection [a-z&&[^aeiou]] ; la soustraction s’écrit comme une intersection avec une négation.
- .NET : Soustraction [a-z-[aeiou]] ; pas d’intersection.
Ancres et limites
Les ancres correspondent à une position, pas à un caractère : elles ne consomment donc jamais de texte.
^ $Début / fin de la chaîne (ou de la ligne avec m)Sans le drapeau m, ^ et $ désignent le début et la fin de toute l’entrée ; avec lui, ceux de chaque ligne.
/^\w+/gm
sur “first line↵second line”
trouve “first” “second”- PCRE / PHP : $ correspond aussi juste avant un \n final.
- Python re : $ correspond aussi juste avant un \n final.
- Java : $ correspond aussi juste avant un terminateur de ligne final.
- .NET : $ correspond aussi juste avant un \n final.
\bLimite de motEntre un caractère de mot et un autre caractère (ou le bord de l’entrée). Sert à trouver des mots entiers.
/\bcat\b/g
sur “cat concat cats cat.”
trouve “cat” “cat”- JavaScript : Caractères de mot ASCII uniquement, même avec le drapeau u.
- Go RE2 : Caractères de mot ASCII uniquement.
\BPas une limite de motÀ l’intérieur d’un mot, par ex. « cat » uniquement s’il fait partie d’un mot plus long.
/\Bcat/g
sur “concat cat bobcat”
trouve “cat” “cat”\A \z \ZDébut / fin absolusDébut et fin de l’entrée, quel que soit le mode multiligne. \Z autorise aussi un saut de ligne final (sauf en Python, où c’est un synonyme de \z).
\A\d+\z- JavaScript : Utilisez ^ et $ sans le drapeau m.
- Python re : \A et \z (3.14+) ; \Z désigne la fin absolue, comme \z ailleurs.
- Go RE2 : \A et \z ; pas de \Z.
\GFin de la correspondance précédenteLa position où s’est terminée la dernière correspondance ; sert à trouver des suites contiguës.
\G\d- JavaScript : Pas de \G ; le drapeau y (sticky) donne le même comportement « commencer exactement ici ».
Quantificateurs : gourmands, paresseux, possessifs
Un quantificateur répète l’élément qui le précède. Le mode gourmand (par défaut) prend le plus possible puis recule ; le mode paresseux (ajoutez ?) prend le moins possible ; le mode possessif (ajoutez +) ne recule jamais.
*Zéro ou plusRépéter de 0 à un nombre illimité de fois.
/ba*/g
sur “b ba baaa”
trouve “b” “ba” “baaa”+Un ou plusRépéter de 1 à un nombre illimité de fois.
/lo+l/g
sur “lol loool ll”
trouve “lol” “loool”?FacultatifZéro ou une fois.
/colou?r/g
sur “color colour colouur”
trouve “color” “colour”{n}Exactement nExactement n répétitions.
/\d{3}/g
sur “12 345 6789”
trouve “345” “678”{n,}n ou plusAu moins n répétitions.
/\d{2,}/g
sur “1 22 333”
trouve “22” “333”{n,m}Entre n et mDe n à m répétitions, le plus possible.
/\d{2,3}/g
sur “1 22 4444”
trouve “22” “444”- Go RE2 : Les nombres supérieurs à 1000 sont refusés.
{,m}Jusqu’à mDe zéro à m répétitions. Seuls certains moteurs l’acceptent ; ailleurs, c’est un texte littéral « {,m} » ou une erreur. {0,m} fonctionne partout.
\d{,3}- JavaScript : Texte littéral sans u, erreur de syntaxe avec u ; écrivez {0,3}.
- PCRE / PHP : PCRE2 10.43+ uniquement.
- Go RE2 : Écrivez {0,3}.
- Java : Écrivez {0,3}.
- .NET : Traité comme du texte littéral ; écrivez {0,3}.
.* .+Gourmand (par défaut)Prend la correspondance la plus longue possible, puis rend des caractères jusqu’à ce que la suite corresponde. Ici, il avale les deux balises.
/<.+>/g
sur “<b>bold</b>”
trouve “<b>bold</b>”*? +? ?? {n,m}?Paresseux (non gourmand)Prend la correspondance la plus courte possible. C’est généralement la solution quand un motif « en prend trop ».
/<.+?>/g
sur “<b>bold</b>”
trouve “<b>” “</b>”- Go RE2 : Aussi disponible avec le drapeau U, qui inverse gourmand et paresseux.
*+ ++ ?+PossessifGourmand sans retour arrière : une fois trouvés, les caractères ne sont jamais rendus. L’échec est plus rapide, et c’est une protection contre le retour arrière catastrophique.
"[^"]*+"- JavaScript : Pas de quantificateurs possessifs ni de groupes atomiques ; à émuler avec (?=(…))\1.
- Python re : Python 3.11+.
- Go RE2 : Inutile : RE2 ne fait jamais de retour arrière.
- .NET : Utilisez un groupe atomique (?>…).
Groupes et références arrière
Les parenthèses regroupent des éléments pour les quantificateurs et l’alternative et (sauf s’ils sont marqués non capturants) mémorisent ce qu’ils ont trouvé.
( … )Groupe capturantRegroupe et capture ; numéroté à partir de 1 selon l’ordre des parenthèses ouvrantes.
/(\d{3})-(\d{4})/g
sur “Call 555-0199 or 555-0123”
trouve “555-0199” “555-0123”(?: … )Groupe non capturantRegroupe sans mémoriser : les numéros de groupe restent stables et la recherche est un peu moins coûteuse.
/(?:ab)+/g
sur “ababab ab a”
trouve “ababab” “ab”(?<name> … )Groupe nomméCapture sous un nom que vous pouvez relire (match.groups.name en JavaScript).
/(?<year>\d{4})-(?<month>\d{2})/g
sur “Released 2026-10”
trouve “2026-10”- PCRE / PHP : Aussi (?'name'…) et (?P<name>…).
- Python re : Seulement (?P<name>…).
- Go RE2 : (?P<name>…) ; (?<name>…) est aussi accepté depuis Go 1.22.
- .NET : Aussi (?'name'…).
\1Référence arrière par numéroTrouve le même texte que celui capturé auparavant par un groupe.
/(\w)\1/g
sur “bookkeeper”
trouve “oo” “kk” “ee”- Go RE2 : RE2 n’a pas de références arrière (elles casseraient sa garantie de temps linéaire).
\k<name>Référence arrière par nomComme \1, mais par nom. L’exemple trouve un texte entre guillemets identiques.
/(?<q>['"]).*?\k<q>/g
sur “say "hi" or 'yo'”
trouve “"hi"” “'yo'”- PCRE / PHP : Aussi \k{name}, \g{name} et (?P=name).
- Python re : Écrivez (?P=name).
a|bAlternative (ou)L’un ou l’autre côté. Les alternatives sont essayées de gauche à droite : placez les plus longues en premier quand l’une est le préfixe d’une autre.
/cat|dog/g
sur “hotdog catalog”
trouve “dog” “cat”(?> … )Groupe atomiqueUne fois le groupe trouvé, le moteur ne revient plus en arrière à l’intérieur.
(?>a|ab)c- Python re : Python 3.11+.
- Go RE2 : Inutile : RE2 ne fait jamais de retour arrière.
(?i) (?i: … )Drapeaux en ligneActivent ou désactivent des drapeaux à l’intérieur du motif. (?i) s’applique au reste du motif ; (?i:…) uniquement au groupe ; (?-i:…) désactive un drapeau.
/(?i:hello) world/g
sur “HELLO world HELLO WORLD”
trouve “HELLO world”- JavaScript : Seulement la forme limitée à un groupe (?i:…) / (?-i:…), pour i, m et s (ES2025). (?i) au début est une erreur de syntaxe.
- Python re : Le (?i) global doit se trouver tout au début du motif (erreur ailleurs depuis 3.11) ; (?i:…) fonctionne partout.
(?(1)yes|no)ConditionTrouve « yes » si le groupe 1 a participé, sinon « no ».
(<)?\w+(?(1)>)(?R) (?1)Récursion / sous-routineRappelle le motif entier ou un groupe, pour les structures imbriquées comme les parenthèses équilibrées.
\((?:[^()]|(?R))*\)- Python re : Disponible dans le module tiers regex.
- .NET : Pas de récursion ; les groupes d’équilibrage (?<open-close>…) gèrent l’imbrication.
(?# … )Commentaire en ligneIgnoré par le moteur. Pour des commentaires plus longs, utilisez le drapeau x (étendu).
\d{3}(?#area code)Lookahead et lookbehind (assertions avant et arrière)
Les assertions de voisinage vérifient ce qui entoure la position courante sans l’inclure dans la correspondance. Elles ont une largeur nulle, comme les ancres.
(?= … )Lookahead positifSuivi de … (non inclus dans la correspondance).
/\d+(?=px)/g
sur “10px 20em 30px”
trouve “10” “30”- Go RE2 : RE2 n’a aucune assertion de voisinage.
(?! … )Lookahead négatifNon suivi de …. Le \d à l’intérieur empêche le moteur de rendre des chiffres pour faire réussir le test.
/\d+(?!px|\d)/g
sur “10px 20em”
trouve “20”(?<= … )Lookbehind positifPrécédé de … (non inclus dans la correspondance).
/(?<=\$)\d+(?:\.\d\d)?/g
sur “Cost: $42.50 or 42”
trouve “42.50”- JavaScript : Longueur quelconque (ES2018).
- PCRE / PHP : Chaque alternative doit avoir une longueur bornée ; longueur variable (255 max. par défaut) depuis PCRE2 10.43.
- Python re : Largeur fixe uniquement : (?<=ab|cd) fonctionne, (?<=a+) est une erreur.
- Java : Longueur bornée uniquement : pas de * ni de + à l’intérieur.
- .NET : Longueur quelconque.
(?<! … )Lookbehind négatifNon précédé de ….
/(?<!\$)\b\d+\b/g
sur “$30 and 45”
trouve “45”- PCRE / PHP : Mêmes règles de longueur que le lookbehind positif.
- Python re : Largeur fixe uniquement.
- Java : Longueur bornée uniquement.
\KRéinitialiser le début de la correspondanceRetire du résultat tout ce qui a été trouvé jusque-là ; un lookbehind sans limite de longueur.
price: \K\d+- JavaScript : Utilisez (?<=…) ou un groupe capturant.
Drapeaux (modificateurs)
JavaScript écrit les drapeaux après la barre oblique fermante (/x/gi). Les autres langages passent des constantes (re.I, Pattern.CASE_INSENSITIVE, RegexOptions.IgnoreCase) ou utilisent (?i) en ligne.
gGlobal (toutes les correspondances)Trouve toutes les correspondances au lieu de s’arrêter à la première. Obligatoire pour matchAll et replaceAll.
/o/g
sur “foo boo”
trouve “o” “o” “o” “o”- PCRE / PHP : Pas de drapeau : utilisez preg_match_all() / preg_replace().
- Python re : Pas de drapeau : utilisez re.findall(), re.finditer(), re.sub().
- Go RE2 : Pas de drapeau : utilisez les méthodes FindAll….
- Java : Pas de drapeau : bouclez avec matcher.find().
- .NET : Pas de drapeau : utilisez Regex.Matches().
iIgnorer la casseRecherche insensible à la casse.
/hello/gi
sur “Hello HELLO hello”
trouve “Hello” “HELLO” “hello”- Python re : re.I / re.IGNORECASE ou (?i).
- Java : CASE_INSENSITIVE (ASCII sauf avec UNICODE_CASE) ou (?i).
- .NET : RegexOptions.IgnoreCase ou (?i).
mMultiligne^ et $ correspondent au début et à la fin de chaque ligne, pas seulement aux extrémités de l’entrée.
/^-\s.+$/gm
sur “- one↵- two↵three”
trouve “- one” “- two”- Python re : re.M / re.MULTILINE.
- .NET : RegexOptions.Multiline.
sLe point inclut le saut de ligneFait aussi correspondre . aux sauts de ligne. Sans lui, [\s\S] est le « n’importe quoi » portable.
/<p>.*?</p>/gs
sur “<p>a↵b</p>”
trouve “<p>a↵b</p>”- Python re : re.S / re.DOTALL.
- Java : Pattern.DOTALL.
- .NET : Appelé RegexOptions.Singleline.
xÉtendu (espacement libre)Les espaces du motif sont ignorés et # commence un commentaire : les longs motifs peuvent ainsi s’étaler sur plusieurs lignes.
(?x) \d{3} - \d{4} # local number- Python re : re.X / re.VERBOSE.
- Java : Pattern.COMMENTS.
- .NET : RegexOptions.IgnorePatternWhitespace.
uUnicodeTraite l’entrée comme des points de code (. trouve donc un emoji entier), active \p{…} et \u{…}, et transforme les échappements invalides en erreurs.
/^.$/gu
sur “😀”
trouve “😀”- PCRE / PHP : Modificateur u de PHP (mode UTF-8) ; ajoutez (*UCP) pour \w et \d en Unicode.
- Python re : Aucun drapeau nécessaire : les motifs str sont en Unicode ; re.ASCII permet de s’en passer.
- Go RE2 : Pas de drapeau : Go travaille toujours sur des points de code UTF-8.
- Java : UNICODE_CASE et UNICODE_CHARACTER_CLASS (U).
- .NET : Pas de drapeau : toujours des unités de code UTF-16 (un emoji en compte deux).
vEnsembles UnicodeVersion améliorée de u (ES2024) : opérations ensemblistes sur les classes (--, &&), classes imbriquées et propriétés de chaînes comme \p{RGI_Emoji}. Ne peut pas être combiné avec u.
/[\p{L}&&\p{ASCII}]+/gv
sur “Ünïcode text”
trouve “n” “code” “text”ySticky (ancré)Chaque correspondance doit commencer exactement là où la précédente s’est terminée (lastIndex). Utile pour les analyseurs lexicaux.
/\d/gy
sur “12a3”
trouve “1” “2”- PCRE / PHP : Utilisez \G.
- Python re : Utilisez pattern.match(text, pos).
- Java : Utilisez \G ou matcher.lookingAt().
- .NET : Utilisez \G.
dIndices de correspondanceAjoute match.indices avec le début et la fin de chaque groupe capturant (ES2022).
/(?<y>\d{4})/d- PCRE / PHP : Positions toujours disponibles (PREG_OFFSET_CAPTURE).
- Python re : Toujours disponible : m.span(n).
- Go RE2 : Toujours disponible : FindStringSubmatchIndex.
- Java : Toujours disponible : matcher.start(n) / end(n).
- .NET : Toujours disponible : Group.Index / Length.
Propriétés Unicode \p{…}
Les échappements de propriété trouvent des caractères selon leur catégorie ou leur écriture Unicode : c’est le seul moyen fiable de trouver « n’importe quelle lettre » dans toutes les langues. En JavaScript, ils exigent le drapeau u ou v.
\p{L}N’importe quelle lettreLes lettres de toutes les écritures : é, ß, 東, д.
/\p{L}+/gu
sur “naïve café 東京 123”
trouve “naïve” “café” “東京”- PCRE / PHP : PHP exige le modificateur u pour une entrée UTF-8.
- Python re : Utilisez le module tiers regex, ou [^\W\d_] pour « lettres ».
\p{Lu} \p{Ll}Lettre majuscule / minusculeCatégories générales : Lu majuscule, Ll minuscule, N nombre, P ponctuation, S symbole, Z séparateur.
/\p{Lu}/gu
sur “Élan Vital”
trouve “É” “V”\P{…}Hors propriétéLe P majuscule inverse : \P{L} est tout ce qui n’est pas une lettre.
/\P{L}+/gu
sur “abc-123”
trouve “-123”\pLAbréviation d’une lettreCatégories d’une seule lettre, sans accolades.
\pL+- JavaScript : Les accolades sont obligatoires : \p{L}.
- .NET : Les accolades sont obligatoires : \p{L}.
\p{Script=Greek}ÉcritureLes caractères d’un système d’écriture. sc= est la forme courte ; Script_Extensions (scx=) inclut aussi les caractères partagés entre plusieurs écritures.
/\p{Script=Greek}+/gu
sur “alpha α, beta β”
trouve “α” “β”- PCRE / PHP : \p{Greek}, \p{sc:Greek} ou \p{scx:Greek}.
- Go RE2 : \p{Greek}.
- Java : Écrivez \p{script=Greek}, \p{sc=Greek} ou \p{IsGreek}.
- .NET : Seulement des blocs nommés comme \p{IsGreek} (une plage de codes, pas l’écriture).
\p{sc=Han}Sinogrammes chinois / kanji japonaisIdéogrammes Han. Pour les kana japonais, ajoutez \p{sc=Hiragana} et \p{sc=Katakana}.
/\p{sc=Han}+/gu
sur “Tokyo 東京 2026 中文”
trouve “東京” “中文”- PCRE / PHP : \p{Han}.
- Python re : Utilisez une plage comme [\u4e00-\u9fff] (couvre seulement le bloc principal).
- Go RE2 : \p{Han}.
- Java : Aussi \p{IsHan}.
- .NET : Blocs uniquement, par ex. \p{IsCJKUnifiedIdeographs}.
\p{RGI_Emoji}Emoji (séquences complètes)Avec le drapeau v, trouve des emoji complets, y compris les couleurs de peau et les séquences de famille. Avec u, \p{Extended_Pictographic} ne trouve que des pictogrammes isolés.
/\p{RGI_Emoji}/gv
sur “Go 👍🏽 team 👨👩👧!”
trouve “👍🏽” “👨👩👧”- PCRE / PHP : Points de code isolés via les propriétés booléennes des versions récentes de PCRE2 (10.40+) ; pas de propriété de séquence.
- Java : \p{IsEmoji} trouve des points de code isolés (Java 21+).
\XGraphèmeUn caractère tel que l’utilisateur le perçoit, par ex. e + accent combinant, ou un emoji de drapeau.
\X- JavaScript : Utilisez Intl.Segmenter pour découper en graphèmes.
- Python re : Disponible dans le module regex.
Syntaxe de substitution (remplacement)
Ce qu’il faut taper dans la chaîne de remplacement. C’est là que les langages diffèrent le plus : la colonne de votre langage compte davantage que l’exemple JavaScript.
$&Correspondance entièreInsère tout le texte trouvé.
/\d+/g
sur “3 apples, 12 pears”
remplacer par “[$&]” → “[3] apples, [12] pears”- PCRE / PHP : $0 ou \0 dans preg_replace.
- Python re : \g<0>.
- Go RE2 : ${0} ou $0 (Expand / ReplaceAllString).
- Java : $0.
- .NET : Aussi $0.
$1Groupe numérotéInsère ce que le groupe 1 a capturé. Pour inverser deux mots :
/(\w+)\s(\w+)/g
sur “hello world”
remplacer par “$2 $1” → “world hello”- PCRE / PHP : Aussi \1 et ${1}.
- Python re : \1 ou \g<1> (utilisez une chaîne brute r"\1").
- Go RE2 : Utilisez ${1}x quand une lettre ou un chiffre suit, sinon Go lit $1x comme un groupe nommé « 1x ».
$<name>Groupe nomméInsère un groupe nommé. Pour reformater une date ISO en jour/mois/année :
/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/g
sur “2026-10-18”
remplacer par “$<d>/$<m>/$<y>” → “18/10/2026”- PCRE / PHP : preg_replace n’a pas de références nommées ; utilisez le numéro du groupe ou preg_replace_callback().
- Python re : \g<name>.
- Go RE2 : ${name} (ou $name).
- Java : ${name}.
- .NET : ${name}.
$$Signe dollar littéralÉchappe $ dans le remplacement.
/(\d+)/g
sur “Price: 20”
remplacer par “$$$1” → “Price: $20”- PCRE / PHP : Un $ qui n’est pas suivi d’un chiffre ou de { est déjà littéral ; écrivez ${1} après.
- Python re : $ n’est pas spécial ; échappez les barres obliques inverses en \\.
- Java : \$ (Matcher.quoteReplacement() échappe une chaîne entière).
$` $'Texte avant / après la correspondanceInsère l’entrée située avant ou après la correspondance. Rarement nécessaire, mais parfois pratique.
/=/
sur “key=value”
remplacer par “ is set ($') and was ($`) ” → “key is set (value) and was (key) value”Recettes courantes (avec leurs limites, honnêtement)
Les motifs les plus recherchés, écrits pour être lisibles et à l’abri du retour arrière catastrophique. Chacun précise ce qu’il ne fait pas.
Email (practical)Trouver des chaînes ressemblant à des e-mailsPartie locale, @ et un domaine contenant au moins un point.
/[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g
sur “Write to ana.lee+news@example.co.uk or bob@test.dev.”
trouve “ana.lee+news@example.co.uk” “bob@test.dev”Limite : Refuse des adresses valides mais rares (parties locales entre guillemets, domaines non ASCII) et accepte certaines adresses invalides (a..b@x.y). Aucune regex ne peut vous dire si une boîte aux lettres existe : envoyez un e-mail de confirmation.
URLTrouver des liens http(s) dans un texteS’arrête aux espaces, aux guillemets et aux chevrons, et laisse de côté la ponctuation finale comme un point ou une virgule.
/https?://[^\s<>"]*[^\s<>".,;:!?)]/g
sur “See https://example.com/a?b=1, or (http://test.dev/x).”
trouve “https://example.com/a?b=1” “http://test.dev/x”Limite : Bien pour transformer un texte en liens, pas pour valider. Pour vérifier une URL, utilisez l’analyseur d’URL de votre langage (new URL() en JavaScript) et testez son protocole et son hôte.
IPv4 addressQuatre octets de 0 à 255Chaque octet est limité à 0–255, sans zéro initial.
/\b(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}\b/g
sur “10.0.0.1 256.1.1.1 192.168.1.254”
trouve “10.0.0.1” “192.168.1.254”Limite : Ne gère ni l’IPv6, ni les suffixes CIDR, ni les ports. Pour valider, utilisez un analyseur d’adresses IP (Python ipaddress, Go net/netip, Node net.isIP).
Date YYYY-MM-DDDate calendaire ISO 8601Mois de 01 à 12 et jour de 01 à 31.
/\b\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])\b/g
sur “2026-10-18, 2026-13-01, 2026-02-31”
trouve “2026-10-18” “2026-02-31”Limite : Vérifie seulement la forme : 2026-02-31 passe. Analysez la date avec une bibliothèque de dates pour refuser les jours impossibles.
Date MM/DD/YYYYDate au format américainMois et jour sur un ou deux chiffres, année sur quatre chiffres.
/\b(?:0?[1-9]|1[0-2])/(?:0?[1-9]|[12]\d|3[01])/\d{4}\b/g
sur “Due 10/18/2026 or 1/5/2027, not 13/01/2026”
trouve “10/18/2026” “1/5/2027”Limite : 01/02/2026 est le 2 janvier aux États-Unis et le 1er février presque partout ailleurs ; une regex ne peut pas savoir ce qui était voulu.
Phone (North America)(416) 555-0199 et variantesDix chiffres avec parenthèses, espaces, points ou tirets facultatifs.
/\(?\b\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g
sur “(416) 555-0199, 416.555.0199, 4165550199”
trouve “(416) 555-0199” “416.555.0199” “4165550199”Limite : Numéros nord-américains uniquement. Pour les numéros internationaux, utilisez une bibliothèque comme libphonenumber ; stockez les numéros au format E.164 (ligne suivante).
Phone (E.164)Format international +CC…Un signe plus, un indicatif de pays qui ne commence pas par 0, 15 chiffres au maximum au total.
/^\+[1-9]\d{1,14}$/gm
sur “+14165550199↵+447911123456↵0044791112”
trouve “+14165550199” “+447911123456”Limite : Vérifie la forme E.164, pas si le numéro est attribué ni s’il a la bonne longueur pour son pays.
Hex colour#rgb, #rgba, #rrggbb, #rrggbbaaLes quatre longueurs acceptées par CSS.
/#(?:[\da-fA-F]{8}|[\da-fA-F]{6}|[\da-fA-F]{3,4})\b/g
sur “#fff #244b3f #12345 #ff000080 #1234567”
trouve “#fff” “#244b3f” “#ff000080”Limite : Trouve aussi des correspondances dans un texte plus long, comme des URL avec des #fragments ; ancrez avec ^…$ pour valider une valeur isolée.
URL slugmots-en-minuscules-avec-traits-d-unionLettres minuscules et chiffres séparés par un seul trait d’union.
/^[a-z0-9]+(?:-[a-z0-9]+)*$/gm
sur “my-post-2026↵My Post↵-bad-↵good”
trouve “my-post-2026” “good”Limite : ASCII uniquement. Pour créer des slugs à partir de titres, utilisez le générateur de slug d’URL plutôt qu’une regex.
Trim whitespaceEspaces en début et en finRemplacez par une chaîne vide. Sans le drapeau m, ^ et $ désignent les extrémités du texte entier.
/^\s+|\s+$/g
sur “ padded text ”
remplacer par “” → “padded text”Limite : Tous les langages modernes ont une fonction trim() intégrée, plus rapide et plus claire ; n’utilisez la regex que là où vous ne pouvez pas appeler de code (éditeurs, fichiers de configuration).
Collapse spacesPlusieurs espaces réduites à uneRemplace deux espaces ou tabulations ou plus par une seule espace.
/[ \t]{2,}/g
sur “too many ⇥ spaces”
remplacer par “ ” → “too many spaces”Duplicate wordsle le, est estUn mot suivi de lui-même. Avec i, « Le le » est aussi détecté.
/\b(\w+)\s+\1\b/gi
sur “This is is a test test of The the editor”
trouve “is is” “test test” “The the”Limite : Nécessite des références arrière : ne fonctionne donc pas en Go. Certaines répétitions sont correctes (« nous nous », « vous vous »).
Password rulesMinuscule, majuscule, chiffre, 12 caractères ou plusChaque lookahead vérifie une règle depuis le début ; .{12,} fixe la longueur.
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{12,}$/gm
sur “short1A↵alllowercase123↵GoodPassword42”
trouve “GoodPassword42”Limite : La norme NIST SP 800-63B déconseille les règles de composition : exigez plutôt une longueur minimale et vérifiez le mot de passe dans des listes de mots de passe compromis.
UUID8-4-4-4-12 hexadécimauxVersions 1 à 8 avec les bits de variante RFC 9562.
/\b[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi
sur “id 3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b and 00000000-0000-0000-0000-000000000000”
trouve “3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b”Limite : Refuse l’UUID nul (que des zéros) et l’UUID max (que des f), qui sont des valeurs spéciales valides.
Une référence statique : la recherche et le filtrage se font dans votre navigateur, et les liens « L’essayer » ouvrent notre testeur de regex qui fonctionne lui aussi dans le navigateur. Parcourir tous les outils gratuits.
Un problème, ou quelque chose à améliorer ? Nous lisons chaque message et corrigeons vite.
Cet aide-mémoire regex liste tous les tokens d’expressions régulières dont vous aurez probablement besoin, de \d et \b au lookbehind, aux quantificateurs possessifs et à \p{Script=Greek}, chacun avec une courte explication et un exemple qui montre exactement ce qu’il trouve. Chaque exemple a un lien Essayer qui ouvre notre testeur de regex avec le motif, les drapeaux et le texte d’exemple déjà remplis : modifiez-le et regardez les correspondances bouger.
Les regex se ressemblent partout, mais ne sont pas identiques. Le lookbehind est illimité en JavaScript et .NET, de largeur fixe en Python, borné en Java et PCRE, et absent en Go. Python écrit les groupes nommés (?P<name>…), PHP ne peut pas utiliser de noms dans un remplacement, et seuls certains moteurs connaissent \A, \K ou (?R). Le sélecteur de variante montre la prise en charge de chaque token en JavaScript, PCRE/PHP, Python, Go, Java et .NET, avec la syntaxe alternative quand elle existe. Les exemples eux-mêmes s’exécutent en JavaScript ; pour les autres langages, lisez les notes et testez dans le langage concerné avant de mettre en production.
Mode d’emploi
- Cherchez un token (\b, lookahead) ou une tâche (e-mail, trim, mots en double), ou accédez à une section grâce aux puces en haut.
- Choisissez votre langage dans la barre des variantes. Les tokens qu’il ne gère pas sont grisés, et la note sous chaque entrée indique la syntaxe que votre langage utilise à la place.
- Cliquez sur Essayer dans le testeur de regex pour exécuter l’exemple en direct, puis modifiez-y le motif ou le texte.
- Utilisez le # à côté d’une entrée pour créer un lien direct vers elle, ou Imprimer / Enregistrer en PDF pour une version compacte sur deux colonnes.
Questions fréquentes
Quelle est la différence entre quantificateurs gourmands et paresseux ?
Un quantificateur gourmand (*, +, {n,m}) prend autant de caractères que possible, puis en rend certains si la suite du motif échoue ; un quantificateur paresseux (*?, +?, {n,m}?) en prend le moins possible. Sur <b>bold</b>, <.+> trouve toute la chaîne alors que <.+?> trouve <b> et </b> séparément. Les quantificateurs possessifs (*+, ++) sont gourmands et ne rendent jamais de caractères ; JavaScript, Go et .NET n’en ont pas.
Quels langages prennent en charge le lookbehind ?
JavaScript (depuis ES2018) et .NET autorisent un lookbehind de longueur quelconque. Java exige une longueur maximale bornée, donc pas de * ni de + à l’intérieur. Le module re de Python n’accepte que le lookbehind de largeur fixe. PCRE2 exigeait une longueur fixe pour chaque alternative jusqu’à la version 10.43, qui a ajouté le lookbehind de longueur variable jusqu’à une limite (255 caractères par défaut). Le moteur RE2 de Go n’a ni lookahead ni lookbehind.
Comment trouver n’importe quelle lettre, y compris accentuée ou non latine ?
Utilisez la propriété Unicode \p{L}. En JavaScript, elle nécessite le drapeau u ou v (/\p{L}+/u) ; PCRE, Go, Java et .NET la prennent en charge directement. [a-zA-Z] rate é, ß et toutes les écritures non latines, et \w se limite à l’ASCII en JavaScript et en Go. Le module re intégré de Python n’a pas de \p{…} ; utilisez le module tiers regex, ou [^\W\d_], qui en Python 3 trouve les lettres Unicode.
Comment utiliser un groupe capturé dans le remplacement ?
Cela dépend du langage : $1 en JavaScript, Java, .NET, Go et PHP ; \1 ou \g<1> en Python. Les groupes nommés s’écrivent $<name> en JavaScript, ${name} en Java, .NET et Go, et \g<name> en Python ; preg_replace de PHP n’a pas de forme nommée, utilisez donc le numéro. La correspondance entière s’écrit $& en JavaScript et .NET, $0 en Java et PHP, et \g<0> en Python.
Pourquoi ma regex fonctionne-t-elle en JavaScript mais pas en Python (ou l’inverse) ?
Les coupables habituels : les groupes nommés ((?<name>) en JavaScript, (?P<name>) en Python), les propriétés \p{…} (oui en JavaScript, non dans le re de Python), la longueur du lookbehind (quelconque en JavaScript, fixe en Python), les drapeaux inline ((?i) au début fonctionne en Python mais provoque une erreur en JavaScript, qui n’a que la forme à portée limitée (?i:…)), et \d ou \w qui trouvent les chiffres et lettres Unicode en Python mais seulement l’ASCII en JavaScript. Pensez aussi à l’échappement des chaînes Python : écrivez les motifs en chaînes brutes, r"\d+".
Peut-on valider des adresses e-mail avec une regex ?
Seulement pour vérifier leur forme. Un motif pratique comme [\w.+-]+@[\w-]+(?:\.[\w-]+)+ repère les fautes de frappe, mais il rejette certaines adresses valides (parties locales entre guillemets, domaines internationalisés) et en accepte certaines invalides. Aucun motif ne peut vous dire qu’une boîte aux lettres existe : vérifiez la forme de façon souple, puis envoyez un e-mail de confirmation.
Écrire des motifs qui fonctionnent dans plusieurs langages
Si un motif doit tourner dans plusieurs moteurs (une règle de validation partagée, un fichier de configuration lu par des services écrits dans différents langages), restez dans le sous-ensemble commun. Ces éléments se comportent de la même façon dans les six moteurs de cette page :
• Les caractères littéraux, les échappements comme \. et \$, et les classes [abc], [^abc] et [a-z].
• \d, \s et \w, tant que votre entrée est en ASCII (Python et .NET trouvent aussi les chiffres et lettres Unicode).
• ^ et $, \b, l’alternative, les groupes capturants et non capturants.
• Les quantificateurs gourmands et paresseux : *, +, ?, {n}, {n,m} et leurs formes avec ?.
Évitez les assertions (Go n’en a aucune), les références arrière (Go), les quantificateurs possessifs et les groupes atomiques (JavaScript, Go et .NET n’ont pas l’un ou les deux), les groupes nommés (la syntaxe de Python diffère) et \p{…} (absent du re de Python). Quand vous en avez besoin, gardez une copie du motif par langage et testez chacune.
Éviter le backtracking catastrophique
Les moteurs à retour arrière (JavaScript, PCRE, Python, Java, .NET) peuvent prendre un temps exponentiel sur les motifs où un groupe quantifié peut trouver le même texte de nombreuses façons, comme (a+)+$ ou (\w|\d)*x. Sur une longue entrée qui correspond presque, le moteur essaie tous les découpages avant d’échouer, et un serveur web peut se bloquer sur une seule requête. C’est le problème de déni de service par expression régulière (ReDoS).
Les corrections sont mécaniques : évitez d’imbriquer des quantificateurs sur les mêmes caractères ; rendez les alternatives mutuellement exclusives ; préférez une classe négative comme [^"]* à .*? quand vous connaissez le délimiteur ; utilisez des quantificateurs possessifs ou des groupes atomiques si votre moteur en dispose ; et limitez la longueur de l’entrée avant la recherche. .NET propose aussi RegexOptions.NonBacktracking et un délai de recherche, PCRE a des limites de correspondance configurables, et le moteur RE2 de Go garantit un temps linéaire en ne prenant pas en charge les fonctionnalités qui nécessitent un retour arrière.
Échapper une regex dans une chaîne
La plupart des bugs de regex dans du vrai code sont des bugs d’échappement de chaînes, pas des bugs de regex. La barre oblique inverse est spéciale à la fois pour les chaînes littérales du langage et pour le moteur de regex : un motif écrit dans une chaîne normale nécessite des barres obliques inverses doublées.
• JavaScript : un littéral /\d+/ n’a besoin que d’une barre oblique inverse ; new RegExp("\\d+") en a besoin de deux. String.raw`\d+` évite le doublement.
• Python : utilisez toujours des chaînes brutes, r"\d+" ; sinon "\b" est un caractère retour arrière, pas une limite de mot.
• Java et C# : "\\d+" dans les chaînes ordinaires (les blocs de texte Java traitent aussi les échappements) ; les chaînes verbatim de C#, @"\d+", conservent les barres obliques inverses telles quelles.
• Go : les chaînes brutes entre accents graves, `\d+`, sont la norme avec regexp.MustCompile.
• PHP : les motifs incluent des délimiteurs, '/\d+/', et les chaînes entre apostrophes conservent la plupart des barres obliques inverses telles quelles.
Outils gratuits similaires
- Testeur de regex — Testez une expression régulière sur un texte d’exemple avec surlignage des correspondances en direct, groupes de capture et aperçu du remplacement. Gratuit, dans votre navigateur.
- Aide-mémoire Git — Les commandes Git classées selon ce que vous voulez faire : annuler le dernier commit, renommer une branche, supprimer une branche distante. switch/restore modernes avec leurs équivalents classiques et badges de danger.
- Aide-mémoire Markdown — Chaque élément Markdown avec sa source et son rendu, la syntaxe étendue (tableaux, listes de tâches, notes de bas de page, maths, Mermaid, alertes), un tableau de compatibilité sur 9 plateformes et un bac à sable en direct.
- Générateur d’expressions cron — Créez une planification cron avec des menus ou collez-en une, lisez-la en langage clair et voyez les 10 prochaines exécutions dans votre fuseau et en UTC. Gratuit, dans le navigateur.
- Comparateur de texte — Comparez deux versions d’un texte, d’un code ou d’un fichier JSON et voyez exactement quelles lignes, quels mots et quels caractères ont changé.