Regex — Cheatsheet

Syntaxe de base des expressions régulières. Utile en Python, JavaScript, Bash (grep, sed, perl) et la plupart des moteurs compatibles ECMAScript / PCRE.

Ancres

Position dans la chaîne.

Métacaractère	Rôle	Exemple
`^`	Début de ligne / début de chaîne	`^erreur`
`$`	Fin de ligne / fin de chaîne	`erreur$`
`\b`	Limite de mot (bordure ASCII)	`\bword\b`
`\B`	Pas une limite de mot	`\Bword\B`

Classes de caractères simples

Séquence	Équivalent	Sens
`\d`	`[0-9]`	chiffre
`\D`	`[^0-9]`	pas un chiffre
`\w`	`[a-zA-Z0-9_]`	caractère « mot »
`\W`	`[^a-zA-Z0-9_]`	pas un caractère « mot »
`\s`	`[ \t\n\r\f]`	espace blanc
`\S`	`[^ \t\n\r\f]`	pas un espace blanc
`.`	tout sauf `\n`	caractère quelconque

Classes de caractères explicites


[a-z]        # lettres minuscules
[A-Z0-9]     # majuscules + chiffres
[^a-z]       # exclusion : tout sauf minuscules
[abc\-xyz]   # ensemble avec hyphène littéral

Le - perd son sens « plage » s’il est en début ou fin de classe : [a-z0-9] définit deux plages, tandis que [-abc] ou [abc-] inclut un hyphène littéral.

Répétition

Syntaxe	Rôle	Exemple
`*`	0 ou plus	`a*`
`+`	1 ou plus	`a+`
`?`	0 ou 1	`colou?r`
`{n}`	exactement n	`\d{4}`
`{n,}`	au moins n	`[a-z]{2,}`
`{n,m}`	entre n et m	`\d{3,5}`

Par défaut les répétitions sont gourmandes (greedy). Ajouter ? après pour les rendre non-gourmandes : .*?, .+?.

Groupes et capturation


(pat)       # groupe capturant → \1, \2, ...
(pat) (pat) # deux groupes → \1, \2
(?:pat)     # groupe non-capturant (pas de numérotation)
(?P<name>pat)  # groupe nommé (Python uniquement)

Exemple : (colou)r capture colou dans \1 et fait matcher r.

Lookahead et lookbehind

Bases zéro : elles ne consomment aucun caractère.

Syntaxe	Rôle
`(?=exp)`	lookahead positif
`(?!exp)`	lookahead négatif
`(?<=exp)`	lookbehind positif
`(?<!exp)`	lookbehind négatif

Exemples :


\d+(?=€)         # chiffres suivis de €
foo(?!\d)        # "foo" pas suivi d'un chiffre
(?<=\$)\d+       # chiffres après un $
(?<!\d)foo       # "foo" pas précédé d'un chiffre

Les lookbehind posent des contraintes de taille dans certaines implémentations : JavaScript les accepte en longueur variable depuis ES2018, Python via le module regex mais pas via re.

Alternance


a|b      # "a" ou "b"
(foo|bar)|baz   # priorité de gauche à droite

L’alternance s’applique à l’élément le plus proche. Utiliser des parenthèses pour englober plusieurs éléments : (foo|bar|baz)+.

Exemples courants


# Email (validation basique)
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
 
# IP v4
\b(?:\d{1,3}\.){3}\d{1,3}\b
 
# URL courte
https?://[^\s]+
 
# Date YYYY-MM-DD
\b\d{4}-\d{2}-\d{2}\b
 
# Mot de passe fort (≥8 chars, majuscule + minuscule + chiffre)
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$
 
# Couleur hexadécimale
#[0-9a-fA-F]{3,8}

Pannes fréquentes

.* est gourmand par défaut. Préférer .*? dans les cas ambigus.
\b ne fonctionne pas correctement avec les caractères accentués (limite locale ASCII dans la plupart des moteurs).
En JavaScript, \p{...} (propriétés Unicode) nécessite le drapeau u.
Les moteurs diffèrent : Python re est le plus restrictif, Perl/PCRE intermédiaire, JavaScript moderne le plus permissif.
^ et $ dépendent du drapeau « multiline » (m) dans certains contextes — en Python c’est le cas, en JavaScript non (sauf avec m).

Drapeaux (flags)

Drapeau	Nom	Effet
`g`	global	toutes les occurrences
`i`	insensible à la casse	`A` = `a`
`m`	multiline	`^`/`$` matchent début/fin de ligne
`s`	dotall	`.` matche aussi `\n`
`u`	Unicode	support `\p{...}`
`x`	verbose	ignore les espaces non-échappés

Source : documentation officielle des moteurs regex (PCRE, ECMAScript, Python re/regex). Tester ses patterns sur regex101.com avant de les passer en production.