Aide-mémoire des expressions régulières pour développeurs

31 mars 2026 · 12 min de lecture

Introduction aux expressions régulières

Les expressions régulières (regex) sont des outils puissants de correspondance de motifs que chaque développeur devrait maîtriser. Elles offrent un moyen concis et déclaratif de rechercher, valider et manipuler des données textuelles sans écrire de code verbeux de manipulation de chaînes.

Que vous construisiez une validation de formulaire, analysiez des fichiers journaux, extrayiez des données d'API ou nettoyiez des ensembles de données, les regex offrent une solution élégante. Un seul motif regex peut remplacer des dizaines de lignes de logique conditionnelle, rendant votre code plus maintenable et moins sujet aux erreurs.

Les langages de programmation modernes comme JavaScript, Python, Java, PHP et Ruby ont tous un support regex intégré. Une fois que vous apprenez la syntaxe, vous pouvez appliquer ces compétences dans pratiquement n'importe quel environnement de développement.

Syntaxe de base et éléments

Comprendre les éléments fondamentaux des regex est essentiel avant de s'attaquer à des motifs complexes. Ces éléments de base forment le fondement de chaque expression régulière que vous écrirez.

Caractères littéraux

Les motifs regex les plus simples correspondent aux caractères littéraux exactement tels qu'ils apparaissent. Le motif cat correspond à la chaîne "cat" partout où elle apparaît dans votre texte.

La plupart des caractères alphanumériques sont littéraux, mais certains caractères spéciaux (appelés métacaractères) ont des significations spéciales et doivent être échappés avec une barre oblique inverse lorsque vous voulez les faire correspondre littéralement.

Métacaractères essentiels

Échapper les caractères spéciaux

Lorsque vous devez faire correspondre des métacaractères littéralement, préfixez-les avec une barre oblique inverse. Par exemple, pour faire correspondre un point littéral, utilisez \. au lieu de simplement .

Les caractères courants qui nécessitent un échappement incluent : . * + ? ^ $ { } [ ] ( ) | \

// Correspond à un point d'interrogation littéral
const pattern = /What\?/;
pattern.test("What?"); // true

// Correspond à un montant en dollars
const price = /\$\d+\.\d{2}/;
price.test("$19.99"); // true

Classes de caractères et quantificateurs

Les classes de caractères vous permettent de faire correspondre n'importe quel caractère d'un ensemble spécifique, tandis que les quantificateurs contrôlent combien de fois un motif doit se répéter. Ensemble, ils forment l'épine dorsale de la correspondance de motifs flexible.

Classes de caractères prédéfinies

Ensembles de caractères personnalisés

Les crochets définissent des ensembles de caractères personnalisés. Le motif [aeiou] correspond à n'importe quelle voyelle unique, tandis que [0-9a-fA-F] correspond à n'importe quel chiffre hexadécimal.

Utilisez un accent circonflexe à l'intérieur des crochets pour nier l'ensemble : [^0-9] correspond à n'importe quel caractère qui n'est PAS un chiffre.

// Correspond à n'importe quelle voyelle
const vowels = /[aeiou]/gi;
"Hello World".match(vowels); // ["e", "o", "o"]

// Correspond uniquement aux consonnes
const consonants = /[^aeiou\s]/gi;
"Hello".match(consonants); // ["H", "l", "l"]

Quantificateurs en détail

Les quantificateurs spécifient combien de fois l'élément précédent doit correspondre. Ils sont gourmands par défaut, ce qui signifie qu'ils correspondent au maximum de texte possible.

• {n} - Exactement n fois : \d{4} correspond exactement à 4 chiffres
• {n,} - Au moins n fois : \d{3,} correspond à 3 chiffres ou plus
• {n,m} - Entre n et m fois : \d{2,4} correspond à 2, 3 ou 4 chiffres
• * - Zéro ou plus (équivalent à {0,})
• + - Un ou plus (équivalent à {1,})
• ? - Zéro ou un (équivalent à {0,1})

Ancres et limites de mots

Les ancres ne correspondent pas aux caractères—elles correspondent aux positions dans la chaîne. Elles sont essentielles pour une correspondance de motifs précise lorsque vous devez vous assurer que le texte apparaît à des emplacements spécifiques.

Ancres de position

L'accent circonflexe ^ correspond au début d'une chaîne (ou ligne en mode multiligne), tandis que le signe dollar $ correspond à la fin. Ceux-ci sont inestimables pour la validation où la chaîne entière doit correspondre à un motif.

// Valider que la chaîne entière est composée de chiffres
const onlyDigits = /^\d+$/;
onlyDigits.test("12345"); // true
onlyDigits.test("123abc"); // false

// Correspond aux lignes commençant par "Error"
const errorLines = /^Error/gm;
const logs = "Info: Starting\nError: Failed\nError: Timeout";
logs.match(errorLines); // ["Error", "Error"]

Limites de mots

L'ancre \b correspond aux limites de mots—positions entre caractères de mot et non-mot. Elle est parfaite pour faire correspondre des mots entiers sans correspondre accidentellement à des parties de mots plus grands.

L'ancre \B correspond aux positions qui ne sont PAS des limites de mots.

// Correspond à "cat" comme mot entier uniquement
const wholeCat = /\bcat\b/;
wholeCat.test("cat"); // true
wholeCat.test("cats"); // false
wholeCat.test("concatenate"); // false

// Correspond à "cat" dans les mots
const partialCat = /\Bcat\B/;
partialCat.test("concatenate"); // true
partialCat.test("cat"); // false

Les limites de mots sont particulièrement utiles pour les opérations de recherche et remplacement où vous voulez éviter les correspondances partielles. Elles sont également essentielles lors de la construction de surligneurs de syntaxe ou d'analyseurs de code.

Groupes et capture

Les parenthèses dans les regex servent plusieurs objectifs : elles regroupent des parties de motifs ensemble, capturent le texte correspondant pour une utilisation ultérieure et permettent des références arrière dans le motif lui-même.

Groupes de capture

Les parenthèses créent des groupes de capture numérotés qui stockent le texte correspondant. Vous pouvez référencer ces captures dans les chaînes de remplacement ou les extraire par programmation.

// Extraire les composants de date
const datePattern = /(\d{4})-(\d{2})-(\d{2})/;
const match = "2026-03-31".match(datePattern);
// match[0]: "2026-03-31" (correspondance complète)
// match[1]: "2026" (année)
// match[2]: "03" (mois)
// match[3]: "31" (jour)

// Reformater les dates en utilisant les captures
const text = "Date: 2026-03-31";
const reformatted = text.replace(/(\d{4})-(\d{2})-(\d{2})/, "$2/$3/$1");
// Résultat: "Date: 03/31/2026"

Groupes non-capturants

Utilisez (?:...) pour regrouper des motifs sans créer de capture. Cela améliore les performances et garde votre numérotation de capture propre lorsque vous avez seulement besoin de regroupement pour l'alternance ou les quantificateurs.

// Grouper sans capturer
const protocol = /(?:https?|ftp):\/\//;
protocol.test("https://example.com"); // true

// Comparer avec capture (surcharge inutile)
const protocolCapture = /(https?|ftp):\/\//;
// Crée un groupe de capture supplémentaire dont nous n'avons pas besoin

Groupes de capture nommés

Les moteurs regex modernes prennent en charge les captures nommées en utilisant la syntaxe (?<name>...). Cela rend vos motifs auto-documentés et plus faciles à maintenir.

// Captures nommées pour la clarté
const emailPattern = /(?<user>[\w.]+)@(?<domain>[\w.]+)/;
const match = "[email protected]".match(emailPattern);
console.log(match.groups.user); // "john.doe"
console.log(match.groups.domain); // "example.com"

// Utiliser dans les remplacements
const masked = "[email protected]".replace(
  /(?<user>[\w.]+)@(?<domain>[\w.]+)/,
  "***@$<domain>"
);
// Résultat: "***@example.com"

Références arrière

Référencez les captures antérieures dans le même motif en utilisant \1, \2, etc. Ceci est puissant pour faire correspondre des motifs répétés ou en miroir.

// Correspond aux mots répétés
const repeated = /\b(\w+)\s+\1\b/;
repeated.test("hello hello"); // true
repeated.test("hello world"); // false

// Correspond aux balises HTML
const htmlTag = /<(\w+)>.*?<\/\1>/;
htmlTag.test("<div>content</div>"); // true
htmlTag.test("<div>content</span>"); // false

Drapeaux et modificateurs regex

Les drapeaux modifient la façon dont le moteur regex interprète votre motif. Ils sont ajoutés après le délimiteur de fermeture dans la plupart des langages (par exemple, /pattern/flags en JavaScript).

Drapeaux courants

• g (global) - Trouver toutes les correspondances au lieu de s'arrêter après la première correspondance
• i (insensible à la casse) - Ignorer la casse lors de la correspondance des lettres
• m (multiligne) - Faire correspondre ^ et $ aux limites de ligne au lieu des limites de chaîne
• s (dotall) - Faire correspondre . aux caractères de nouvelle ligne
• u (unicode) - Activer le support Unicode complet
• y (sticky) - Correspondre uniquement à partir de la position lastIndex

// Recherche insensible à la casse
const pattern = /hello/i;
pattern.test("HELLO"); // true
pattern.test("Hello"); // true

// Drapeau global pour plusieurs correspondances
const digits = /\d+/g;
"Phone: 555-1234, Fax: 555-5678".match(digits);
// ["555", "1234", "555", "5678"]

// Mode multiligne
const headers = /^#.+$/gm;
const markdown = "# Title\nContent\n## Subtitle";
markdown.match(headers); // ["# Title", "## Subtitle"]

Motifs courants et leurs applications

Explorons des motifs regex éprouvés pour les tâches de développement courantes. Ces motifs ont été affinés par l'utilisation dans le monde réel et gèrent les cas limites que vous pourriez ne pas considérer initialement.

Validation d'email

La validation d'email est notoirement complexe en raison des spécifications RFC, mais ce motif pratique gère 99% des adresses email du monde réel :

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

// Emails valides
emailPattern.test("[email protected]"); // true
emailPattern.test("[email protected]"); // true

// Emails invalides
emailPattern.test("invalid@"); // false
emailPattern.test("@example.com"); // false
emailPattern.test("[email protected]"); // false

Pour les applications de production, envisagez d'utiliser une bibliothèque dédiée de validation d'email qui gère les domaines internationalisés et tous les cas limites RFC. Vous pouvez également utiliser notre Outil de validation d'email pour tester les motifs d'email de manière interactive.

Correspondance d'URL

Faites correspondre et extrayez les URL du texte avec ce motif complet :

const urlPattern