Référence complète des expressions régulières avec syntaxe, flags, groupes, lookaheads et exemples de modèles réels.
Essayer dans le Testeur Regex →| Syntaxe | Description |
|---|---|
. | Any character except newline |
\d | Digit [0-9] |
\D | Non-digit [^0-9] |
\w | Word char [a-zA-Z0-9_] |
\W | Non-word character |
\s | Whitespace (space, tab, newline) |
\S | Non-whitespace |
[abc] | One of a, b, or c |
[^abc] | Not a, b, or c |
[a-z] | Character in range a–z |
[a-zA-Z] | Letter (any case) |
\p{L} | Any Unicode letter (u flag) |
| Syntaxe | Description |
|---|---|
^ | Start of string (or line with m flag) |
$ | End of string (or line with m flag) |
\b | Word boundary |
\B | Non-word boundary |
\A | Start of string (Python/Java) |
\Z | End of string (Python/Java) |
| Syntaxe | Description |
|---|---|
* | 0 or more (greedy) |
+ | 1 or more (greedy) |
? | 0 or 1 (optional) |
{n} | Exactly n times |
{n,} | n or more times |
{n,m} | Between n and m times |
*? | 0 or more (lazy) |
+? | 1 or more (lazy) |
?? | 0 or 1 (lazy) |
| Syntaxe | Description |
|---|---|
(abc) | Capturing group |
(?:abc) | Non-capturing group |
(?<name>abc) | Named capturing group |
\1 | Backreference to group 1 |
\k<name> | Named backreference |
(?|...) | Branch reset group (PCRE) |
| Syntaxe | Description |
|---|---|
(?=abc) | Positive lookahead — must be followed by abc |
(?!abc) | Negative lookahead — must NOT be followed by abc |
(?<=abc) | Positive lookbehind — must be preceded by abc |
(?<!abc) | Negative lookbehind — must NOT be preceded by abc |
| Indicateur | Nom | Description |
|---|---|---|
g | Global | Find all matches, not just the first |
i | Case-insensitive | Match regardless of case (A = a) |
m | Multiline | ^ and $ match start/end of each line |
s | Dotall | . matches newline characters too |
u | Unicode | Enable full Unicode support (\p{} classes) |
y | Sticky | Match only at lastIndex position (JS) |
x | Extended | Allow whitespace + comments in pattern (Python/PHP) |
| Modèle | Regex | Test |
|---|---|---|
[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,} | Essayer dans le Testeur Regex → | |
| URL | https?:\/\/[\w\-]+(\.[\w\-]+)+[\w\-._~:/?#[\]@!$&'()*+,;=%]* | Essayer dans le Testeur Regex → |
| IPv4 Address | \b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b | Essayer dans le Testeur Regex → |
| Phone (US) | \+?1?[\s.-]?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4} | Essayer dans le Testeur Regex → |
| Date (YYYY-MM-DD) | \d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01]) | Essayer dans le Testeur Regex → |
| Time (HH:MM) | (?:[01]\d|2[0-3]):[0-5]\d | Essayer dans le Testeur Regex → |
| UUID | [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12} | Essayer dans le Testeur Regex → |
| Hex Color | #(?:[0-9a-fA-F]{3}){1,2}\b | Essayer dans le Testeur Regex → |
| Slug | [a-z0-9]+(?:-[a-z0-9]+)* | Essayer dans le Testeur Regex → |
| ZIP Code (US) | \d{5}(?:-\d{4})? | Essayer dans le Testeur Regex → |
| Credit Card | (?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}) | Essayer dans le Testeur Regex → |
| HTML Tag | <([a-zA-Z][a-zA-Z0-9]*)(?:\s[^>]*)?\/?>.*?<\/\1> | Essayer dans le Testeur Regex → |
| Markdown Bold | \*\*([^*]+)\*\* | Essayer dans le Testeur Regex → |
| JWT Token | [A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+ | Essayer dans le Testeur Regex → |
| Semver | \bv?(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.]+)?\b | Essayer dans le Testeur Regex → |
| GitHub Username | (?<=github\.com\/)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,37}[a-zA-Z0-9])?) | Essayer dans le Testeur Regex → |
| Positive Integer | ^[1-9]\d*$ | Essayer dans le Testeur Regex → |
| Float / Decimal | -?\d+(?:\.\d+)? | Essayer dans le Testeur Regex → |
| Blank Lines | ^\s*$ | Essayer dans le Testeur Regex → |
| Duplicate Words | \b(\w+)\s+\1\b | Essayer dans le Testeur Regex → |
Une expression régulière est une séquence de caractères définissant un motif de recherche. Elle est utilisée pour la recherche, la correspondance et la manipulation de chaînes. Les regex sont supportées nativement en JavaScript, Python, Java, PHP, Go et la plupart des langages modernes.
Les quantificateurs gourmands (*, +, {n,m}) correspondent à autant de caractères que possible. Les quantificateurs paresseux (*?, +?, {n,m}?) correspondent à aussi peu de caractères que possible.
Les lookaheads (?=...) et lookbehinds (?<=...) sont des assertions de largeur nulle — ils vérifient un motif sans consommer de caractères. Le lookahead positif (?=foo) affirme que 'foo' suit. Le lookahead négatif (?!foo) affirme que 'foo' ne suit PAS.
La syntaxe de base (classes de caractères, quantificateurs, ancres) est cohérente dans la plupart des langages. Cependant, des fonctionnalités comme lookbehind, les groupes nommés et les flags spécifiques varient selon le moteur.