"Cheatsheet regex : 20 patterns prêts à l'emploi pour les problèmes du quotidien"

La cheatsheet regex que tu vas vraiment garder sous la main

Personne ne mémorise les expressions régulières. Même les devs qui en écrivent chaque semaine gardent en tête une dizaine de constructions et cherchent le reste. Et c'est normal : la regex est une compétence de consultation, pas de mémorisation.

Cette cheatsheet couvre deux choses : la syntaxe de base dont tu as besoin pour lire n'importe quel pattern, et 20 patterns éprouvés pour les problèmes qui reviennent tout le temps. Colle n'importe lequel dans un Regex Tester pour voir les correspondances surlignées en direct avant de lui faire confiance dans ton code.

Le rappel de syntaxe en 60 secondes

Quatre briques suffisent à expliquer 90 % des regex que tu croiseras.

Classes de caractères — quoi matcher

Quantificateurs — combien de fois

Ancres — où ça matche

^ début de chaîne, $ fin de chaîne, \b frontière de mot. Oublier les ancres est la cause n°1 des « ma regex de validation accepte n'importe quoi » : \d{4} matche tranquillement à l'intérieur de abc12345xyz. Pour valider une chaîne entière, écris ^\d{4}$.

Groupes

• (...) — groupe capturant, référencé par $1, $2 dans les remplacements
• (?:...) — groupe non capturant (grouper sans capturer)
• (?<nom>...) — groupe nommé, $<nom> dans les remplacements JavaScript
• (?=...) / (?!...) — lookahead : vérifier ce qui suit sans le consommer

Si un pattern avec des groupes imbriqués te fait loucher, un Regex Visualizer le transforme en diagramme ferroviaire — souvent le moyen le plus rapide de comprendre la regex de quelqu'un d'autre.

20 patterns à copier-coller

Validation

1. Email (pragmatique) — largement suffisant pour un formulaire ; la vraie validation RFC 5322 exige un vrai envoi d'email :

^[^\s@]+@[^\s@]+\.[^\s@]+$

2. URL (http/https) — protocole, domaine, chemin optionnel :

^https?:\/\/[\w.-]+\.[a-z]{2,}(\/\S*)?$

3. Adresse IPv4 — chaque octet plafonné à 255, pas juste \d{1,3} :

^((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$

4. Date au format ISO (YYYY-MM-DD) — valide la forme, pas le calendrier (elle accepte le 31 février) :

^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

5. Date au format français (JJ/MM/AAAA) :

^(0[1-9]|[12]\d|3[01])\/(0[1-9]|1[0-2])\/\d{4}$

6. Heure sur 24 h (HH:MM) :

^([01]\d|2[0-3]):[0-5]\d$

7. Téléphone international (E.164) — un + suivi de 7 à 15 chiffres :

^\+[1-9]\d{6,14}$

8. UUID (v1 à v5) :

^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$

9. Version semver — majeur.mineur.patch avec pré-release/build optionnels :

^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$

10. Couleur hexadécimale — #fff ou #ffffff, alpha optionnel :

^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$

11. Slug d'URL — minuscules, chiffres, tirets simples :

^[a-z0-9]+(-[a-z0-9]+)*$

12. Mot de passe robuste — 8 caractères minimum, une minuscule, une majuscule, un chiffre, un caractère spécial (les lookaheads en action) :

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$

Nettoyage et extraction

13. Espaces en fin de ligne — à remplacer par rien (flag multiline m) :

[ \t]+$

14. Espaces multiples → un seul — remplace par un espace simple :

 {2,}

15. Mot dupliqué (le le) — backreference \1 et frontières de mot :

\b(\w+)\s+\1\b

16. Lignes vides — réduit 2+ lignes vides consécutives à une seule :

\n{3,}

17. Balises HTML (suppression) — le quantificateur paresseux l'empêche d'avaler tout le document :

<[^>]+?>

18. Extraire le domaine d'une URL :

^https?:\/\/(?:www\.)?([^\/:?#]+)

19. Nombres dans un texte — entiers et décimaux, signe optionnel :

-?\d+(\.\d+)?

20. Texte entre guillemets — non gourmand, gère plusieurs segments par ligne :

"([^"]*)"

Les patterns 13 à 16 brillent dans le nettoyage de texte en masse. Un outil de Find & Replace avec support regex te permet de les appliquer à un document entier, avec des substitutions de groupes capturés type $1.

Deux avertissements avant de mettre en prod

Le backtracking catastrophique

Des quantificateurs imbriqués sur des ensembles de caractères qui se chevauchent — le classique étant (a+)+$ ou (\w+\s?)*$ — peuvent forcer le moteur à explorer un nombre exponentiel de chemins sur une entrée qui ne matche pas. Une chaîne de 30 caractères peut geler ton process. C'est une vraie classe d'attaque (ReDoS) : la panne mondiale de Cloudflare en 2019, c'était une seule regex.

Règles pratiques : évite d'imbriquer +/* dans un autre +/*, préfère des classes précises ([^"] plutôt que .) pour que les alternatives ne se chevauchent pas, et teste toujours tes patterns sur de longues chaînes qui matchent presque.

Ne parse pas du HTML avec des regex

Le pattern 17 ci-dessus convient pour un nettoyage rapide et ponctuel de texte de confiance. Ce n'est pas un parseur HTML. Le HTML autorise l'imbrication, des commentaires contenant >, des attributs contenant >, du CDATA et du balisage cassé mais rendu quand même — la regex en est structurellement incapable (elle ne sait pas compter la profondeur d'imbrication). Au-delà du nettoyage express, utilise un vrai parseur : DOMParser dans le navigateur, BeautifulSoup en Python, Cheerio en Node.

Construire tes propres patterns

Quand aucun des 20 ne colle, avance par itérations : commence par un match littéral, généralise un morceau à la fois, et re-teste après chaque changement. Note 3 à 5 chaînes qui doivent matcher et 3 à 5 qui ne doivent pas — tes cas négatifs attrapent plus de bugs que tes cas positifs.

Et quand le pattern dont tu as besoin est vraiment tordu — morceaux optionnels imbriqués, plusieurs formats en un — le décrire en français à un AI Regex Generator puis vérifier le résultat contre tes cas de test va plus vite que le tâtonnement.

Teste ta regex maintenant

Colle n'importe quel pattern de cette cheatsheet dans le Regex Tester et vois les correspondances, groupes et remplacements surlignés en temps réel. Aucun compte requis.