Les expressions régulières (regex) sont parmi les outils les plus puissants — et souvent les plus redoutés — dans l'arsenal d'un développeur. Au premier abord, elles peuvent sembler comme du charabia, mais une fois que vous maîtrisez leurs éléments constitutifs, la regex devient un instrument indispensable pour la validation de données, les opérations de recherche et remplacement, l'analyse de logs, et l'extraction d'informations précises.

Les Fondations

Caractères Littéraux

La plupart des caractères correspondent à eux-mêmes. Par exemple, l'expression régulière bonjour trouvera littéralement la chaîne "bonjour". C'est le principe de base : ce que vous voyez est ce que vous obtenez.

Méta-caractères

Méta-caractères Courants
.     N'importe quel caractère unique (sauf saut de ligne)
^     Début de la chaîne
$     Fin de la chaîne
\d    N'importe quel chiffre (0-9)
\w    N'importe quel caractère alphanumérique ou underscore (a-z, A-Z, 0-9, _)
\s    N'importe quel espace blanc (espace, tabulation, saut de ligne)
\D    N'importe quel caractère qui n'est PAS un chiffre
\W    N'importe quel caractère qui n'est PAS alphanumérique ou underscore
\S    N'importe quel caractère qui n'est PAS un espace blanc
\b    Limite de mot (début ou fin d'un mot)

Quantificateurs

Quantificateurs
*     Zéro ou plusieurs fois
+     Une ou plusieurs fois
?     Zéro ou une fois (optionnel)
{3}   Exactement 3 fois
{2,5} Entre 2 et 5 fois
{3,}  3 fois ou plus

Classes de Caractères

Les crochets [] définissent un ensemble de caractères possibles. La regex trouvera n'importe lequel des caractères listés à l'intérieur.

Classes de Caractères
[aeiou]      Correspond à n'importe quelle voyelle
[a-z]        Correspond à n'importe quelle lettre minuscule
[A-Za-z]     Correspond à n'importe quelle lettre (majuscule ou minuscule)
[0-9]        Correspond à n'importe quel chiffre (équivalent à \d)
[^0-9]       Correspond à tout caractère SAUF un chiffre
[a-zA-Z0-9_] Équivalent à \w

Groupes et Capture

Groupes
// Les parenthèses créent des groupes capturants
const match = "2025-07-08".match(/(\d{4})-(\d{2})-(\d{2})/);
// match[1] = "2025" (année)
// match[2] = "07"   (mois)
// match[3] = "08"   (jour)

// Groupes nommés (plus lisibles et intuitifs)
const match2 = "2025-07-08".match(/(?\d{4})-(?\d{2})-(?\d{2})/);
// match2.groups.annee  = "2025"
// match2.groups.mois = "07"

// Groupe non-capturant (pour regrouper sans capturer)
/(?:https?|ftp):\/\//

Exemples Pratiques

Validation d'Email (Basique)

Regex pour Email
const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
emailRegex.test("[email protected]");  // true
emailRegex.test("pas-un-email");       // false

Validation de Slug d'URL

Regex pour Slug
// Autorise uniquement lettres minuscules, chiffres et tirets
const slugRegex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
slugRegex.test("mon-article-de-blog");   // true
slugRegex.test("Mon Article De Blog");   // false
slugRegex.test("--double-tirets");  // false

Extraction de toutes les URLs d'un Texte

Extraction d'URLs
const texte = "Visitez https://exemple.com ou http://test.org pour plus d'infos.";
const urls = texte.match(/https?:\/\/[^\s]+/g);
// urls = ["https://exemple.com", "http://test.org"]

Validation de Force de Mot de Passe

Regex pour Mot de Passe Fort
// Minimum 8 caractères, une majuscule, une minuscule, un chiffre, un caractère spécial
const motDePasseFort = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;

Regex en PHP

PHP preg_match
// Correspondance
if (preg_match('/^\d{4}-\d{2}-\d{2}$/', $date)) {
    echo "Format de date valide";
}

// Remplacement
$slug = preg_replace('/[^a-z0-9]+/', '-', strtolower($titre));

// Extraire toutes les correspondances
preg_match_all('/\b[A-Z][a-z]+\b/', $texte, $correspondances);
// $correspondances[0] contient tous les mots commençant par une majuscule

Erreurs Courantes à Éviter

  • Avarice par défaut : L'opérateur .* tente de correspondre au plus grand nombre de caractères possible. Utilisez .*? pour un comportement non avide (correspondre au minimum).
  • Oubli d'échapper les caractères spéciaux : Les caractères tels que ., *, +, ?, (, ), [, ] doivent être précédés d'un antislash \ s'ils doivent être interprétés littéralement.
  • Absence d'ancrage : Sans les ancres ^ (début) et $ (fin), votre regex pourrait trouver une correspondance dans une sous-chaîne au lieu de valider la chaîne entière.
  • Complexité inutile : Si une méthode plus simple comme string.includes() ou string.startsWith() suffit, n'introduisez pas la complexité des expressions régulières.

Essayez nos Outils Gratuits pour Développeurs

Encodez, décodez et formatez votre code en un instant.