Les expressions régulières pour les débutants

Vous cherchez à tester une expression régulière en ligne gratuit ou à comprendre enfin comment fonctionnent ces mystérieuses suites de caractères ? Les expressions régulières (ou “regex”) font peur à beaucoup de développeurs. Ces patterns cryptiques comme ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ semblent incompréhensibles au premier abord.

Pourtant, les regex sont un outil puissant pour valider des motifs, rechercher du texte et extraire des données. Que vous ayez besoin de valider un email, un numéro de téléphone, ou d’extraire des informations d’un log, les expressions régulières sont la solution.

Notre testeur de regex vous permet d’expérimenter avec flags et groupes en temps réel. C’est un outil regex pour développeurs idéal pour apprendre et débugger vos patterns. Dans ce guide progressif, découvrez comment maîtriser les regex étape par étape.

Qu’est-ce qu’une expression régulière ?

Une regex est un pattern de recherche qui décrit un ensemble de chaînes de caractères. Elle permet de :

Valider : Vérifier qu’une entrée correspond à un format (email, téléphone, etc.)
Rechercher : Trouver des occurrences dans un texte
Extraire : Capturer des parties spécifiques d’une chaîne
Remplacer : Modifier du texte selon des motifs

Les bases essentielles

Caractères littéraux

Par défaut, un caractère se correspond lui-même :

Pattern	Correspond à
`hello`	”hello” dans le texte
`2025`	”2025” dans le texte

Testez dans notre testeur regex : entrez hello comme pattern et hello world comme texte.

Caractères spéciaux (métacaractères)

Certains caractères ont une signification particulière :

Caractère	Signification
`.`	N’importe quel caractère (sauf nouvelle ligne)
`\d`	Un chiffre (0-9)
`\D`	Tout sauf un chiffre
`\w`	Un caractère “mot” (lettre, chiffre, underscore)
`\W`	Tout sauf un caractère mot
`\s`	Un espace blanc (espace, tab, nouvelle ligne)
`\S`	Tout sauf un espace blanc

Exemples :

\d\d\d correspond à “123”, “456”, “789”
\w\w\w correspond à “abc”, “A_1”, “foo”

Quantificateurs

Les quantificateurs indiquent combien de fois un élément doit apparaître :

Quantificateur	Signification
`*`	Zéro ou plus
`+`	Un ou plus
`?`	Zéro ou un (optionnel)
`{n}`	Exactement n fois
`{n,}`	Au moins n fois
`{n,m}`	Entre n et m fois

Exemples pratiques :

\d+ : un ou plusieurs chiffres → “1”, “123”, “99999”
\d{4} : exactement 4 chiffres → “2025”, “1234”
\d{2,4} : entre 2 et 4 chiffres → “12”, “123”, “1234”

Classes de caractères

Les crochets [] définissent un ensemble de caractères possibles :

Pattern	Correspond à
`[abc]`	”a”, “b” ou “c”
`[a-z]`	Toute lettre minuscule
`[A-Z]`	Toute lettre majuscule
`[0-9]`	Tout chiffre (équivalent à `\d`)
`[a-zA-Z]`	Toute lettre
`[^abc]`	Tout SAUF “a”, “b” ou “c”

Exemples :

[aeiou] : une voyelle
[a-zA-Z0-9] : un caractère alphanumérique
[^0-9] : tout sauf un chiffre

Ancres

Les ancres ne correspondent pas à des caractères mais à des positions :

Ancre	Signification
`^`	Début de ligne/chaîne
`$`	Fin de ligne/chaîne
`\b`	Limite de mot

Exemples :

^Bonjour : “Bonjour” au début
fin$ : “fin” à la fin
\bcat\b : le mot “cat” (pas “category”)

Groupes et alternatives

Pattern	Signification
`(abc)`	Groupe capturant
`(?:abc)`	Groupe non capturant
`a\|b`	”a” OU “b”

Exemples :

(chat|chien) : “chat” ou “chien”
https? : “http” ou “https” (le “s” est optionnel)

Exemples pratiques du quotidien

Valider un email

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

Décomposition :

^ : début de chaîne
[a-zA-Z0-9._%+-]+ : partie locale (avant @)
@ : le caractère @
[a-zA-Z0-9.-]+ : nom de domaine
\. : le point (échappé car . est spécial)
[a-zA-Z]{2,} : extension (au moins 2 lettres)
$ : fin de chaîne

Valider un numéro de téléphone français

^(?:(?:\+|00)33|0)\s*[1-9](?:[\s.-]*\d{2}){4}$

Accepte : “0612345678”, “06 12 34 56 78”, “+33 6 12 34 56 78”

Extraire des URLs

https?://[^\s]+

Simple mais efficace pour trouver des URLs dans un texte.

Valider un code postal français

^[0-9]{5}$

5 chiffres exactement.

Trouver des adresses IP

\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b

Note : Ceci trouve les formats d’IP, pas nécessairement des IPs valides (0-255).

Valider un mot de passe fort

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

Exige : minuscule, majuscule, chiffre, caractère spécial, minimum 8 caractères.

Besoin d’un mot de passe fort ? Utilisez notre générateur de mot de passe !

Extraire des hashtags

#\w+

Trouve tous les hashtags dans un texte.

Pièges courants à éviter

1. Oublier d’échapper les caractères spéciaux

// ❌ Cherche n'importe quoi.com
example.com

// ✅ Cherche exactement "example.com"
example\.com

Caractères à échapper : . * + ? ^ $ { } [ ] ( ) | \

2. Regex trop gourmandes

Les quantificateurs * et + sont “gourmands” par défaut :

// Texte : "<div>hello</div><div>world</div>"

// ❌ Gourmand : capture tout entre le premier < et le dernier >
<.+>

// ✅ Non-gourmand : capture chaque balise
<.+?>

3. Ne pas ancrer les patterns de validation

// ❌ Trouve "123" dans "abc123def"
\d+

// ✅ Valide que toute la chaîne est un nombre
^\d+$

4. Sensibilité à la casse

// ❌ Ne trouve pas "HELLO"
hello

// ✅ Avec flag insensible à la casse (i)
hello    // avec /i
[Hh][Ee][Ll][Ll][Oo]  // sans flag

Les flags (modificateurs)

Flag	Signification
`i`	Insensible à la casse
`g`	Global (toutes les occurrences)
`m`	Multiligne (^ et $ par ligne)
`s`	Le point `.` inclut les nouvelles lignes

Notre testeur regex vous permet de tester différents flags.

Regex dans différents langages

JavaScript

const regex = /\d+/g;
const text = "Il y a 3 pommes et 5 oranges";

// Test
regex.test(text); // true

// Match
text.match(regex); // ["3", "5"]

// Replace
text.replace(/\d+/g, "X"); // "Il y a X pommes et X oranges"

Python

import re

text = "Il y a 3 pommes et 5 oranges"
pattern = r"\d+"

# Recherche
re.search(pattern, text)  # Match object pour "3"

# Toutes les occurrences
re.findall(pattern, text)  # ["3", "5"]

# Remplacement
re.sub(pattern, "X", text)  # "Il y a X pommes et X oranges"

PHP

$text = "Il y a 3 pommes et 5 oranges";
$pattern = "/\d+/";

// Recherche
preg_match($pattern, $text, $matches);

// Toutes les occurrences
preg_match_all($pattern, $text, $matches);

// Remplacement
preg_replace($pattern, "X", $text);

Exercices pratiques

Testez ces exercices dans notre testeur regex :

Exercice 1 : Dates

Trouvez les dates au format JJ/MM/AAAA dans : “Rendez-vous le 15/03/2025 ou le 20/04/2025”

Solution

\d{2}/\d{2}/\d{4}

Exercice 2 : Montants en euros

Extrayez les prix dans : “Article A : 19,99€ - Article B : 150€ - Total : 169,99 €“

Solution

\d+(?:,\d{2})?\s*€

Exercice 3 : Noms de fichiers

Trouvez les fichiers .jpg ou .png : “photo.jpg, document.pdf, image.png, video.mp4”

Solution

\w+\.(?:jpg|png)

Ressources pour progresser

Pratiquer

Notre testeur regex avec feedback en temps réel
regex101.com pour des explications détaillées
regexr.com avec une référence complète

Mémorisation

Les bases : ., \d, \w, \s
Les quantificateurs : *, +, ?, {n}
Les ancres : ^, $, \b

Outils complémentaires

Pour travailler efficacement avec le texte :

Testeur de regex : Testez vos expressions en temps réel
Compteur de mots : Analysez vos textes
Comparateur de texte : Comparez avant/après remplacement
Formateur JSON : Formatez les données extraites

Conclusion

Les expressions régulières sont un outil puissant qui mérite l’investissement en apprentissage. Commencez par les bases, pratiquez régulièrement, et vous serez surpris de la rapidité avec laquelle vous pourrez construire des patterns complexes.

La clé : tester, tester, tester. Notre testeur regex est là pour ça !

N’hésitez pas à revenir sur ce guide comme référence, et bonne pratique !