Expressions régulières : Un guide pratique avec exemples

31 mars 2026 · 12 min de lecture

Les expressions régulières (regex) sont l'un des outils les plus puissants dans la boîte à outils d'un développeur, pourtant elles sont souvent mal comprises ou complètement évitées. Que vous validiez des entrées utilisateur, analysiez des fichiers journaux ou transformiez des données textuelles, les regex offrent un moyen concis et efficace de faire correspondre des motifs dans des chaînes de caractères.

Ce guide complet vous emmènera des bases des regex aux techniques avancées, avec des exemples pratiques que vous pouvez utiliser immédiatement dans vos projets. À la fin, vous comprendrez non seulement comment les regex fonctionnent, mais quand et pourquoi les utiliser.

Qu'est-ce qu'une regex et pourquoi devriez-vous vous en soucier ?

Une expression régulière est une séquence de caractères qui définit un motif de recherche. Considérez-la comme un mini-langage spécialement conçu pour la correspondance de motifs dans le texte. Au lieu de rechercher des chaînes exactes, les regex vous permettent de décrire des motifs comme "n'importe quelle adresse e-mail" ou "tous les numéros de téléphone dans ce format".

Les regex sont prises en charge dans pratiquement tous les langages de programmation et de nombreux outils en ligne de commande. Une fois que vous apprenez la syntaxe, vous pouvez l'appliquer partout—de JavaScript et Python à grep et sed.

Les cas d'utilisation courants incluent :

• Valider les entrées utilisateur (e-mails, numéros de téléphone, mots de passe)
• Extraire des données du texte (analyser des journaux, extraire du contenu)
• Opérations de recherche et remplacement (refactorisation de code, nettoyage de données)
• Routage d'URL et correspondance de motifs
• Coloration syntaxique et analyse lexicale

Bases des regex : Blocs de construction

Chaque motif regex est construit à partir de blocs de construction fondamentaux. Comprendre ces éléments de base est essentiel avant de passer à des motifs plus complexes.

Caractères littéraux

La regex la plus simple est juste du texte littéral. Le motif cat correspond à la chaîne exacte "cat" dans votre texte. La plupart des caractères alphanumériques se correspondent directement à eux-mêmes.

Métacaractères

Certains caractères ont des significations spéciales dans les regex. Ceux-ci sont appelés métacaractères et incluent : . ^ $ * + ? { } [ ] \ | ( )

Pour faire correspondre ces caractères littéralement, vous devez les échapper avec une barre oblique inverse. Par exemple, \. correspond à un point littéral.

Le point joker

Le point . est le joker le plus basique—il correspond à n'importe quel caractère unique sauf le saut de ligne. Le motif a.c correspond à "abc", "a1c", "a-c", mais pas à "ac" (pas de caractère entre) ou "a\nc" (saut de ligne).

Notez que les versions en majuscules (\D, \W, \S) sont l'inverse de leurs homologues en minuscules. C'est un motif courant dans la syntaxe regex.

Quantificateurs : Contrôler la répétition

Les quantificateurs spécifient combien de fois un motif doit se répéter. Ils sont placés après l'élément que vous voulez répéter et sont fondamentaux pour créer des motifs flexibles.

Quantificateurs de base

Correspondance gourmande vs paresseuse

Par défaut, les quantificateurs sont gourmands—ils correspondent au maximum de texte possible. Cela peut conduire à des résultats inattendus lors de la correspondance de motifs comme les balises HTML.

// Correspondance gourmande
const text = "<div>Hello</div><div>World</div>";
const greedy = /<.*>/;
// Correspond à : "<div>Hello</div><div>World</div>" (chaîne entière !)

// Correspondance paresseuse
const lazy = /<.*?>/;
// Correspond à : "<div>" (s'arrête au premier crochet fermant)

Ajouter ? après un quantificateur le rend paresseux (non-gourmand). Les quantificateurs paresseux correspondent au minimum de texte possible tout en satisfaisant le motif.

Classes de caractères et raccourcis

Les classes de caractères vous permettent de faire correspondre n'importe quel caractère d'un ensemble spécifique. Elles sont définies à l'aide de crochets et sont incroyablement utiles pour créer des motifs flexibles.

Classes de caractères de base

// Correspond à n'importe quelle voyelle
/[aeiou]/

// Correspond à n'importe quel chiffre
/[0-9]/

// Correspond à n'importe quelle lettre minuscule
/[a-z]/

// Correspond à n'importe quelle lettre (insensible à la casse)
/[a-zA-Z]/

// Correspond aux caractères alphanumériques
/[a-zA-Z0-9]/

Classes de caractères niées

Utilisez ^ au début d'une classe de caractères pour la nier—correspondant à n'importe quel caractère sauf ceux listés.

// Correspond à n'importe quel non-chiffre
/[^0-9]/

// Correspond à n'importe quelle non-voyelle
/[^aeiou]/

// Correspond à n'importe quel caractère sauf espace ou tabulation
/[^ \t]/

Caractères spéciaux dans les classes

La plupart des métacaractères perdent leur signification spéciale à l'intérieur des classes de caractères. Vous pouvez inclure ., *, + et ? sans les échapper. Cependant, vous devez toujours échapper ], \, ^ et - dans certaines positions.

// Correspond à un point ou une virgule
/[.,]/

// Correspond à un trait d'union (échapper ou placer au début/fin)
/[-a-z]/ ou /[a-z-]/

// Correspond à un crochet fermant (doit échapper)
/[\]]/

Groupes et captures

Les groupes servent deux objectifs principaux : ils vous permettent d'appliquer des quantificateurs à plusieurs caractères, et ils capturent le texte correspondant pour une utilisation ultérieure.

Groupes de capture

Les parenthèses créent des groupes de capture qui mémorisent le texte correspondant. Ceci est essentiel pour extraire des données des chaînes.

// Extraire les composants de date
const datePattern = /(\d{4})-(\d{2})-(\d{2})/;
const match = "2026-03-29".match(datePattern);

// match[0] : "2026-03-29" (correspondance complète)
// match[1] : "2026" (premier groupe)
// match[2] : "03" (deuxième groupe)
// match[3] : "29" (troisième groupe)

Groupes de capture nommés

Les groupes nommés rendent votre regex plus lisible et votre code plus maintenable. Au lieu de vous référer aux groupes par numéro, vous leur donnez des noms descriptifs.

// Syntaxe des groupes nommés : (?<name>pattern)
const datePattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = "2026-03-29".match(datePattern);

// Accès par nom
console.log(match.groups.year);  // "2026"
console.log(match.groups.month); // "03"
console.log(match.groups.day);   // "29"

Groupes non-capturants

Parfois, vous avez besoin de regroupement pour les quantificateurs ou l'alternance mais ne voulez pas capturer le texte. Les groupes non-capturants utilisent la syntaxe (?:...).

// Capturer le protocole sans créer de groupe
/(?:https?|ftp):\/\/([a-z.]+)/

// Ceci crée seulement un groupe de capture (le domaine)
// Le groupe de protocole (?:https?|ftp) ne capture pas

Les groupes non-capturants sont plus rapides et utilisent moins de mémoire que les groupes capturants. Utilisez-les lorsque vous n'avez pas besoin du texte capturé.

Références arrière

Les références arrière vous permettent de faire correspondre le même texte qui a été capturé par un groupe précédent. Ceci est utile pour trouver des mots répétés ou faire correspondre des délimiteurs appariés.

// Trouver des mots répétés
/\b(\w+)\s+\1\b/
// Correspond à "the the" ou "hello hello"

// Faire correspondre des guillemets appariés
/(['"])(.*?)\1/
// Correspond à "hello" ou 'world' mais pas "mixed'

Alternance

L'opérateur pipe | crée une alternance—correspondant à un motif ou un autre. C'est comme un OU logique.

// Correspond à cat, dog ou bird
/cat|dog|bird/

// Correspond aux extensions de fichiers courantes
/\.(jpg|jpeg|png|gif|webp)$/i

// Correspond à Mr., Mrs., Ms. ou Dr.
/(?:Mr|Mrs|Ms|Dr)\./

Ancres et limites

Les ancres ne correspondent pas aux caractères—elles correspondent aux positions dans la chaîne. Elles sont essentielles pour s'assurer que les motifs apparaissent à des emplacements spécifiques.

Ancres de chaîne

• ^ correspond au début de la chaîne (ou ligne en mode multiligne)
• $ correspond à la fin de la chaîne (ou ligne en mode multiligne)

// Doit commencer par "Hello"
/^Hello/

// Doit se terminer par "world"
/world$/

// La chaîne entière doit être exactement 5 chiffres
/^\d{5}$/

Limites de mots

L'ancre \b correspond aux limites de mots—positions entre caractères de mot et non-mot. Ceci est crucial pour faire correspondre des mots entiers.

// Correspond à "cat" comme mot entier
/\bcat\b/
// Correspond à : "cat", "the cat sat"
// Ne correspond pas à : "category", "scat"

// Correspond aux mots commençant par "pre"
/\bpre\w+/
// Correspond à : "preview", "prepare", "prefix"

L'inverse \B correspond aux non-limites de mots—positions où les deux côtés sont des caractères de mot ou les deux sont des caractères non-mot.

Motifs courants pour une utilisation réelle

Voici des motifs regex éprouvés pour les tâches courantes de validation et d'extraction. Ces motifs équilibrent simplicité et précision pratique.

Validation de mot de passe

La validation de mot de passe nécessite de vérifier plusieurs conditions simultanément. Les assertions anticipées rendent cela possible sans logique complexe.

// Mot de passe fort : 8+ caractères, majuscule, minuscule, chiffre, caractère spécial
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/

// Décomposition :
// (?=.*[a-z])     - au moins une lettre minuscule
// (?=.*[A-Z])     - au moins une lettre majuscule