Expressions régulières (Regex)

Définition

Une expression régulière (regex) est un motif de recherche qui décrit un ensemble de chaînes de caractères selon des règles syntaxiques précises.

Utilisation

Validation de formats (email, téléphone, etc.)
Recherche et remplacement de texte
Extraction de données
Analyse lexicale

Syntaxe de base

Caractères littéraux

a : correspond exactement au caractère 'a'
abc : correspond exactement à la chaîne "abc"

Métacaractères

Symbole	Signification	Exemple
`.`	N'importe quel caractère	`a.c` → "abc", "axc", "a1c"
`*`	0 ou plusieurs occurrences	`ab*c` → "ac", "abc", "abbc"
`+`	1 ou plusieurs occurrences	`ab+c` → "abc", "abbc" (pas "ac")
`?`	0 ou 1 occurrence	`ab?c` → "ac", "abc"
`^`	Début de chaîne	`^abc` → "abc..."
`$`	Fin de chaîne	`abc$` → "...abc"
`\\|`	OU logique	`a\\|b` → "a" ou "b"

Quantificateurs

Symbole	Signification	Exemple
`{n}`	Exactement n occurrences	`a{3}` → "aaa"
`{n,}`	Au moins n occurrences	`a{2,}` → "aa", "aaa", "aaaa"...
`{n,m}`	Entre n et m occurrences	`a{2,4}` → "aa", "aaa", "aaaa"

Classes de caractères

Symbole	Signification	Équivalent
`[abc]`	Un des caractères a, b ou c	`a\\|b\\|c`
`[a-z]`	Lettre minuscule
`[A-Z]`	Lettre majuscule
`[0-9]`	Chiffre	`\d`
`[^abc]`	Tout sauf a, b ou c

Classes prédéfinies

Symbole	Signification	Équivalent
`\d`	Chiffre	`[0-9]`
`\D`	Non-chiffre	`[^0-9]`
`\w`	Caractère de mot	`[a-zA-Z0-9_]`
`\W`	Non-caractère de mot	`[^a-zA-Z0-9_]`
`\s`	Espace blanc	`[ \t\n\r\f]`
`\S`	Non-espace blanc	`[^ \t\n\r\f]`

Groupes et captures

Symbole	Signification	Exemple
`(abc)`	Groupe de capture	`(ab)+` → "ab", "abab"
`(?:abc)`	Groupe non-capturant
`\1`	Référence au groupe 1	`(a)\1` → "aa"

Exemples pratiques

Validation de formats courants

Numéro de téléphone français

^0[1-9]([0-9]{8})$

* ^0 : commence par 0 * [1-9] : suivi d'un chiffre de 1 à 9 * [0-9]{8} : puis 8 chiffres * $ : fin de chaîne

Code postal français

^[0-9]{5}$

* 5 chiffres exactement

Plaque d'immatriculation (nouveau format)

^[A-Z]{2}-[0-9]{3}-[A-Z]{2}$

* Format : XX-123-XX

Extraction de données

Extraire les mots

\b[a-zA-Z]+\b

* \b : frontière de mot * [a-zA-Z]+ : une ou plusieurs lettres

Extraire les nombres

\d+(\.\d+)?

* \d+ : un ou plusieurs chiffres * (\.\d+)? : optionnellement un point suivi de chiffres

Validation d'adresse email

Expression régulière simplifiée

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Décomposition

Partie locale (avant @)

[a-zA-Z0-9._%+-]+

* Caractères autorisés : lettres, chiffres, point, underscore, %, +, - * Quantificateur : + (au moins un caractère)

Séparateur

* Caractère obligatoire unique

Nom de domaine

[a-zA-Z0-9.-]+

* Caractères autorisés : lettres, chiffres, point, tiret * Quantificateur : + (au moins un caractère)

Extension

\.[a-zA-Z]{2,}

* Point obligatoire : \. (échappé) * Extension : [a-zA-Z]{2,} (au moins 2 lettres)

Exemples valides

user@example.com
test.email+tag@domain.co.uk
user123@sub.domain.org

Exemples invalides

user@ (pas de domaine)
@domain.com (pas de partie locale)
user@domain (pas d'extension)
user..name@domain.com (points consécutifs)

Version plus stricte (RFC 5322 partielle)

^[a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?@[a-zA-Z0-9]([a-zA-Z0-9.-]*[a-zA-Z0-9])?\.[a-zA-Z]{2,}$

Améliorations : * Interdit de commencer/finir par un point ou tiret * Plus conforme aux standards

Exemple d'agrégation interne 2024

Contexte (Figure 20)

Validation d'un identifiant utilisateur avec les contraintes : * Commence par une lettre * Contient uniquement lettres, chiffres et underscore * Longueur entre 3 et 20 caractères

Expression régulière

^[a-zA-Z][a-zA-Z0-9_]{2,19}$

Décomposition

^ : début de chaîne
[a-zA-Z] : première lettre obligatoire
[a-zA-Z0-9_]{2,19} : 2 à 19 caractères (lettres, chiffres, underscore)
$ : fin de chaîne

Total : 3 à 20 caractères (1 + 2 à 19)

Exemples

✅ user123
✅ Admin_User
✅ a12
❌ 123user (commence par un chiffre)
❌ us (trop court)
❌ user-name (tiret interdit)

Outils et langages

Langages supportant les regex

Python : module re
JavaScript : objet RegExp
Java : classe Pattern
C# : classe Regex
PHP : fonctions preg_*

Exemple en Python

import re

# Validation email
email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
email = "user@example.com"

if re.match(email_pattern, email):
    print("Email valide")
else:
    print("Email invalide")

Exemple en JavaScript

// Validation email
const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
const email = "user@example.com";

if (emailPattern.test(email)) {
    console.log("Email valide");
} else {
    console.log("Email invalide");
}

Bonnes pratiques

Performance

Éviter les quantificateurs gourmands inutiles
Utiliser des ancres (^ et $) quand nécessaire
Préférer les classes de caractères aux alternatives multiples

Lisibilité

Commenter les regex complexes
Utiliser des groupes nommés si supportés
Diviser les regex très longues

Sécurité

Attention aux attaques par déni de service (ReDoS)
Valider la longueur des chaînes en amont
Éviter les regex avec backtracking excessif

Exemple de regex dangereuse

(a+)+b

* Peut causer un backtracking exponentiel * Vulnérable aux attaques ReDoS

Version sécurisée

a+b

* Même résultat, complexité linéaire

Outils de test

En ligne

regex101.com : Test et explication détaillée
regexr.com : Interface interactive
regexpal.com : Test simple et rapide

Éditeurs

VSCode : Support natif avec coloration
Sublime Text : Plugin regex
Vim : Commandes de recherche/remplacement

Cas d'usage avancés

Validation de mot de passe

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

* Au moins une minuscule * Au moins une majuscule
* Au moins un chiffre * Au moins un caractère spécial * Minimum 8 caractères

Extraction d'URLs

https?://[^\s]+

* Protocole HTTP ou HTTPS * Suivi de caractères non-espaces

Validation d'adresse IP

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

* Chaque octet entre 0 et 255 * Format xxx.xxx.xxx.xxx