Expressions Régulières

Les expressions régulières (regex) sont des motifs utilisés pour matcher, rechercher et remplacer du texte. C'est un outil puissant intégré à JavaScript pour travailler avec les chaînes de caractères.

Deux façons de créer une regex :

// Syntaxe littérale (préférée pour les motifs statiques)
const regex1 = /hello/i;

// Syntaxe constructeur (pour les motifs dynamiques)
const regex2 = new RegExp('hello', 'i');

Drapeaux courants :

• g — Global : trouve toutes les correspondances, pas seulement la première
• i — Insensible à la casse : matche indépendamment de la casse
• m — Multiline : ^ et $ matchent début/fin de chaque ligne

const text = 'Hello hello HELLO';
console.log(text.match(/hello/gi)); // ['Hello', 'hello', 'HELLO']

Les expressions régulières sont utilisées pour la validation (est-ce un email valide ?), la recherche (trouver tous les numéros de téléphone dans un texte) et le remplacement (censurer des mots, formater du texte).

Les motifs regex sont construits à partir de divers caractères et séquences spéciales.

Classes de caractères qui matchent des catégories de caractères :

• \d — n'importe quel chiffre (0-9)
• \w — n'importe quel caractère de mot (lettre, chiffre, underscore)
• \s — n'importe quel espace blanc (espace, tabulation, nouvelle ligne)
• . — n'importe quel caractère sauf nouvelle ligne
• [abc] — n'importe quel caractère dans l'ensemble
• [^abc] — n'importe quel caractère PAS dans l'ensemble

Quantificateurs qui spécifient combien :

• * — zéro ou plus
• + — un ou plus
• ? — zéro ou un (optionnel)
• {n} — exactement n fois
• {n,m} — entre n et m fois

Ancres qui matchent des positions :

• ^ — début de la chaîne (ou ligne avec le drapeau m)
• $ — fin de la chaîne (ou ligne avec le drapeau m)

Groupement et alternance :

• () — grouper des caractères ensemble
• | — OU (alternance)

// Matcher un numéro de téléphone US : 555-123-4567
const phone = /^\d{3}-\d{3}-\d{4}$/;
console.log(phone.test('555-123-4567')); // true

Échappement : Pour matcher un caractère spécial littéralement, préfixe-le avec \ :

const price = /\$\d+\.\d{2}/; // matche $9.99, $100.00

Il existe deux ensembles de méthodes pour travailler avec les regex : les méthodes sur les objets RegExp et les méthodes sur les chaînes de caractères.

Méthodes RegExp :

const regex = /\d+/;

// test() — retourne true ou false
regex.test('abc123'); // true
regex.test('abc');    // false

// exec() — retourne un tableau de correspondances ou null
regex.exec('abc123'); // ['123', index: 3, ...]

Méthodes de chaînes qui acceptent les regex :

const text = 'Call 555-1234 or 555-5678';

// match() — trouver les correspondances
text.match(/\d{3}-\d{4}/g); // ['555-1234', '555-5678']

// search() — trouver l'index de la première correspondance
text.search(/\d+/); // 5

// replace() — remplacer les correspondances
text.replace(/\d/g, 'X'); // 'Call XXX-XXXX or XXX-XXXX'

// replaceAll() — remplacer toutes (nécessite le drapeau g avec regex)
'a.b.c'.replaceAll('.', '-'); // 'a-b-c'

// split() — diviser par motif
'one, two,  three'.split(/,\s*/); // ['one', 'two', 'three']

Groupes de capture avec parenthèses :

const dateRegex = /(\d{4})-(\d{2})-(\d{2})/;
const match = '2024-01-15'.match(dateRegex);
console.log(match[1]); // '2024' (année)
console.log(match[2]); // '01'   (mois)
console.log(match[3]); // '15'   (jour)

Voici quelques motifs regex pratiques que tu rencontreras fréquemment.

Validation d'email basique :

const email = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
email.test('user@example.com');  // true
email.test('invalid-email');      // false

Numéros de téléphone (divers formats) :

const phone = /^\+?\d{1,3}[-.\s]?\d{3}[-.\s]?\d{4}$/;

Extraire des nombres d'un texte :

const text = 'I have 3 cats and 12 dogs';
const numbers = text.match(/\d+/g).map(Number);
console.log(numbers); // [3, 12]

Remplacer les espaces superflus :

const messy = '  too   many   spaces  ';
const clean = messy.trim().replace(/\s+/g, ' ');
console.log(clean); // 'too many spaces'

Quand NE PAS utiliser les regex :

• Parser du HTML — utilise DOMParser ou querySelector à la place
• Grammaires complexes — utilise un vrai parser
• Opérations simples sur les chaînes — includes(), startsWith(), endsWith() sont plus clairs

Comme dit le vieil adage : "Certaines personnes, confrontées à un problème, pensent 'Je sais, je vais utiliser des expressions régulières.' Maintenant elles ont deux problèmes." Utilise les regex quand c'est le bon outil, mais ne les force pas.