Premiers pas
Syntaxe de base
Regex utilise des caractères spéciaux pour le matching de motifs. . matche tout caractère, [] définit des classes de caractères, \d \w \s sont des raccourcis pour des ensembles courants. Utilisez ^ à l'intérieur de [] pour la négation.
# Basic matching
hello # literal match
. # any character except newline
[abc] # any of a, b, c
[^abc] # not a, b, or c
[a-z] # range a to z
\d # digit [0-9]
\D # non-digit
\w # word char [a-zA-Z0-9_]
\W # non-word char
\s # whitespace
\S # non-whitespaceMétacaractères
Les métacaractères ont un sens spécial. Pour les matcher littéralement, préfixez d'un antislash. À l'intérieur des classes de caractères [], seuls ] \ ^ et - exigent un échappement (et - seulement quand il n'est pas au début/fin).
# Special metacharacters that need escaping:
. * + ? ^ $ { } [ ] \\ | ( )
# Escape with backslash to match literally
\. # literal dot
\* # literal asterisk
\+ # literal plus
\? # literal question mark
\( # literal parenthesis
\[ # literal bracket
\$ # literal dollar
\^ # literal caret
\\ # literal backslash
# Example: match "1.5" not "1x5"
1\.5 # matches "1.5" onlyPoint et wildcards
Le point . est le wildcard le plus courant mais ne matche pas le retour à la ligne par défaut. Utilisez le flag /s (ES2018+) ou des astuces de classes comme [\s\S] pour la compatibilité inter-moteurs quand vous devez matcher sur plusieurs lignes.
# Dot matches any char except newline (by default)
a.c # matches "abc", "a c", "a1c", "a@c"
a..c # four chars: a, any, any, c
# Dot matches newline only with /s flag (dotall)
/a.b/s # "a\nb" matches
# Match any character truly (with /s flag)
/[\s\S]/ # any char including newline (portable)
/[\d\D]/ # also any char
/[\w\W]/ # also any char
# Practical: any chars between tags
<div[\s\S]*?</div>Littéraux regex dans le code
En JS, /motif/flags est le plus courant. En Python, utilisez des chaînes brutes (r"") pour éviter le double échappement. Java exige des antislashs doubles dans les littéraux de chaînes. PHP utilise / comme délimiteur. Go utilise les backticks ou les chaînes "\\\\".
# JavaScript - regex literal
const re = /\bword\b/gi;
# JavaScript - constructor (for dynamic patterns)
const re2 = new RegExp("\\bword\\b", "gi");
# Python - raw string with re module
import re
pattern = r"\bword\b"
re.search(pattern, "a word here")
# Java - String needs double escaping
Pattern p = Pattern.compile("\\bword\\b");
# PHP - Perl-style
if (preg_match('/\\bword\\b/i', $text)) { }
# Go - RE2 syntax
re := regexp.MustCompile(`\\bword\\b`)Tester et matcher
test() en JS retourne un booléen, match() des correspondances. search() de Python trouve n'importe où, match() ancre au début, fullmatch() exige que toute la chaîne matche. Choisissez la bonne fonction selon votre intention.
# JavaScript
/abc/.test("abcdef") # true
"abcdef".match(/abc/) # ["abc", index: 0]
"abcabc".match(/abc/g) # ["abc", "abc"]
"abcdef".search(/abc/) # 0 (index)
# Python
import re
re.search(r"abc", "abcdef") # Match object or None
re.match(r"abc", "abcdef") # anchored at start
re.fullmatch(r"abc", "abc") # entire string
# Test if pattern matches anywhere
bool(re.search(r"abc", "xabcx")) # TrueClasses de caractères
Ensembles [abc]
Les crochets définissent un ensemble de caractères matchant tout caractère listé unique. À l'intérieur de [], la plupart des métacaractères (. * + ? etc.) perdent leur sens spécial et matchent littéralement. Seuls ] \ ^ et - sont spéciaux à l'intérieur.
# Match any single char from the set
[aeiou] # any vowel
[abc123] # any of a, b, c, 1, 2, 3
[ABC] # uppercase A, B, or C (case-sensitive)
# In a set, most metacharacters are literal
[.*+] # literal . * or +
[()] # literal ( or )
# Quantifiers work on sets
[aeiou]{2} # exactly two vowels
[0-9]+ # one or more digitsEnsembles niés [^abc]
Placer ^ juste après le [ ouvrant nie l'ensemble, matchant tout caractère NON listé. Le ^ doit être premier ; ailleurs dans l'ensemble c'est un caret littéral. Utile pour des motifs « jusqu'à X ».
# Caret at start negates the set
[^aeiou] # any char that is NOT a vowel
[^0-9] # any non-digit
[^\s] # any non-whitespace
[^a-zA-Z] # any non-letter
# Common: match up to a delimiter
[^,]+ # everything until next comma
[^;]+ # everything until next semicolon
[^"\\] # any char except quote or backslash
# Negation works with quantifiers
[^aeiou]+ # one or more non-vowelsPlages [a-z]
Un tiret entre deux caractères crée une plage basée sur les codes de caractères. Les plages vont du bas vers le haut. Pour matcher un tiret littéral dans un ensemble, mettez-le au début/fin ou échappez-le. Évitez [A-z] qui inclut des caractères non alphabétiques entre Z et a.
# Hyphen defines a range inside []
[a-z] # lowercase letter
[A-Z] # uppercase letter
[0-9] # digit (same as \d)
[a-zA-Z] # any letter
[a-zA-Z0-9] # alphanumeric
[a-fA-F0-9] # hexadecimal digit
# ASCII order matters
[A-z] # WARNING: includes [ \ ] ^ _ `
# Multiple ranges in one set
[a-zA-Z0-9_] # word character (same as \w)
# Literal hyphen: place at start or end, or escape
[-a-z] # hyphen or lowercase letter
[a-z-] # lowercase letter or hyphen
[a\-z] # a, hyphen, or zRaccourcis prédéfinis
Les raccourcis \d \w \s sont concis et lisibles. En mode Unicode (défaut en Python 3, JS avec /u), \d et \w matchent plus que l'ASCII. Utilisez re.ASCII en Python ou [0-9] explicitement pour de l'ASCII seul.
# Most common shorthands (work outside and inside [])
\d # digit [0-9]
\w # word char [a-zA-Z0-9_]
\s # whitespace [ \t\n\r\f\v]
\D # non-digit
\W # non-word char
\S # non-whitespace
# With ASCII-only flag (Python)
\d # Unicode digits by default
\d # [0-9] with re.ASCII flag
# Inside character classes
[\d\s] # digit or whitespace
[\w.] # word char or literal dot
[a-z\d] # letter or digit
# POSIX classes (PCRE, not JS)
[[:alpha:]] # letters
[[:digit:]] # digits
[[:alnum:]] # alphanumeric
[[:space:]] # whitespaceRaccourcis niés
Les versions majuscules \D \W \S nient leurs homologues minuscules. Elles incluent retours à la ligne et autres caractères. Si vous voulez « non chiffre mais aussi pas retour à la ligne », combinez explicitement comme [^\d\n].
# Uppercase versions are negations
\D # any non-digit [^0-9]
\W # any non-word char [^a-zA-Z0-9_]
\S # any non-whitespace [^\s]
# Useful for "match until X" patterns
\S+ # one or more non-whitespace (a word)
\D+ # one or more non-digits
\W # a single non-word char
# Combined with anchors
^\S+ # word at start of string
\S+$ # word at end of string
# Find non-word boundaries for tokenization
\W+ # split on punctuation/space
# Caveat: \D matches newlines too
[^\d\n] # non-digit AND non-newlineCombiner les classes
Les classes de caractères peuvent mêler plages, raccourcis et littéraux. L'ordre importe peu (sauf pour les plages et ^ en début). Utilisez-les pour bâtir des motifs pratiques comme e-mails, noms de fichiers et identifiants.
# Mix shorthands, ranges, and literals in []
[\w\s] # word char or whitespace
[a-z\d_] # lowercase, digit, or underscore
[\w.-] # word char, dot, or hyphen (e.g., domain)
[^\w\s] # neither word char nor whitespace (punctuation)
# Common practical classes
[A-Z][a-z]+ # Capitalized word
\d{1,3}\.\d{1,3} # version-like number
[\w.+-]+@\w+ # email-ish
# Hex color
#[a-fA-F0-9]{3,6}
# Match identifier (variable name)
[a-zA-Z_$][\w$]*
# Filename with extension
[\w.-]+\.[a-zA-Z]{1,5}Quantificateurs
Astérisque * (zéro ou plus)
* matche zéro ou plusieurs fois l'élément précédent. Gourmand par défaut — matche autant que possible. Ajoutez ? après pour le rendre paresseux (*?). Souvent combiné à ? pour des motifs « optionnels » comme https?://
# * matches 0 or more occurrences
ab*c # "ac", "abc", "abbc", "abbbbc"
\d* # zero or more digits
\s* # optional whitespace
[a-z]* # zero or more lowercase letters
# Useful for optional content
https?:// # http:// or https:// (note the ?)
color:\s*#?[a-f0-9]+ # color: #abc or color: abc
# * is greedy - matches as much as possible
<a.*> # from <a to LAST > on the line
# Make it lazy with ?
<a.*?> # from <a to FIRST > (lazy)
.*? # zero or more, lazy
# * on group
(ab)* # "", "ab", "abab", "ababab"Plus + (un ou plus)
+ exige au moins une correspondance (contrairement à * qui en autorise zéro). Utile pour « un ou plus » comme mots (\w+), nombres (\d+) ou suites d'espaces (\s+). La variante paresseuse +? s'arrête à la première correspondance.
# + matches 1 or more occurrences (at least one)
ab+c # "abc", "abbc", but NOT "ac"
\d+ # one or more digits (integer)
\w+ # one or more word chars (a word)
\s+ # one or more whitespace
# Common patterns
\w+@\w+ # simplistic email
\d+\.\d+ # decimal number
-?\d+ # optional sign + integer
[A-Z]+ # one or more uppercase
# Greedy by default - use +? for lazy
".+?" # quoted string (lazy: stops at first ")
".+" # greedy: matches to the LAST "
# + vs *: + requires at least one
a+ # "a", "aa", "aaa" (not "")
a* # "", "a", "aa", "aaa"Point d'interrogation ? (zéro ou un)
? rend l'élément précédent optionnel (0 ou 1). Placé après un autre quantificateur (*? +? ??), il rend ce quantificateur paresseux. Utile pour lettres optionnelles, signes, séparateurs et formes courtes/longues comme 'Nov'/'November'.
# ? matches 0 or 1 occurrence (optional)
colou?r # "color" or "colour"
https?:// # "http://" or "https://"
-?\d+ # integer with optional minus sign
[+-]?\d* # number with optional sign
# Make greedy quantifier lazy
.*? # lazy zero-or-more
.+? # lazy one-or-more
?? # lazy zero-or-one (rarely needed)
# Optional group
Nov(?:ember)? # "Nov" or "November"
Mr\.? # "Mr" or "Mr."
# Optional non-capturing group with separator
\d{4}[-/]?(\d{2}) # 2024-01 or 202401
# Chained optionals
a?b?c? # "", "a", "ab", "abc", "b", "bc", "c"Accolades {n,m}
Les accolades précisent les comptes exacts : {n} (exactement n), {n,m} (de n à m), {n,} (n ou plus), {0,m} (jusqu'à m). La plupart des moteurs traitent { comme littéral s'il ne forme pas un quantificateur valide. Toujours gourmand sauf ajout de ?.
# Exact count
\d{3} # exactly 3 digits
[a-z]{5} # exactly 5 lowercase letters
.{10} # exactly 10 of any char
# Range: min, max
\d{2,4} # 2 to 4 digits
\w{3,} # 3 or more word chars
.{0,5} # 0 to 5 of any char (same as.....?)
# Open-ended
\d{3,} # 3 or more digits
\s{1,} # one or more whitespace (same as \s+)
\d{0,} # zero or more (same as \d*)
# Practical patterns
\d{4}-\d{2}-\d{2} # date YYYY-MM-DD
\d{1,3}(?:\.\d{1,3}){3} # IPv4 address
\d{3}-\d{3}-\d{4} # US phone
[A-Fa-f0-9]{6} # 6 hex digits
\d{4,16} # 4-16 digit PIN
# Greedy by default - add ? for lazy
\d{2,4}? # match minimum (2)Quantificateurs gourmands
Les quantificateurs gourmands consomment le plus possible, puis reviennent en arrière pour laisser le reste du motif matcher. Cela peut causer des correspondances inattendues dans HTML/texte. Utilisez le paresseux (*? +?) ou soyez plus spécifique avec des classes pour éviter les problèmes.
# Quantifiers are greedy by default
# They match as MUCH as possible while allowing rest to match
".*" # in 'a "b" c "d" e', matches "b" c "d"
<a.*> # matches from <a to the LAST >
# Greedy backtracks to allow overall match
\d+\d # in "12345", \d+ takes "1234", last \d takes "5"
# Common greedy patterns
.* # entire line
.+ # entire line (at least 1 char)
\d+ # all consecutive digits
\w+ # all consecutive word chars
# Greedy can be a problem with HTML
<.*> # WRONG: matches <b>text</b> as one
<\w+> # better: matches just <b>
# Greedy with anchored end
^.*(end).*$ # .* takes everything, backtracks to find "end"Quantificateurs paresseux
Les quantificateurs paresseux (aussi dits non-gourmands ou réticents) matchent le moins possible, s'étendant seulement si nécessaire. Utilisez-les pour trouver la correspondance la plus courte comme le contenu entre guillemets/tags. Pour les chaînes quotées, '[^']*' est souvent plus clair et rapide que '.*?'.
# Add ? to make any quantifier lazy (match as LITTLE as possible)
*? # lazy zero-or-more
+? # lazy one-or-more
?? # lazy zero-or-one
{n,m}? # lazy range
# Lazy matches shortest possible
"<.*?>" # in 'a "b" c "d" e', matches "b" then "d"
<a.*?> # matches <a> to first >
# Compare: HTML tag matching
<.+> # greedy: <b>bold</b> matches as ONE
<.+?> # lazy: matches <b> then </b> separately
# Find quoted strings (lazy)
"([^"]*)" # alternative: chars that aren't a quote
# Lazy can be slower in some cases
# Prefer negated classes when possible:
"[^"]*" # often faster than ".*?"
# Multiple lazy on same line
(.*?)(.*?)(.*?) # all lazy, but each takes minimumAncres et frontières
Ancre de début ^
^ matche le début de la chaîne (ou de chaque ligne avec le flag /m). Assertion de largeur nulle — ne consomme pas de caractères. Ne confondez pas avec ^ dans [], qui nie la classe. Utilisez ^...$ pour valider des chaînes entières.
# ^ matches position at start of string (or line with /m)
^Hello # "Hello" only at the start
^\d+ # digits at the start
^https?:// # URL at start of string
# With multiline flag /m, ^ matches start of each line
^\s*$ # blank lines (with /m, matches each)
# Useful for validation (must start with)
^[A-Z] # must start with uppercase letter
^[a-zA-Z] # must start with a letter
# ^ inside [] is DIFFERENT (negation)
[^abc] # any char that is NOT a, b, or c
# Common validation: entire string is digits
^\d+$ # only digits, nothing else
# Line prefix matching (multiline)
^\s*#.* # comment lines starting with #Ancre de fin $
$ matche la fin de la chaîne (ou de ligne avec /m). Combinez ^...$ pour valider que toute la chaîne matche un motif. Attention aux alternances : ^a|b$ signifie (^a) OU (b$), utilisez ^(a|b)$ ou ^(?:a|b)$.
# $ matches position at end of string (or before final newline)
end$ # "end" only at the end
\.\w{2,4}$ # file extension at end
\d+$ # digits at the end
# With multiline flag /m, $ matches end of each line
\s*$ # trailing whitespace per line (with /m)
# Combine ^ and $ for full-string validation
^\d{4}$ # exactly 4 digits, nothing else
^[A-Z][a-z]+$ # Capitalized word, entire string
^yes|no$ # WARNING: this is (^yes) OR (no$)
# Fix the precedence issue:
^(?:yes|no)$ # entire string is "yes" or "no"
# Email-ish validation
^[\w.+-]+@[\w-]+\.[a-z]{2,}$
# Multiline: find empty lines
^$ # empty lines (with /m)Frontière de mot \b
\b est une assertion de largeur nulle matchant la frontière entre \w (caractère de mot) et \W (non-mot) ou les bords de chaîne. Parfait pour matcher des mots entiers sans matcher des sous-chaînes. L'underscore est un caractère de mot, donc 'foo_bar' est un seul mot pour \b.
# \b matches a position between a word char and non-word char
\bword\b # "word" but not "wording" or "sword"
\bcat # "cat" at start of word: cat, cats, but not scat
cat\b # "cat" at end of word: cat, scat, but not cats
\bcat\b # "cat" as a whole word only
# Useful for finding whole words
\bthe\b # "the" but not "theater" or "breathe"
# Find words of specific length
\b\w{4}\b # all 4-letter words
\b\w{4,}\b # all words with 4+ letters
# Boundary at start/end of identifier
\bUser\b # whole word "User"
\bid\b # whole word "id" (not "id" in "ride")
# Variable name as whole word
\bcount\b # "count" but not "discount" or "counter"
# Boundary between digit and non-digit
\b\d+\b # whole numbers onlyNon-frontière de mot \B
\B matche tout endroit qui n'est PAS une frontière de mot. Utile pour garantir qu'un motif n'est PAS au début/fin d'un mot. Rare mais puissant pour des cas précis comme 'cat' à l'intérieur d'un autre mot.
# \B is the opposite of \b - matches where there is NO word boundary
\Bword # "word" NOT at start of word: "sword", "password"
word\B # "word" NOT at end of word: "wording", "wordsword"
\Bword\B # "word" in middle of other word chars
# Find 'cat' inside another word only
\Bcat\B # matches in " concatenate " (middle 'cat')
# Useful for matching inside identifiers
\Ba\B # 'a' surrounded by word chars
# Position NOT at word boundary
\B-\B # hyphen between word chars (e.g., "well-known")
# Practical: hyphenated compound word
\w+\B-\B\w+ # NOT what you want for "well-known"
# \B at start of string with first char being non-word
\B. # any char that's NOT at a word boundary start
# Test password: 'a' must be inside word (rare)
\Ba\w+\B # 'a' not at word edgesAncres de chaîne \A \Z \z
\A et \z/\Z sont des ancres de chaîne absolues non affectées par le mode multiligne (Python, PCRE, Ruby, Java). \A est le début, \z la fin, \Z la fin-ou-avant-le-retour-final. JS les manque — utilisez ^ et $ (avec /m pour le mode ligne). Les ^ $ de Ruby sont toujours basés ligne.
# These anchors are NOT in JavaScript natively (use ^ and $)
# Available in Python, Java, PCRE, Ruby, etc.
\A # absolute start of string (not affected by /m)
\Z # end of string, or before final newline (Python/PCRE)
\z # absolute end of string (no newline tolerance)
# Python example
import re
re.search(r"\Ahello", "hello\nworld") # Match at start
re.search(r"world\Z", "hello\nworld\n") # Match (before final \n)
re.search(r"world\z", "hello\nworld\n") # No match (newline at end)
# Difference between ^ and \A with re.MULTILINE
text = "line1\nline2"
re.findall(r"^\w+", text, re.M) # ['line1', 'line2']
re.findall(r"\A\w+", text, re.M) # ['line1'] only
# JavaScript: only ^ and $ available
# Use ^ with /m for line starts
# Use $ with /m for line ends
# Ruby always treats ^ and $ as line anchors
# Use \A and \z for string anchors in RubyGroupes et captures
Groupes de capture ()
Les parenthèses () créent un groupe de capture qui enregistre le texte matché pour usage ultérieur. Les groupes se numérotent de gauche à droite à partir de 1. Utilisez-les pour extraire des parties d'une correspondance ou les référencer plus tard dans les remplacements ou backreferences.
# Parentheses create a capturing group
(abc) # matches "abc" and captures it
(\d+) # matches digits and captures them
(a)(b)(c) # three separate capture groups
# Group with quantifier
(ab)+ # "ab", "abab", "ababab" (whole group repeated)
(\d{2,4})- # 2-4 digits followed by hyphen
# Capturing in replacement (JS)
"2024-01-15".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3/$2/$1")
# Result: "15/01/2024"
# Capturing in Python
import re
m = re.search(r"(\w+)@(\w+)", "[email protected]")
m.group(1) # "user"
m.group(2) # "example"
m.groups() # ("user", "example")
# Backreference in same regex
(\w+)\s+\1 # repeated word: "hello hello"Numérotation des groupes
Les groupes se numérotent selon la position de leur parenthèse ouvrante, de gauche à droite. Les groupes externes/imbriquants précèdent leurs groupes internes. La syntaxe de remplacement varie : JS/Java utilisent $1, Python \1 (ou \g<1>), PHP accepte $1 et \1.
# Groups are numbered left-to-right by opening paren
(A)(B)(C) # group 1=A, 2=B, 3=C
((A)(B))(C) # group 1=AB, 2=A, 3=B, 4=C
# Nested groups: outer first, then inner
(\d{4})-(\d{2})-(\d{2}) # 1=year, 2=month, 3=day
((\d{1,3})\.){3}(\d{1,3}) # 1=last octet., 2=octet, 4=last octet
# Reference groups in replacement
# JavaScript: $1, $2, $3
"abc".replace(/(a)(b)(c)/, "$3$2$1") # "cba"
# Python: \1, \2 in re.sub; m.group(1)
re.sub(r"(\w+)@(\w+)", r"\2.\1", "user@host") # "host.user"
# Java: $1, $2 in replaceAll
"x".replaceAll("(x)", "$1$1") # "xx"
# PHP: $1 or \1 in preg_replace
preg_replace('/(\w+)@(\w+)/', '$2.$1', 'user@host')
# Whole match: $& (JS), \g<0> (Python), $0 (Java/PHP)Non capturant (?:...)
Utilisez (?:...) pour grouper sans capturer. Économise la mémoire, garde la numérotation de vos groupes de capture prévisible et signale l'intention. Surtout important avec des alternances ou quantificateurs sur des sous-motifs dont la valeur capturée ne compte pas.
# (?:...) groups WITHOUT capturing (saves memory, cleaner groups)
(?:abc)+ # "abc" repeated, but no capture
(?:\d{1,3}\.){3}\d{1,3} # IPv4, no extra captures
# Compare: capturing vs non-capturing
(\d{4})-(\d{2}) # 2 groups captured
(?:\d{4})-(?:\d{2}) # 0 groups captured (just match)
# Use non-capturing when you don't need the captured value
https?://(?:www\.)?(\w+) # capture just the domain
(?:Mr|Mrs|Ms)\.\s+\w+ # title prefix, no capture needed
# Combine with alternation
(?:cat|dog|bird)s? # plural animals, no capture
# With quantifier on alternation
(?:\d+\s*)+ # numbers separated by spaces
# Why use it?
# 1. Saves memory (no captured text stored)
# 2. Keeps group numbering clean
# 3. Documents intent: "this is just for grouping"Groupes nommés (?<name>...)
Les groupes nommés (?<nom>...) [JS/.NET] ou (?P<nom>...) [Python/PCRE] rendent les motifs auto-documentés. Référence par nom dans le remplacement ($<nom> en JS, \g<nom> en Python) et en backreferences (\k<nom> en JS, (?P=nom) en Python).
# Named capture group - JavaScript, .NET, Python 3.x style
(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
# Python uses (?P<name>...) - same as PCRE
(?P<year>\d{4})-(?P<month>\d{2})
# Reference in replacement
# JavaScript:
"2024-01-15".replace(
/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/,
"$<d>/$<m>/$<y>"
) # "15/01/2024"
# Python:
re.sub(
r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})",
r"\g<d>/\g<m>/\g<y>",
"2024-01-15"
) # "15/01/2024"
# Reference by name in same regex (backreference)
(?<word>\w+)\s+\k<word> # JS
(?P<word>\w+)\s+(?P=word) # Python
# Access named groups in Python
m = re.match(r"(?P<year>\d{4})", "2024")
m.group("year") # "2024"
m.groupdict() # {"year": "2024"}Alternance |
L'alternance | matche l'un de plusieurs motifs. Sa précédence est très basse, donc utilisez des parenthèses pour la délimiter. Les moteurs essaient les alternatives de gauche à droite et prennent la première qui permet à la correspondance globale de réussir — l'ordre compte quand les alternatives se recouvrent.
# | means OR - matches one of several alternatives
cat|dog|bird # "cat" OR "dog" OR "bird"
yes|no # "yes" or "no"
\d{2}|\d{4} # 2 digits OR 4 digits
# IMPORTANT: alternation has low precedence
^abc|def$ # means (^abc) OR (def$) — NOT ^abc$ or ^def$
# Use groups to scope alternation
^(abc|def)$ # entire string is "abc" or "def"
^(?:cat|dog)s?$ # "cat", "cats", "dog", "dogs"
# Order matters - first match wins
a|ab # in "ab", matches just "a" (leftmost wins)
ab|a # in "ab", matches "ab"
# Common: file extensions
\.(?:jpg|png|gif|bmp)$
# HTML tags
</?(?:div|span|p|a)\b
# Day names
(?:Mon|Tues?|Wed|Thurs?|Fri|Sat|Sun)day
# Number formats
\d{1,3}(?:,\d{3})*|\d+ # 1,234 or 1234Backreferences de groupes
Les backreferences (\1, \2 ou \k<nom>) matchent le même texte capturé par un groupe antérieur. Usages classiques : paires de tags HTML/XML, mots répétés, séparateurs cohérents. Le backreference doit matcher exactement ce que le groupe a capturé.
# \1, \2, etc. refer to a previous capturing group's match
(\w+)\s+\1 # repeated word: "hello hello"
<(\w+)>.*?</\1> # HTML tag matching: <div>...</div>
(["\'])[^\1]*\1 # quoted string (quote char remembered)
# Named backreferences
# JavaScript: \k<name>
(?<q>["\'])[^\k<q>]*\k<q> # quoted string with named ref
# Python: (?P=name)
(?P<q>["\'])[^\2]*?(?P=q) # similar (numbered ref still works)
# Practical: matching opening/closing tags
<b>(.*?)</\1> # WARNING: \1 is "b", but...
# Better: capture tag name
<([a-z][a-z0-9]*)\b[^>]*>[\s\S]*?</\1>
# Find duplicated words
\b(\w+)\s+\1\b # "the the", "is is"
# Match paired delimiters
(\[)[^\]]*\1\] # WRONG: matches "[[..[" — use \1 for SAME char
# Date with same separator
(\d{4})([-/])(\d{2})\2(\d{2}) # 2024-01-15 (same separator)Groupes non capturants
Non capturant de base
(?:...) groupe sans créer de capture. Utilisez-le dès que vous avez besoin de grouper pour une alternance ou un quantificateur sans vous soucier de la valeur matchée. Garde la numérotation prévisible et un peu plus rapide.
# (?:pattern) - group without capturing
(?:abc) # matches "abc", no capture
(?:foo|bar) # "foo" or "bar", no capture
# Compare
(\d{4})-(\d{2})-(\d{2}) # 3 capture groups
(?:\d{4})-(?:\d{2})-(?:\d{2}) # 0 capture groups (just match)
# When you only care about match/not-match
^(?:Yes|No|Maybe)$ # validate yes/no/maybe
https?://(?:www\.)?\w+ # URL prefix, only domain matters
# Keep capture numbers clean
(?:https?://)?(\w+) # group 1 = domain (prefix is non-capturing)
vs
(https?://)?(\w+) # group 1 = protocol, group 2 = domain
# Nested
(?:(?:foo|bar)-)?(\w+) # group 1 = word (after optional prefix)Avec quantificateurs
Les groupes non capturants se marient bien aux quantificateurs quand on veut répéter un sous-motif sans conserver le texte matché. Essentiel pour garder les numéros de groupes de capture prévisibles quand on extrait des parties précises d'un motif complexe.
# Apply quantifier to a non-capturing group
(?:abc)+ # "abc", "abcabc", "abcabcabc"
(?:\d{1,3}\.){3}\d{1,3} # IPv4: 3 groups of "ddd." then "ddd"
(?:\s*,\s*) # comma with optional surrounding whitespace
(?:\w+\s+)+\w+\.? # word sequence (sentence-ish)
# Compare: capturing group + quantifier keeps LAST match only
(\d,)+ # in "1,2,3,", group 1 captures "3," (last)
(?:\d,)+ # same match, no capture
# Optional group with separator
\d{4}(?:-\d{2}){2} # 2024-01-15 (no captures)
\d{4}(?:[-/]\d{2}){2} # 2024-01-15 or 2024/01/15
# Repeated pattern
(?:\d+\.)*\d+ # version number like 1.2.3
# Multiple non-capturing groups
^(?:Mr|Mrs|Ms|Dr)\.?\s+(?:[A-Z][a-z]+\s?)+$ # full name w/ title
# Avoid extra captures when extracting specific data
https?://(?:www\.)?([\w-]+)\.(?:com|org|net) # only capture domainGroupes imbriqués
Mêlez librement groupes non capturants et capturants. Les captures restent numérotées par ordre de parenthèse ouvrante, mais les groupes non capturants ne consomment pas de numéro. Utilisez cela pour garder vos numéros de capture serrés quand seules certaines parties comptent.
# Mix capturing and non-capturing groups
(?:(\d{4})-(\d{2})-(\d{2})) # outer non-cap, 3 inner captures
# group 1=year, 2=month, 3=day
# With alternation inside non-capturing
(?:https?|ftp)://([^/]+) # group 1 = host
# Date with optional time
(\d{4}-\d{2}-\d{2})(?:[ T](\d{2}:\d{2}))?
# group 1 = date, group 2 = optional time
# Practical: parse URL
(?:([^:]+)://)? # group 1: optional scheme
([^/?#]+) # group 2: host
(?:/([^?#]*))? # group 3: optional path
(?:\?([^#]*))? # group 4: optional query
(?:#(.*))? # group 5: optional fragment
# CSV-ish parser (simplified)
(?:^|,)(?:"([^"]*)"|([^,]*))
# group 1: quoted field, group 2: unquoted field
# Email-ish
(?:[\w.+-]+)@((?:[\w-]+\.)+[a-z]{2,})
# group 1 = domain (non-capturing group inside)Bénéfices de performance
Les groupes non capturants (?:...) sont légèrement plus rapides et moins gourmands car le moteur ne stocke pas le texte capturé. Le bénéfice est faible par correspondance mais peut compter dans des boucles serrées sur du grand texte. Utilisez-les dès que vous n'avez pas à référencer la valeur capturée.
# Non-capturing groups are slightly faster
# They skip storing the matched text
# Microbenchmark concept (Python)
import re, time
text = "a" * 1000
# Capturing version
r1 = re.compile(r"(a)+")
# Non-capturing version
r2 = re.compile(r"(?:a)+")
# Both match same text, but r2 is marginally faster
# More importantly: avoids unnecessary group data
# Use non-capturing when you don't need group(N)
# In hot loops, this matters:
patterns = [
r"(?:\s*,\s*)", # non-capturing
r"(\s*,\s*)", # capturing (waste if unused)
]
# When extraction IS needed, use capturing:
re.findall(r"(\w+)@(\w+)", "a@b c@d") # need the captures
# When only matching matters, use non-capturing:
re.search(r"(?:\d{1,3}\.){3}\d{1,3}", text) # just match test
# Replace with no group reference
re.sub(r"(?:\s)+", "_", "a b c") # "a_b_c" (no groups used)Cas d'usage courants
Les groupes non capturants excellent pour : grouper une alternance, appliquer des quantificateurs à des sous-motifs, sections optionnelles, et garder les numéros de capture propres. Défaut à (?:...) pour grouper — n'utilisez () que si vous devez vraiment extraire ou faire un backreference du texte.
# 1. Grouping for alternation
(?:cat|dog|bird)s? # plural animal names
\.(?:jpg|jpeg|png|gif)$ # image extensions
^(?:Mr|Mrs|Ms|Dr)\.\s # honorifics
# 2. Optional/required sub-patterns
https?://(?:www\.)? # protocol + optional www
\d{4}(?:-?\d{2}){2} # date with optional hyphens
# 3. Repeated complex sub-pattern
(?:\d{1,3}\.){3}\d{1,3} # IPv4
(?:\s*\d+\s*)+, # comma-separated numbers
# 4. Path-style patterns
(?:/[a-z][\w-]*)+ # URL path like /api/users/123
(?:\.\w+)+ # file.txt.bak (multiple extensions)
# 5. Quoted strings with escapes
"(?:[^"\\]|\\.)*" # double-quoted with escapes
# 6. Header parsing
^(\w+):\s*(.*)$ # name: value (just capture both)
# 7. Programming keyword + identifier
(?:const|let|var)\s+(\w+) # only capture the variable name
# 8. CSV with optional quotes
(?:^|,)(?:"([^"]*)"|([^,]*)) # capture quoted OR unquotedLookahead et lookbehind
Lookahead positif (?=)
Le lookahead positif (?=...) affirme que ce qui suit matche le motif, sans consommer de caractères. Utile pour trouver des motifs seulement quand ils sont suivis de quelque chose de précis, et pour la validation comme « doit contenir un chiffre » dans les règles de mot de passe.
# (?=...) - matches if pattern follows, WITHOUT consuming
foo(?=bar) # "foo" only if followed by "bar"
\d+(?=px) # digits only if followed by "px"
\w+(?=@) # word chars only if followed by "@"
# Lookahead doesn't consume - the next match starts after "foo"
"foobar".match(/foo(?=bar)/) # match: "foo", index 0
# Next search continues at index 3, "bar" is still there
# Multiple lookaheads (all must match)
\d+(?=\s)(?=.*\bUSD\b) # digit followed by space AND USD somewhere
# Password: must contain a digit
^(?=.*\d).{8,}$ # at least 8 chars, contains a digit
# Word boundary alternative using lookahead
\w+(?=\W|$) # word chars until non-word or end
# Find numbers not followed by units
\d+(?!px)(?!em) # number not followed by px or em
# Capture inside lookahead
(\w+)(?=(\W)) # word + capture the following non-word charLookahead négatif (?!)
Le lookahead négatif (?!...) affirme que ce qui suit NE matche PAS. Usages courants : exclure des mots précis, rejeter des motifs (comme « le mot de passe ne doit pas contenir password »), et matcher seulement quand quelque chose ne suit pas (ex. 'q' non suivi de 'u').
# (?!...) - matches if pattern does NOT follow
foo(?!bar) # "foo" only if NOT followed by "bar"
\d+(?!px) # digits NOT followed by "px"
\w+(?!@\w) # word NOT followed by @word
# Q-w-o-T: find "q" not followed by "u"
q(?!u) # matches "q" in "Iraq" but not "quiet"
# Negative lookahead for "not this word"
\b(?!and\b|or\b|not\b)\w+ # any word except "and", "or", "not"
# Number NOT followed by decimal
\d+(?!\.\d) # "100" in "100 " but not in "100.5"
# Email local part: no consecutive dots
^(?!.*\.\.)[\w.]+@ # reject "a..b@..."
# Password: must NOT contain "password"
^(?!.*password).{8,}$ # 8+ chars, no "password" substring
# Disallow specific file extensions
\.\w+(?!\.(?:exe|bat|dll)$) # not an executable extension
# Find "cat" not preceded by "scat" (would need lookbehind)
# but here: cat not FOLLOWED by "s" or "egory"
\bcat(?!s|egory)\bLookbehind positif (?<=)
Le lookbehind positif (?<=...) affirme que ce qui précède matche, sans consommer. Sert à trouver des motifs seulement quand ils viennent après quelque chose de précis. Beaucoup de moteurs (Java, vieux PCRE, Python < 3.7) exigent un lookbehind de longueur fixe ; JS (ES2018+), .NET et PCRE récent autorisent la longueur variable.
# (?<=...) - matches if pattern PRECEDES (without consuming)
(?<=\$)\d+ # digits preceded by "$"
(?<=#)\w+ # word chars preceded by "#" (hex color)
(?<=Mr\.)\s\w+ # word after "Mr."
# Lookbehind doesn't consume - match starts AFTER the prefix
"$100".match(/(?<=\$)\d+/) # match: "100", index 2
# Get value after specific label
(?<=total:\s*)\d+\.\d{2} # number after "total:"
# Find text inside quotes
(?<=")[^"]+(?=") # content between double quotes
# Currency amount
(?<=USD\s)\d+(?:\.\d{2})? # number after "USD "
# Capture domain after @
(?<=@)[\w.]+ # domain part of email
# Path segment after /api/
(?<=/api/)[^/?#]+ # resource name in URL
# IMPORTANT: many engines require FIXED-LENGTH lookbehind
# (?<=ab|abc) -- INVALID in some engines (variable length)
# (?<=ab|cd) -- OK in most (same length alternatives)
# (?<=\w+) -- INVALID (variable length) in old engines
# JavaScript (ES2018+), .NET, and newer PCRE allow variable lengthLookbehind négatif (?<!)
Le lookbehind négatif (?<!...) affirme que ce qui précède NE matche PAS. Utile pour exclure des correspondances selon le contexte, comme « trouver les nombres non précédés de $ » ou « trouver un mot ne faisant pas partie d'un identifiant plus grand ». Mêmes restrictions de longueur que le lookbehind positif dans les vieux moteurs.
# (?<!...) - matches if pattern does NOT precede
(?<!\$)\d+ # digits NOT preceded by "$"
(?<!\w)\w+ # word NOT preceded by word char (start of word)
(?<!Mr\.)\s\w+ # space+word NOT after "Mr."
# Find "cat" not preceded by "scat" or "concat"
(?<!s)cat\b # "cat" not preceded by "s" (matches "cat" alone)
# Number not preceded by a sign
(?<![-+])\d+ # unsigned numbers
# Word not after specific prefix
(?<!un)\w+ # word not preceded by "un"
# Currency validation
(?<!\d)\d{1,3}(?:,\d{3})*(?:\.\d{2})?(?!\d)
# number with thousand separators, not part of larger number
# Prevent matching substring inside larger identifier
(?<![_\w])count\b(?!er) # "count" not part of "counter"/"_count"
# Remove spaces NOT after periods
text.replace(/(?<!\.) +/g, " ")
# collapse double spaces unless after a period
# Find "and" not preceded by "&" (avoid matching "&" alone)
(?<!&)\b\w+\bMotifs de validation
Les lookaheads excellent en validation : chaque lookahead vérifie une règle depuis la même position de départ. Empilez plusieurs lookaheads au début (^) pour imposer des règles composées comme « le mot de passe doit avoir majuscule, chiffre, caractère spécial ». Le motif principal matche ensuite toute la chaîne.
# Lookarounds are perfect for "must contain" / "must not contain"
# Password: 8+ chars, 1+ uppercase, 1+ lowercase, 1+ digit
^(?=.*[A-Z])(?=.*[a-z])(?=.*\d).{8,}$
# Stronger: also require special char
^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$
# Must NOT contain "password" (case-insensitive)
^(?!.*password).{8,}$
# Email: must have @ and a dot after it
^(?=[^@]*@[^@]*\.[^@]*$).+$
# US phone: 10 digits possibly with separators
^(?=(?:\D*\d){10}\D*$)[\d\s()-]+$
# IPv4: 4 octets 0-255
^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$
# Hex color: 3 or 6 hex digits, optional #
^#?(?:[0-9a-fA-F]{3}){1,2}$
# Date: YYYY-MM-DD with basic validation
^(?!0000)\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$
# Username: 3-20 chars, alphanumeric + underscore, not starting with digit
^(?=[A-Za-z_])[A-Za-z0-9_]{3,20}$Limites du lookaround
Limites du lookbehind : beaucoup de moteurs exigent des motifs de longueur fixe (Python <3.7, Java, vieux PCRE). Les moteurs modernes (JS ES2018+, .NET, Python 3.7+, PCRE 4.5+) autorisent la longueur variable. Les lookarounds sont de largeur nulle — ils ne consomment ni n'avancent le curseur. Les groupes de capture à l'intérieur CAPTURENT bien.
# 1. Lookbehind must be FIXED LENGTH in many engines
# Python (before 3.7), Java, older PCRE
(?<=abc|abcd)x # INVALID - alternatives of different lengths
(?<=abc|def)x # OK - same length
# Python 3.7+, JS (ES2018+), .NET, PCRE 4.5+ allow variable length
(?<=\w+)x # OK in modern engines
# 2. Lookbehind CANNOT be unbounded
(?<=.*)x # INVALID in most engines (no quantifier)
# 3. Capture groups inside lookaround
# DO capture, but the lookahead itself doesn't consume
(\w+)(?=(\W)) # group 1 = word, group 2 = next non-word
# 4. JavaScript lookbehind support (ES2018+)
# Old Safari versions don't support lookbehind
# Use capturing alternative for old browsers:
# Instead of (?<=\$)\d+, use \$(\d+) and use group 1
# 5. Lookarounds are zero-width
# They don't move the cursor
"abc".match(/(?=a)a/) # match: "a"
"abc".match(/(?=a)b/) # no match (can't be both a and b)
# 6. Nested lookarounds (legal but complex)
(?=(?:.*\d){3}).+ # must contain at least 3 digits
# 7. Performance: lookarounds can be slow with catastrophic patterns
(?=(a+)+)b # avoid nested quantifiers in lookaheadSubstitution et remplacement
Remplacement simple
La syntaxe de remplacement varie selon le langage : JS utilise string.replace(regex, str), Python re.sub(motif, repl, chaîne), Java String.replaceAll, PHP preg_replace. Utilisez le flag global (g) pour remplacer toutes les correspondances ; sinon seule la première est remplacée.
# Replace in different languages
# JavaScript
"hello world".replace(/world/, "there") # "hello there"
"hello world".replace(/o/g, "0") # "hell0 w0rld"
# Python
import re
re.sub(r"world", "there", "hello world") # "hello there"
re.sub(r"o", "0", "hello world") # "hell0 w0rld"
# Java
"hello world".replaceAll("o", "0") # "hell0 w0rld"
# PHP
preg_replace('/o/', '0', 'hello world') # "hell0 w0rld"
# Replace first occurrence only
"hello world".replace(/o/, "0") # "hell0 world" (JS)
re.sub(r"o", "0", "hello world", count=1) # "hell0 world" (Py)
# Whole-match reference: $& (JS), $0 (Java/PHP), \g<0> (Py)
"abc".replace(/\w/g, "$&!") # "a!b!c!"
# Python: use a function
re.sub(r"\w", lambda m: m.group(0) + "!", "abc") # "a!b!c!"Remplacement par groupes de capture
Référencez les groupes de capture dans les remplacements : JS/Java utilisent $1, $2 ; Python \1, \2 ou \g<1> (préféré) ; PHP accepte $1 ou \1. Utilisez $& (JS) / $0 (Java) / \g<0> (Python) pour la correspondance entière. Pour un $ littéral en remplacement JS, utilisez $$.
# Reference captured groups in replacement
# JavaScript: $1, $2, ... for groups; $& for whole match
"2024-01-15".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3/$2/$1")
# Result: "15/01/2024"
# Swap two words
"hello world".replace(/(\w+) (\w+)/, "$2 $1") # "world hello"
# Python: \1, \2 OR \g<1>, \g<2> (preferred for clarity)
re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\3/\2/\1", "2024-01-15")
# Result: "15/01/2024"
# Java: $1, $2
"2024-01-15".replaceAll("(\d{4})-(\d{2})-(\d{2})", "$3/$2/$1")
# PHP: $1 or \1
preg_replace('/(\d{4})-(\d{2})-(\d{2})/', '$3/$2/$1', '2024-01-15')
# .NET: ${name} for named groups
# "John".Replace(...) uses ${first} if pattern is (?<first>\w+)
# Use $& (JS) or $0 (Java) for entire match
"hello".replace(/\w/g, "[$&]") # "[h][e][l][l][o]"
# Literal $ in replacement (JS) - use $$
"price".replace(/price/, "$$100") # "$100"Remplacement par groupes nommés
Groupes nommés dans les remplacements : JS utilise $<nom>, Python \g<nom>, Java/.NET ${nom}. PHP ne supporte pas les références nommées dans le remplacement — utilisez des numérotés ($1, $2). Les remplacements nommés sont bien plus lisibles, surtout pour des motifs complexes à nombreux groupes.
# Reference named capture groups in replacement
# JavaScript: $<name>
"2024-01-15".replace(
/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/,
"$<d>/$<m>/$<y>"
) # "15/01/2024"
# Python: \g<name>
re.sub(
r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})",
r"\g<d>/\g<m>/\g<y>",
"2024-01-15"
) # "15/01/2024"
# .NET: ${name}
Regex.Replace("2024-01-15",
@"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})",
"${d}/${m}/${y}")
# PHP: \k<name> in pattern, but in replacement use \1 or $1
# (PHP doesn't directly support named backrefs in replacement)
preg_replace(
'/(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})/',
'$3/$2/$1', # use numbered refs
'2024-01-15'
)
# Java: ${name} (Java 7+)
"2024-01-15".replaceAll(
"(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})",
"${d}/${m}/${y}")
# Swap using named groups
"John Doe".replace(/(?<first>\w+) (?<last>\w+)/, "$<last>, $<first>")
# "Doe, John"Remplacer toutes les occurrences
La sémantique du replace-all diffère : JS exige le flag /g (ou replaceAll), re.sub de Python fait tout par défaut (count= pour limiter), replaceAll de Java fait regex/tout tandis que replace fait littéral/tout, preg_replace de PHP fait tout par défaut ($limit). Vérifiez toujours si votre replace fait premier-seulement ou tout.
# Replace ALL matches - critical difference between languages
# JavaScript: needs /g flag for replaceAll behavior
"a-b-c".replace(/-/g, "+") # "a+b+c"
"a-b-c".replace(/-/, "+") # "a+b-c" (only first!)
# JavaScript: .replaceAll (ES2021+) requires /g flag
"a-b-c".replaceAll("-", "+") # "a+b+c" (string pattern)
"a-b-c".replaceAll(/-/g, "+") # "a+b+c" (regex needs /g)
# Python: re.sub replaces ALL by default
re.sub(r"-", "+", "a-b-c") # "a+b+c"
# Use count parameter for limited replacement
re.sub(r"-", "+", "a-b-c", count=1) # "a+b-c"
re.sub(r"-", "+", "a-b-c", count=2) # "a+b+c" wait, just first 2
# Java: replaceAll takes a regex
"a-b-c".replaceAll("-", "+") # "a+b+c"
# replaceFirst for just one
"a-b-c".replaceFirst("-", "+") # "a+b-c"
# Note: String.replace (no "All") does literal replace of ALL
"a-b-c".replace("-", "+") # "a+b+c" (literal, not regex)
# PHP: preg_replace replaces all by default
preg_replace('/-/', '+', 'a-b-c') # "a+b+c"
# Use $limit parameter
preg_replace('/-/', '+', 'a-b-c', 1) # "a+b-c"
# Go (noreplaceAll in regexp package)
re := regexp.MustCompile("-")
re.ReplaceAllString("a-b-c", "+") # "a+b+c"Remplacement par fonction
Les remplacements par fonction permettent des transformations dynamiques : conversion de casse, arithmétique, lookups. JS transmet (match, groupes, offset, string) à la fonction. Python transmet un objet match — utilisez .group(n) pour accéder aux captures. Java utilise Matcher.appendReplacement ; PHP preg_replace_callback.
# Use a function for dynamic replacement (JS, Python)
# JavaScript: function receives (match, g1, g2, ..., offset, string)
"hello world".replace(/\w+/g, w => w.toUpperCase())
# "HELLO WORLD"
# Reverse each word
"hello world".replace(/\w+/g, w => w.split("").reverse().join(""))
# "olleh dlrow"
# Increment numbers
"a1 b2 c3".replace(/\d/g, d => parseInt(d) + 1)
# "a2 b3 c4"
# Python: function receives a match object
import re
re.sub(r"\w+", lambda m: m.group(0).upper(), "hello world")
# "HELLO WORLD"
# Use captured groups in Python function
def swap(m):
return f"{m.group(2)} {m.group(1)}"
re.sub(r"(\w+) (\w+)", swap, "hello world") # "world hello"
# Java: Matcher.appendReplacement with StringBuilder
Matcher m = Pattern.compile("\\d+").matcher("a1 b2");
StringBuilder sb = new StringBuilder();
while (m.find()) {
m.appendReplacement(sb, String.valueOf(Integer.parseInt(m.group()) + 10));
}
m.appendTail(sb); # "a11 b12"
# PHP: preg_replace_callback
preg_replace_callback('/\d+/', function($m) {
return $m[0] + 10;
}, 'a1 b2'); # "a11 b12"Motifs de remplacement courants
Remplacements regex courants : rogner les espaces, compacter les espaces, retirer le HTML, conversion de casse (kebab↔camel↔snake), masquage de données sensibles, formatage de nombres/téléphones, échappement des métacaractères. Chacun utilise groupes de capture et références de remplacement pour des transformations propres et déclaratives.
# Trim leading/trailing whitespace
" hi ".replace(/^\s+|\s+$/g, "") # "hi"
# Collapse multiple spaces into one
"a b c".replace(/\s+/g, " ") # "a b c"
# Replace newlines with <br>
"text\nmore".replace(/\n/g, "<br>") # "text<br>more"
# Strip HTML tags
"<p>Hello</p>".replace(/<[^>]+>/g, "") # "Hello"
# Convert kebab-case to camelCase
"my-variable".replace(/-([a-z])/g, (_, c) => c.toUpperCase())
# "myVariable"
# CamelCase to snake_case
"myVar".replace(/([A-Z])/g, "_$1").toLowerCase()
# "my_var"
# Escape regex metacharacters
"1.5".replace(/[.*+?^${}()|[\]\\]/g, "\\$&") # "1\\.5"
# Mask emails: hide local part
"user@host".replace(/(^.).+(@.+)/, "$1***$2") # "u***@host"
# Format phone: 1234567890 -> 123-456-7890
"1234567890".replace(/(\d{3})(\d{3})(\d{4})/, "$1-$2-$3")
# URL-encode unsafe characters
"hello world".replace(/[^A-Za-z0-9]/g, c => "%" + c.charCodeAt(0).toString(16))
# "hello%20world"Flags
Global g
Le flag g (JS) fait travailler match() et replace() sur TOUTES les correspondances, pas seulement la première. Note : g rend la regex avec état via lastIndex — réutiliser le même objet regex entre appels exec() peut causer des bugs. Utilisez matchAll (ES2020+) pour une itération plus sûre. Python utilise re.findall / re.finditer ; Java replaceAll.
# g flag - match ALL occurrences, not just the first
# JavaScript
"abcabc".match(/a/g) # ["a", "a"] (all matches)
"abcabc".match(/a/) # ["a"] (first match only)
"a-b-c".replace(/-/g, "+") # "a+b+c"
# Without /g, replace() only does first match
"a-b-c".replace(/-/, "+") # "a+b-c"
# With /g, .match returns array of all matches (or null)
"aaa".match(/a/g) # ["a", "a", "a"]
# WARNING: /g with exec() maintains lastIndex state (gotcha)
const re = /a/g;
re.exec("aaa") # index 0, lastIndex=1
re.exec("aaa") # index 1, lastIndex=2
re.exec("aaa") # index 2, lastIndex=3
re.exec("aaa") # null, lastIndex=0 (resets)
# Use String.matchAll (ES2020+) for safer iteration
const matches = "aaa".matchAll(/a/g);
for (const m of matches) console.log(m.index);
# Python (re.sub finds all by default; re.findall)
re.findall(r"a", "aaa") # ["a", "a", "a"]
re.finditer(r"a", "aaa") # iterator of match objects
# Java: replaceAll = with /g; replaceFirst = without
# PHP: preg_match_all = with /g; preg_match = without
preg_match_all('/a/', 'aaa', $m) # finds allInsensible à la casse i
Le flag i rend le matching insensible à la casse. Utilisez (?i) en ligne pour une insensibilité délimitée (ex. abc(?i)def rend seulement 'def' insensible). La plupart des moteurs supportent (?i:...) pour des flags en ligne délimités. Courant pour tags HTML, e-mails et recherche insensible à la casse.
# i flag - ignore case
/abc/i.test("ABC") # true
/abc/i.test("AbC") # true
# Match HTML tags case-insensitively
/<div>/i.test("<DIV>") # true
text.replace(/<br\s*\/?>/gi, "\n") # <br>, <BR>, <Br/>
# Case-insensitive word match
"Hello hello HELLO".match(/hello/gi) # ["Hello", "hello", "HELLO"]
# Email is case-insensitive in practice
"[email protected]".match(/^[\w.+-]+@[\w.-]+\.[a-z]{2,}$/i)
# Python
re.search(r"abc", "ABC", re.IGNORECASE) # match
re.IGNORECASE # constant
re.I # shorthand
# Java
"ABC".matches("(?i)abc") # true (inline flag)
Pattern.compile("abc", Pattern.CASE_INSENSITIVE)
# Inline flags (most engines): (?i)
# (?i)abc == /abc/i
# abc(?i)def == abc plus case-insensitive def
# (?i:abc) == case-insensitive abc (PCRE/Java, scoped)
# PHP: '/abc/i'
preg_match('/abc/i', 'ABC') # 1 (match)
# Go (RE2): always use FlagI
re := regexp.MustCompile("(?i)abc")
re.MatchString("ABC") # true
# .NET
Regex.Match("ABC", "abc", RegexOptions.IgnoreCase)Multiligne m
Le flag m fait matcher ^ et $ à chaque frontière de ligne (retour à la ligne), pas seulement début/fin de chaîne. Utile pour traiter du contenu basé ligne. Forme en ligne : (?m). Note : m n'affecte PAS le point . — c'est le rôle du flag s (dotall).
# m flag - ^ and $ match start/end of EACH LINE (not just string)
# Without /m: ^ and $ are string-anchored
"line1\nline2".match(/^\w+/) # ["line1"] (only first line)
"line1\nline2".match(/^\w+/gm) # ["line1", "line2"] (each line)
# Find empty lines
"text\n\nmore".match(/^$/gm) # [""] (the empty line)
# Comment lines in code
"^#.*" with /gm finds all lines starting with #
# Process each line: replace leading whitespace
" a\n b\n c".replace(/^\s+/gm, "")
# "a\nb\nc"
# JavaScript
"hello\nworld".replace(/^/gm, "> ")
# "> hello\n> world"
# Python (re.MULTILINE)
re.findall(r"^\w+", "line1\nline2", re.MULTILINE)
# ["line1", "line2"]
re.M # shorthand
# Java: Pattern.MULTILINE
Pattern p = Pattern.compile("^\w+", Pattern.MULTILINE)
# Inline: (?m)
# (?m)^\w+ == with /m flag
# PHP: '/^\w+/m'
# Go: (?m) inline
# .NET: RegexOptions.Multiline
# IMPORTANT: m does NOT change . (use s flag for that)
# m affects ^ and $; s affects .Dotall s
Le flag s (dotAll) fait matcher . aussi le retour à la ligne. ES2018+ en JS, re.DOTALL/re.S en Python, Pattern.DOTALL en Java. De façon déroutante, .NET l'appelle 'Singleline'. Indépendant du flag m (multiligne) — on peut utiliser les deux. Alternative portable sans /s : utilisez [\s\S] ou [\d\D] pour matcher tout caractère y compris le retour à la ligne.
# s flag - dot . matches ALL chars INCLUDING newline
# Without /s: . doesn't match newline
"a\nb".match(/a.b/) # null
"a\nb".match(/a.b/s) # ["a\nb"] (with /s)
# Match anything between tags (even across lines)
"<div>a\nb</div>".match(/<div>(.*?)<\/div>/s)
# captures "a\nb"
# JavaScript (ES2018+) - s flag
const re = /<div>[\s\S]*?<\/div>/ # traditional
const re2 = /<div>.*?<\/div>/s # with /s
# Python: re.DOTALL or re.S
re.search(r"<div>.*?</div>", text, re.DOTALL)
# Inline: (?s)
# (?s). matches any char including newline
# Java: Pattern.DOTALL
Pattern.compile(".*?", Pattern.DOTALL)
# PHP: '/.*/s'
# Go: (?s) inline
# .NET: RegexOptions.Singleline
# Naming is confusing:
# - JavaScript "s" = "dotAll" (dot matches all)
# - .NET "Singleline" = same (dot matches all)
# - Multiline (m) and Singleline (s) are INDEPENDENT
# - You can use BOTH /ms simultaneously
# Combine m and s
"line1\nline2".replace(/^.*/gms, "X")
# replaces each line entirely with "X"
# Portable alternative (works everywhere): [\s\S] or [\d\D]
/.?[\s\S]*?</tag>/ # portable "any char"Unicode u
Le flag u (JS ES6+) traite les motifs comme points de code Unicode, corrigeant les problèmes de paires de substitution et activant les échappements de propriétés \p{...}. Python 3 est Unicode par défaut (re.ASCII pour restreindre). PHP utilise /u pour l'UTF-8. Sans /u, JS matche des unités de code UTF-16 — gestion cassée des emoji/CJK.
# u flag - treat pattern as Unicode code points (not UTF-16 code units)
# JavaScript (ES6+)
# Without /u: matches UTF-16 code units (broken surrogate pairs)
"𝌆".length # 2 (surrogate pair)
/^.$/.test("𝌆") # false (two code units)
/^.$/u.test("𝌆") # true (one code point)
# Unicode property escapes (require /u)
/^\p{L}+$/u.test("Hello") # true (letters)
/\p{Script=Han}/u.test("中文") # true (CJK characters)
/\p{Emoji}/u.test("👋") # true
# Case-insensitive Unicode folding
/\w/iu.test("Ω") # true (Σ/σ/ς equivalence with /iu)
# Python 3: Unicode by default (use re.ASCII for ASCII-only)
re.search(r"\w+", "日本語") # matches (Unicode default)
re.search(r"\w+", "日本語", re.ASCII) # ASCII-only
# Python Unicode properties (3.13+ or regex module)
# \p{L} requires regex module or Python 3.13+
import regex # third-party module
regex.search(r"\p{L}+", "Hello")
# Java: Pattern.UNICODE_CHARACTER_CLASS
Pattern.compile("\\w+", Pattern.UNICODE_CHARACTER_CLASS)
# Java's \w is Unicode by default; flag enables POSIX Unicode classes
# PHP: /u flag for UTF-8 mode
preg_match('/^\p{L}+$/u', 'Hello') # 1 (Unicode)
# .NET: \p{L} works by default
# Go (RE2): \p{L} works by default
# IMPORTANT: with /u in JS, quantifiers apply to code points
/[😂]{2}/u.test("😂😂") # trueSticky y et étendu x
Le flag sticky y (JS seulement) matche exactement à lastIndex — utile pour parseurs/tokenizers. Le flag étendu x ignore les espaces non échappés et traite # comme début de commentaire, permettant des motifs documentés multi-lignes. Python utilise re.VERBOSE, PHP/PCRE /x, forme en ligne (?x).
# y flag (sticky) - JS only - matches at lastIndex exactly
const re = /abc/y;
re.lastIndex = 0;
re.test("abcabc") # true, lastIndex now 3
re.test("abcabc") # true, lastIndex now 6 (matches at exactly 3)
re.test("abcabc") # false (would need to start at 6, no chars left)
# Useful for tokenizers (must match in sequence)
function tokenize(str) {
const tokens = [];
const ws = /\s*/y;
const num = /\d+/y;
const op = /[+\-*/]/y;
let pos = 0;
while (pos < str.length) {
ws.lastIndex = pos; let m = ws.exec(str);
if (m) pos = ws.lastIndex;
if (pos >= str.length) break;
num.lastIndex = pos; m = num.exec(str);
if (m) { tokens.push(["num", m[0]]); pos = num.lastIndex; continue; }
op.lastIndex = pos; m = op.exec(str);
if (m) { tokens.push(["op", m[0]]); pos = op.lastIndex; continue; }
throw new Error("Unexpected at " + pos);
}
return tokens;
}
# x flag (extended) - whitespace in pattern ignored, # starts comment
# JavaScript: ES2025+ proposal; widely supported in other engines
# Python (re.VERBOSE)
pattern = r"""
\d{4} # year
- # separator
\d{2} # month
- # separator
\d{2} # day
"""
re.match(pattern, "2024-01-15", re.VERBOSE)
# PHP: /x flag
preg_match('/
\d{4} # year
-
\d{2} # month
/x', '2024-01')
# Inline: (?x)
# (?x)\d{4}-\d{2} # comment allowed
# To match literal whitespace in /x mode, escape: \ or use [ ]
# \ \t\n all still work; just unescaped space/tab are ignoredMotifs courants
La regex d'e-mail est notoirement difficile — la regex RFC 5322 complète est énorme. La plupart du code de production utilise un motif simplifié qui attrape les cas invalides courants. La seule vraie validation est d'envoyer un e-mail avec un lien de confirmation. Rejetez les formats clairement mauvais mais soyez tolérant sur les cas limites.
# Simplified email (good for most uses)
^[\w.+-]+@[\w.-]+\.[a-zA-Z]{2,}$
# More strict
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
# RFC 5322 (simplified - the actual RFC is much more complex)
^(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+
(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*)
@
(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+
[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$
# JavaScript
const emailRe = /^[\w.+-]+@[\w.-]+\.[a-zA-Z]{2,}$/;
emailRe.test("[email protected]") # true
emailRe.test("[email protected]") # true
# Python
import re
re.match(r"^[\w.+-]+@[\w.-]+\.[a-z]{2,}$", "[email protected]", re.I)
# Practical note: the only true validation is sending an email.
# Reject clearly invalid formats, but accept edge cases.
# Common TLD length: 2-24 chars (newer TLDs can be long)
^[\w.+-]+@[\w.-]+\.[a-zA-Z]{2,24}$URL
La regex d'URL va du simple (https?://...) au complexe conforme RFC. En production, préférez la classe URL intégrée (JS) ou urllib.parse (Python). Avec une regex, capturez séparément scheme/host/port/path/query/fragment pour un parsing complet. Regex de domaine : étiquettes jusqu'à 63 caractères, TLD 2+ lettres.
# Basic URL pattern
^https?://[\w.-]+(?:\.[a-z]{2,})?(:\d+)?(?:/\S*)?$
# More complete URL parser
^(?:(\w+)://)? # 1: scheme
([^/:?#]+) # 2: host
(?::(\d+))? # 3: port
([^?#]*) # 4: path
(?:\?([^#]*))? # 5: query
(?:#(.*))? # 6: fragment
$
# JavaScript URL parsing
const urlRe = /^(https?):\/\/([^/:?#]+)(?::(\d+))?
([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/ix;
const m = "https://example.com:8080/path?q=1#top".match(urlRe);
// m[1]="https", m[2]="example.com", m[3]="8080",
// m[4]="/path", m[5]="q=1", m[6]="top"
# Python
import re
url_re = re.compile(r'''
^(?P<scheme>https?)://
(?P<host>[^/:?#]+)
(?::(?P<port>\d+))?
(?P<path>[^?#]*)
(?:\?(?P<query>[^#]*))?
(?:\#(?P<frag>.*))?
$''', re.VERBOSE | re.IGNORECASE)
# Match domain only
^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$
# Validate URL using built-in URL class (JS)
try { new URL(input); } catch { /* invalid */ }Numéro de téléphone
Les formats de téléphone varient beaucoup par pays. US : 10 chiffres avec séparateurs/indicatif optionnels. International E.164 : + puis jusqu'à 15 chiffres. Pour une vraie validation, normalisez d'abord (retirez les non-chiffres) puis vérifiez compte de chiffres et préfixe. Les API/bibliothèques téléphoniques sont plus fiables que la regex en production.
# US phone: 123-456-7890, (123) 456-7890, 1234567890
^(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$
# Capture components
^(?:\+1[-.\s]?)?\(?\(?(\d{3})\)?[-.\s]?(\d{3})[-.\s]?(\d{4})$
# International (E.164): +[country][number], max 15 digits
^\+[1-9]\d{1,14}$
# China phone: 11 digits starting with 1
^1[3-9]\d{9}$
# UK phone: 0XXXXXXXXXX or +44XXXXXXXXXX
^(?:0|\+44)\d{10}$
# Generic international (loose)
^\+?[\d\s().-]{7,}$
# JavaScript
const phoneRe = /^(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$/;
phoneRe.test("(123) 456-7890") # true
phoneRe.test("123-456-7890") # true
phoneRe.test("1234567890") # true
# Python: extract phone from text
re.findall(r"\b\d{3}[-.]?\d{3}[-.]?\d{4}\b", text)
# Format phone: 1234567890 -> (123) 456-7890
"1234567890".replace(/(\d{3})(\d{3})(\d{4})/, "($1) $2-$3")Adresse IP
La regex IPv4 utilise l'alternance pour imposer 0-255 par octet : 25[0-5] pour 250-255, 2[0-4]\d pour 200-249, 1?\d?\d pour 0-199. IPv6 est bien plus complexe (avec le raccourci ::). Pour la détection d'IP privées : 10.x, 172.16-31.x, 192.168.x. Utilisez le module ipaddress (Python) ou net (JS) pour un parsing robuste.
# IPv4: four octets 0-255
^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}
(?:25[0-5]|2[0-4]\d|1?\d?\d)$
# Explanation:
# 25[0-5] -> 250-255
# 2[0-4]\d -> 200-249
# 1?\d?\d -> 0-199 (1? optional leading 1, \d? optional tens)
# Python
import re
ipv4_re = re.compile(
r'^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$'
)
ipv4_re.match("192.168.1.1") # match
ipv4_re.match("256.0.0.1") # None (256 > 255)
# Extract IPv4 from text
re.findall(r'\b(?:\d{1,3}\.){3}\d{1,3}\b', text)
# IPv6 (simplified)
^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$
# (:: shorthand, mixed notation are more complex)
# JavaScript
const ipv4 = /^(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)$/;
ipv4.test("0.0.0.0") # true
ipv4.test("255.255.255.255") # true
ipv4.test("256.0.0.0") # false
# Convert IP to number
"192.168.1.1".split(".").reduce((acc, o) => (acc << 8) + +o, 0) >>> 0
# Private IP ranges
^(?:10\.|172\.(?:1[6-9]|2\d|3[01])\.|192\.168\.)Couleur hexadécimale
Regex de couleur hex : # suivi de 3 ou 6 chiffres hex. Utilisez {3,6} avec prudence (il autorise aussi 4 et 5). Mieux : (?:[0-9a-fA-F]{3}){1,2} impose exactement 3 ou 6. Pour le support 8 chiffres (RGBA), utilisez [0-9a-fA-F]{3,4} ou {8}. Les couleurs CSS peuvent aussi être hsl(), rgb(), nommées — utilisez un parseur CSS en production.
# Hex color: #RGB or #RRGGBB
^#?(?:[0-9a-fA-F]{3}){1,2}$
# Strict with #
^#(?:[0-9a-fA-F]{3}){1,2}$
# With optional alpha: #RGBA or #RRGGBBAA
^#(?:[0-9a-fA-F]{3,4}){1,2}$
# Capture RGB components
^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$
# JavaScript
const hexRe = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
hexRe.test("#fff") # true
hexRe.test("#FFAABB") # true
hexRe.test("#12AB56") # true
hexRe.test("#GGG") # false
hexRe.test("fff") # false (no #)
# Allow without #
const hexLoose = /^#?[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?$/
# Extract hex colors from CSS
const css = "color: #fff; background: #123456;";
const colors = css.match(/#[0-9a-fA-F]{3,6}/g);
// ["#fff", "#123456"]
# Convert #RGB to #RRGGBB
"#abc".replace(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i, "#$1$1$2$2$3$3")
// "#aabbcc"
# Python
import re
re.match(r"^#(?:[0-9a-fA-F]{3}){1,2}$", "#abc123")ZIP / code postal
Les formats de codes postaux varient par pays : le ZIP US est 5 chiffres avec +4 optionnel ; le Canada est lettre-chiffre-lettre espace chiffre-lettre-chiffre ; les codes postaux UK sont complexes. Validez contre le format officiel du pays. Pour des apps multi-pays, choisissez une regex par pays plutôt qu'un méga-motif.
# US ZIP: 12345 or 12345-6789
^\d{5}(?:-\d{4})?$
# Canada postal: A1A 1A1 (letter digit letter space digit letter digit)
^[A-Za-z]\d[A-Za-z][ -]?\d[A-Za-z]\d$
# UK postcode (simplified)
^[A-Z]{1,2}\d[A-Z\d]? ?\d[A-Z]{2}$
# China postal code: 6 digits
^\d{6}$
# Germany: 5 digits
^\d{5}$
# France: 5 digits
^\d{5}$
# Australia: 4 digits
^\d{4}$
# JavaScript
const zipRe = /^\d{5}(?:-\d{4})?$/;
zipRe.test("12345") # true
zipRe.test("12345-6789") # true
zipRe.test("1234") # false
# Canada postal
const caRe = /^[A-Za-z]\d[A-Za-z][ -]?\d[A-Za-z]\d$/;
caRe.test("M5V 2H1") # true
caRe.test("m5v2h1") # true
# Python
import re
re.match(r"^\d{5}(?:-\d{4})?$", "12345-6789") # match
# Format ZIP: 123456789 -> 12345-6789
"123456789".replace(/(\d{5})(\d{4})/, "$1-$2")Validation de mot de passe
Longueur minimale
La longueur minimale est la règle de mot de passe la plus importante. Les recommandations modernes (NIST) conseillent au moins 8 caractères, en encourageant des phrases de passe plus longues (12-16+). Combinez avec des lookaheads pour les règles composées. Le lookahead (?=.{8,}$) affirme la longueur sans consommer, permettant aux autres règles de vérifier aussi depuis le début.
# At least 8 characters
^.{8,}$
# At least 12 characters (modern recommendation)
^.{12,}$
# Between 8 and 128 characters
^.{8,128}$
# Using lookahead (allows combining with other rules)
^(?=.{8,}$).*$
# JavaScript
const lenRe = /^.{8,}$/;
lenRe.test("short") # false
lenRe.test("longenough") # true
# Python
import re
bool(re.match(r"^.{8,}$", "longenough")) # True
# Allow any character including newlines (use s flag or [\s\S])
# /^.{8,}$/s matches multi-line password
# Common: 8+ with at least one of each type (lookaheads)
^(?=.{8,}$) # at least 8 chars
(?=.*[a-z]) # at least one lowercase
(?=.*[A-Z]) # at least one uppercase
(?=.*\d) # at least one digit
(?=.*[^A-Za-z0-9]) # at least one special char
.*$Exigence de majuscule
Exigez une majuscule avec le lookahead (?=.*[A-Z]). Pour N majuscules : (?=(?:.*[A-Z]){N}). Pour les majuscules Unicode (grec, cyrillique, etc.), utilisez \p{Lu} avec le flag u (JS) ou le module regex (Python). Sans lookahead, testez/comptez séparément pour un code plus propre.
# Must contain at least one uppercase letter
^(?=.*[A-Z]).*$
# Must contain at least one uppercase, 8+ chars
^(?=.*[A-Z]).{8,}$
# At least two uppercase letters
^(?=(?:.*[A-Z]){2}).*$
# JavaScript
const upperRe = /^(?=.*[A-Z]).{8,}$/;
upperRe.test("password") # false (no uppercase)
upperRe.test("Password") # true
upperRe.test("PASSWORD") # true
# Python
import re
bool(re.match(r"^(?=.*[A-Z]).{8,}$", "Password1")) # True
# Count uppercase letters
const uppers = (pwd) => (pwd.match(/[A-Z]/g) || []).length;
uppers("PassWord") # 2
# Allow Unicode uppercase (with /u flag in JS)
const unicodeUpper = /^(?=.*\p{Lu}).+$/u;
unicodeUpper.test("Ωμέγα") # true (Ω is uppercase Greek)
# Python Unicode uppercase
re.search(r"\p{Lu}", "Ωμέγα", regex.UNICODE) # needs 'regex' module
# .NET: \p{Lu} for any uppercase letter
# Java: \p{Lu} works with Pattern.UNICODE_CHARACTER_CLASS
# Without lookahead: just count
if (/[A-Z]/.test(password)) { /* has uppercase */ }Exigence de chiffre
Exigez des chiffres avec (?=.*\d). Pour N chiffres : (?=(?:.*\d){N}). \d matche les chiffres Unicode en mode par défaut — utilisez [0-9] pour de l'ASCII seul. Beaucoup trouvent des appels test() séparés plus clairs que d'empiler des lookaheads : chaque règle se lit comme une vérification booléenne unique.
# Must contain at least one digit
^(?=.*\d).*$
# At least one digit, 8+ chars
^(?=.*\d).{8,}$
# At least three digits
^(?=(?:.*\d){3}).*$
# JavaScript
const digitRe = /^(?=.*\d).{8,}$/;
digitRe.test("password") # false (no digit)
digitRe.test("password1") # true
digitRe.test("pass1word2") # true
# Count digits
const digits = (pwd) => (pwd.match(/\d/g) || []).length;
digits("pass12word") # 2
# Python
import re
bool(re.match(r"^(?=.*\d).{8,}$", "password1")) # True
# Unicode digits (e.g., Arabic-Indic digits)
/^.*\p{N}/u.test("password١") # true (١ is Arabic-Indic 1)
# ASCII-only digits explicitly
^(?=.*[0-9]).*$
# Common password rule: must contain letter AND digit
^(?=.*[A-Za-z])(?=.*\d).{8,}$
# Alphanumeric only (no special chars)
^[A-Za-z0-9]{8,}$
# Without regex
const hasDigit = (s) => /\d/.test(s);
const hasLetter = (s) => /[A-Za-z]/.test(s);
if (hasDigit(pwd) && hasLetter(pwd) && pwd.length >= 8) { /* OK */ }Caractère spécial
Exigez des caractères spéciaux avec (?=.*[^A-Za-z0-9]). Note : l'espace compte comme spécial — excluez-le explicitement avec une liste blanche si besoin. Beaucoup de sites se restreignent à une allow-list sûre (ex. [!@#$%^&*]). Vérifiez toujours les espaces séparément si vous voulez les interdire.
# Must contain at least one special (non-alphanumeric) char
^(?=.*[^A-Za-z0-9]).*$
# Or explicit list of special chars
^(?=.*[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>/?]).*$
# At least one special, 8+ chars
^(?=.*[^A-Za-z0-9]).{8,}$
# JavaScript
const specialRe = /^(?=.*[^A-Za-z0-9]).{8,}$/;
specialRe.test("password") # false
specialRe.test("password!") # true
specialRe.test("pass word") # true (space is non-alphanumeric!)
# To exclude space from "special":
^(?=.*[!@#$%^&*\-_=+]).*$
# Python
import re
bool(re.match(r"^(?=.*[^A-Za-z0-9]).{8,}$", "Password1!")) # True
# Count special characters
const specials = (pwd) => (pwd.match(/[^A-Za-z0-9]/g) || []).length;
# Common allow-list for special chars in passwords
const ALLOWED_SPECIAL = /[!@#$%^&*\-_=+?]/;
const hasAllowedSpecial = (pwd) => ALLOWED_SPECIAL.test(pwd);
# Disallow whitespace entirely
^(?=\S*$).{8,}$ # no whitespace, 8+ chars
^(?!.*\s).{8,}$ # equivalent
# Without regex
const hasSpecial = (s) => /[^A-Za-z0-9]/.test(s);
const noWhitespace = (s) => !/\s/.test(s);Validation combinée
Empilez les lookaheads au début pour les règles composées : chaque lookahead affirme une condition depuis la même position. Pour la maintenabilité, des appels test() séparés peuvent être plus clairs qu'une méga-regex. Recommandations NIST modernes : privilégier la longueur (12+), autoriser tous les caractères imprimables, et vérifier contre les mots de passe compromis connus.
# Combined password rule:
# - 8+ chars
# - 1+ lowercase
# - 1+ uppercase
# - 1+ digit
# - 1+ special char
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$
# Stronger: 12+ chars, 2+ digits
^(?=.*[a-z])(?=.*[A-Z])(?=(?:.*\d){2})(?=.*[^A-Za-z0-9]).{12,}$
# JavaScript
const strongPwd = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$/;
strongPwd.test("Password1!") # true
strongPwd.test("password") # false (no upper, digit, special)
strongPwd.test("PASSWORD1!") # false (no lower)
# Python
import re
STRONG = re.compile(
r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^A-Za-z0-9]).{8,}$"
)
bool(STRONG.match("Password1!")) # True
# Readable alternative: separate checks (often clearer)
function validatePassword(pwd) {
const checks = {
length: pwd.length >= 8,
lower: /[a-z]/.test(pwd),
upper: /[A-Z]/.test(pwd),
digit: /\d/.test(pwd),
special: /[^A-Za-z0-9]/.test(pwd),
noWhitespace: !/\s/.test(pwd),
};
return Object.values(checks).every(Boolean) ? checks : null;
}
# Disallow common weak passwords
^(?!password|123456|qwerty|letmein).{8,}$
# NIST guidance: focus on length, allow all char types,
# check against breach databases (haveibeenpwned API)Matching de dates
YYYY-MM-DD
La regex peut valider le format (YYYY-MM-DD avec mois 01-12, jour 01-31) mais PAS la validité sémantique (30 février, années bissextiles). Pour une vraie validation, utilisez Date (JS) ou datetime (Python). Les groupes de capture permettent d'extraire année/mois/jour pour un traitement ultérieur. Utilisez le format ISO 8601 pour des dates sans ambiguïté.
# Basic: 4 digits, dash, 2 digits, dash, 2 digits
^\d{4}-\d{2}-\d{2}$
# With basic validation (month 01-12, day 01-31)
^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$
# Disallow year 0000
^(?!0000)\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$
# JavaScript
const dateRe = /^(?!0000)\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/;
dateRe.test("2024-01-15") # true
dateRe.test("2024-13-01") # false (month 13)
dateRe.test("2024-02-31") # true (regex doesn't know Feb has 28 days)
# Capture components
^(\d{4})-(\d{2})-(\d{2})$
"2024-01-15".match(/^(\d{4})-(\d{2})-(\d{2})$/)
// ["2024-01-15", "2024", "01", "15"]
# Python
import re
m = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", "2024-01-15")
year, month, day = m.groups()
# Use Date for real validation
const d = new Date("2024-01-15");
if (isNaN(d.getTime())) { /* invalid */ }
# Python: datetime for real validation
from datetime import date
try: date(2024, 1, 15)
except ValueError: pass # invalidDD/MM/YYYY
JJ/MM/AAAA (Europe) vs MM/JJ/AAAA (US) se ressemblent — l'ambiguïté est un vrai problème. Utilisez toujours ISO 8601 (YYYY-MM-DD) pour le stockage/échange. La regex capture jour/mois/année pour reformater. La vraie validation (29 février, années bissextiles, longueurs de mois) exige une bibliothèque de dates.
# DD/MM/YYYY with basic validation
^(?:0[1-9]|[12]\d|3[01])/(?:0[1-9]|1[0-2])/\d{4}$
# Capture day, month, year
^(\d{2})/(\d{2})/(\d{4})$
# With separators: / or - or .
^(\d{1,2})[/-](\d{1,2})[/-](\d{4})$
# JavaScript
const re = /^(\d{1,2})[/-](\d{1,2})[/-](\d{4})$/;
const m = "15/01/2024".match(re);
// m[1]="15", m[2]="01", m[3]="2024"
# US format MM/DD/YYYY
^(?:0[1-9]|1[0-2])/(?:0[1-9]|[12]\d|3[01])/\d{4}$
# Allow 1 or 2 digit day/month
^(\d{1,2})/(\d{1,2})/(\d{4})$
# Capture and reorder: DD/MM/YYYY -> YYYY-MM-DD
"15/01/2024".replace(/^(\d{2})\/(\d{2})\/(\d{4})$/, "$3-$2-$1")
// "2024-01-15"
# Python
import re
re.sub(r"^(\d{2})/(\d{2})/(\d{4})$", r"\3-\2-\1", "15/01/2024")
# "2024-01-15"
# Detect format ambiguity: 01/02/2024 - is it Jan 2 or Feb 1?
# Use ISO 8601 (YYYY-MM-DD) for unambiguous storageFormat d'heure
Regex d'heure : HH 00-23 (ou 01-12 pour le 12 heures), MM/SS 00-59. Utilisez l'alternance ([01]\d|2[0-3]) pour les heures. Utilisez toujours ISO 8601 (HH:MM:SS avec fuseau optionnel) pour le stockage. Pour de l'arithmétique temporelle réelle, utilisez Date/datetime — la regex ne valide que le format.
# 24-hour: HH:MM
^([01]\d|2[0-3]):[0-5]\d$
# 24-hour: HH:MM:SS
^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$
# 12-hour with AM/PM
^(0?[1-9]|1[0-2]):[0-5]\d(?:\s?[AP]M)?$
# Capture HH, MM, SS
^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$
# With milliseconds
^([01]\d|2[0-3]):[0-5]\d:[0-5]\d\.\d{3}$
# JavaScript
const time24 = /^([01]\d|2[0-3]):[0-5]\d$/;
time24.test("23:59") # true
time24.test("24:00") # false
time24.test("12:30") # true
const time12 = /^(0?[1-9]|1[0-2]):[0-5]\d\s?[AP]M$/i;
time12.test("1:30 PM") # true
time12.test("12:00am") # true
# Python
import re
re.match(r"^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$", "12:30:45")
# ISO 8601 duration: PT1H30M
^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$
# Time zone offset: +HH:MM or -HH:MM
[+-]([01]\d|2[0-3]):?[0-5]\d
# Combined date and time (ISO 8601)
^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:Z|[+-]\d{2}:?\d{2})?$DateTime ISO 8601
ISO 8601 est le standard international de date/heure : YYYY-MM-DDTHH:MM:SS avec secondes fractionnaires et fuseau optionnels (Z pour UTC, ou ±HH:MM). Pour le parsing en production, utilisez Date (JS) ou datetime.fromisoformat (Python 3.7+). La regex sert seulement à valider le format.
# ISO 8601 date
^\d{4}-\d{2}-\d{2}$
# ISO 8601 date and time (basic)
^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:Z|[+-]\d{2}:\d{2})?$
# With optional milliseconds
^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})?$
# JavaScript - use built-in Date parsing
const d = new Date("2024-01-15T10:30:00Z");
if (!isNaN(d.getTime())) { /* valid ISO */ }
# Validate ISO 8601 strictly
const isoRe = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})$/;
isoRe.test("2024-01-15T10:30:00Z") # true
isoRe.test("2024-01-15T10:30:00.123Z") # true
isoRe.test("2024-01-15T10:30:00+08:00") # true
isoRe.test("2024-01-15 10:30:00") # false (T required)
# Python - use datetime.fromisoformat (3.7+)
from datetime import datetime
try:
datetime.fromisoformat("2024-01-15T10:30:00")
except ValueError:
pass # invalid
# Capture date and time components
^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[+-]\d{2}:\d{2})?$
# Week date: 2024-W03-1 (year-week-weekday)
^\d{4}-W\d{2}-\d$
# Ordinal date: 2024-015 (year-day of year)
^\d{4}-\d{3}$Capturer les composantes
Les groupes de capture permettent d'extraire les composantes de date pour traitement. Les groupes nommés ((?P<nom>...) en Python, (?<nom>...) en JS) rendent le code bien plus lisible que des références numériques. Convertissez toujours le mois en entier et soustrayez 1 pour le constructeur Date de JS (les mois sont indexés à partir de 0).
# Capture year, month, day from YYYY-MM-DD
^(\d{4})-(\d{2})-(\d{2})$
# Groups: 1=year, 2=month, 3=day
# JavaScript
const m = "2024-01-15".match(/^(\d{4})-(\d{2})-(\d{2})$/);
const [_, year, month, day] = m;
// year="2024", month="01", day="15"
# Named groups (clearer)
const m2 = "2024-01-15".match(
/^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$)/
);
m2.groups.year // "2024"
m2.groups.month // "01"
m2.groups.day // "15"
# Python with named groups
import re
m = re.match(r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})",
"2024-01-15")
m.group("year") # "2024"
m.groupdict() # {"year": "2024", "month": "01", "day": "15"}
# Reformat date: YYYY-MM-DD -> DD/MM/YYYY
"2024-01-15".replace(
/^(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})$/,
"$<d>/$<m>/$<y>"
)
// "15/01/2024"
# Python
re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\3/\2/\1", "2024-01-15")
# "15/01/2024"
# Validate and extract date from text
const text = "Meeting on 2024-01-15 at 10:30";
const [_, y, mo, d] = text.match(/(\d{4})-(\d{2})-(\d{2})/);
// y="2024", mo="01", d="15"
# Convert to Date object
const d = new Date(+y, +mo - 1, +d); # months are 0-indexedMatching de nombres
Entiers
Regex d'entiers : ^[+-]?\d+$ (signe optionnel). Pour les séparateurs de milliers : ^\d{1,3}(?:,\d{3})*$ impose des groupes de trois. Le format européen utilise points/espaces comme séparateurs. Hex/octal/binaire utilisent les préfixes 0x/0o/0b (ou 0 seul pour l'octal dans les vieux langages).
# Positive integers
^\d+$
# Optional sign
^[+-]?\d+$
# Negative only
^-\d+$
# With thousand separators (US/EU: comma)
^[+-]?\d{1,3}(?:,\d{3})*$
# JavaScript
const intRe = /^[+-]?\d+$/;
intRe.test("12345") # true
intRe.test("-1") # true
intRe.test("+42") # true
intRe.test("3.14") # false
# With commas
const commaInt = /^[+-]?\d{1,3}(?:,\d{3})*$/;
commaInt.test("1,234") # true
commaInt.test("12,345,678") # true
commaInt.test("1234") # false (needs comma)
# Allow comma-less too
^[+-]?(?:\d{1,3}(?:,\d{3})*|\d+)$
# Python
import re
re.match(r"^[+-]?\d+$", "12345") # match
# Strip commas before parsing
"1,234,567".replace(/,/g, "") # "1234567"
int("1,234,567".replace(",", "")) # 1234567
# Hex integer
^0x[0-9a-fA-F]+$
# Octal
^0o?[0-7]+$
# Binary
^0b[01]+$Décimaux
La regex décimale demande du soin : autorisez-vous le point initial (.5) ? le point final (1.) ? la partie entière optionnelle ? Forme courante : ^[+-]?\d+(?:\.\d+)?$ exige une partie entière, décimales optionnelles. Pour la devise, fixez les décimales (ex. {2}).
# Basic decimal: digits.digits
^\d+\.\d+$
# Optional integer or fractional part
^\d+\.?\d*$ # 1, 1., 1.5
^\d*\.?\d+$ # .5, 1.5, 1
^\d+\.\d+|\d+$ # integer or decimal
# With optional sign
^[+-]?(?:\d+\.\d+|\d+)$
# JavaScript
const decRe = /^[+-]?(?:\d+\.\d+|\d+)$/;
decRe.test("3.14") # true
decRe.test("-0.5") # true
decRe.test("1") # true
decRe.test(".5") # false (requires leading digit)
# Allow leading dot
^[+-]?(?:\d+\.?\d*|\.\d+)$
# Fixed decimal places (e.g., 2)
^[+-]?\d+\.\d{2}$
# With thousand separators
^[+-]?\d{1,3}(?:,\d{3})*\.\d+$
# Avoid trailing dot
^[+-]?\d+(?:\.\d+)?$
# Extract decimals from text
"The price is 3.14 dollars".match(/-?\d+\.\d+/)
// ["3.14"]
# Python
import re
re.findall(r"-?\d+\.\d+", "Pi is 3.14, e is 2.72") # ['3.14', '2.72']
# Strict: 1-6 decimal places
^\d+\.\d{1,6}$Nombres négatifs
Regex de nombres négatifs : ^-?\d+$ autorise un moins optionnel. Pour des stricts négatifs, ^-\d+$. Attention à l'extraction depuis du texte — les tirets de « co-opératif » peuvent matcher. Utilisez les frontières de mot (\b) ou exigez un espace avant le moins pour éviter les faux positifs.
# Optional minus sign
^-?\d+$
# Optional + or -
^[+-]?\d+$
# Required minus
^-\d+$
# With decimal
^-?\d+\.\d+$
# JavaScript
const negRe = /^-?\d+$/;
negRe.test("-123") # true
negRe.test("123") # true (zero or one minus)
negRe.test("--1") # false
# Strict negative integer
const strictNeg = /^-\d+$/;
strictNeg.test("-1") # true
strictNeg.test("0") # false
strictNeg.test("-0") # true (technically -0)
# Exclude negative zero
^-(?!0+$)\d+$
# Allow scientific notation with sign
^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$
# Extract signed numbers from text
"Temperature: -5 to +10 degrees".match(/[+-]?\d+/g)
// ["-5", "+10"]
# Python
import re
re.findall(r"-?\d+", "loss: -100, gain: 50") # ['-100', '50']
# Avoid matching minus as text hyphen
# Use word boundary or whitespace before
\s-?\d+ # minus must follow whitespace
\b-?\d+\b # word boundary
# Currency with optional negative
^\$?-?\d+(?:\.\d{2})?$ # $-5.00 or -5.00 or $5.00Notation scientifique
Notation scientifique : mantisse (avec décimal optionnel), 'e' ou 'E', signe optionnel, chiffres d'exposant. Utilisez parseFloat (JS) ou float (Python) pour le parsing — ils gèrent nativement la notation scientifique. Les groupes de capture permettent d'accéder séparément à mantisse et exposant si nécessaire.
# Scientific notation: mantissa e exponent
^[+-]?(?:\d+\.?\d*|\.\d+)[eE][+-]?\d+$
# Examples: 1e10, -2.5E-3, 6.022e23, 1.5E+10
# JavaScript
const sciRe = /^[+-]?(?:\d+\.?\d*|\.\d+)[eE][+-]?\d+$/;
sciRe.test("1e10") # true
sciRe.test("-2.5E-3") # true
sciRe.test("6.022e23") # true
sciRe.test("1.5E+10") # true
sciRe.test("1e") # false (no exponent)
# Allow integer or decimal without exponent too
^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$
# Capture mantissa and exponent
^([+-]?(?:\d+\.?\d*|\.\d+))[eE]([+-]?\d+)$
const m = "-2.5E-3".match(/^([+-]?(?:\d+\.?\d*|\.\d+))[eE]([+-]?\d+)$/);
// m[1]="-2.5" (mantissa), m[2]="-3" (exponent)
# Convert to number
parseFloat("6.022e23") # 6.022e+23
Number("1.5E+10") # 15000000000
# Python
import re
re.match(r"^[+-]?(?:\d+\.?\d*|\.\d+)[eE][+-]?\d+$", "-2.5E-3")
float("-2.5E-3") # -0.0025
# Extract scientific numbers from text
re.findall(r"[-+]?\d+\.?\d*[eE][-+]?\d+", "Avogadro: 6.022e23")
# ['6.022e23']
# Engineering notation (exponent multiple of 3)
# Hard to enforce via regex; better to validate after parsing
# Examples: 1.5e3, 2.5e6, 1e-3 (not 1.5e4)Format de devise
Les formats de devise varient : US ($1,234.56), UE (1.234,56 €), Japon (¥1,234 sans décimales). Utilisez toLocaleString pour le formatage d'affichage. Pour le parsing, retirez symbole et séparateurs avant parseFloat. La regex valide le format ; utilisez Intl.NumberFormat pour le formatage de devise en production.
# US currency: $123.45 or $1,234.56
^\$\d{1,3}(?:,\d{3})*\.\d{2}$
# Optional $ and cents
^\$?\d{1,3}(?:,\d{3})*(?:\.\d{2})?$
# Optional sign for negative
^[+-]?\$?\d{1,3}(?:,\d{3})*(?:\.\d{2})?$
# Allow negative after $: -$5.00 or $-5.00
^[+-]?\$[+-]?\d+(?:\.\d{2})?$
# European format: 1.234,56 €
^\d{1,3}(?:\.\d{3})*,\d{2}\s?€$
# JavaScript
const usd = /^\$\d{1,3}(?:,\d{3})*\.\d{2}$/;
usd.test("$1,234.56") # true
usd.test("$123.45") # true
usd.test("$1234.56") # false (needs comma)
usd.test("$1.234") # false (needs 2 decimals)
# Loose: just match dollar amount
/\$[\d,.]+/g
# Extract all currency from text
"Total: $1,234.56, tax: $99.99".match(/\$[\d,]+\.\d{2}/g)
// ["$1,234.56", "$99.99"]
# Parse to number
const parseUSD = (s) => parseFloat(s.replace(/[$,]/g, ""));
parseUSD("$1,234.56") # 1234.56
# Format number as currency
(1234.56).toLocaleString("en-US", { style: "currency", currency: "USD" })
// "$1,234.56"
# Python
import re
re.match(r"^\$\d{1,3}(?:,\d{3})*\.\d{2}$", "$1,234.56")
# Bitcoin: 0.5 BTC, satoshis
^\d+(?:\.\d{1,8})?\s?(?:BTC|sat|sats)$Remplacement de chaînes
Remplacement simple
Premier vs tout diffère selon le langage : le replace() de JS fait premier-seulement sans /g ; re.sub de Python fait tout par défaut (count=1 pour le premier) ; replaceFirst de Java pour le premier, replaceAll pour tout-regex, replace pour tout-littéral. Utilisez la regex pour matcher des motifs, le replace de chaîne littérale pour du texte fixe.
# Replace first occurrence
# JavaScript
"hello world".replace(/world/, "there") # "hello there"
"hello world".replace(/o/, "0") # "hell0 world" (first only)
# Python
import re
re.sub(r"world", "there", "hello world") # "hello there"
re.sub(r"o", "0", "hello world", count=1) # "hell0 world" (first only)
# Java
"hello world".replaceFirst("o", "0") # "hell0 world"
"hello world".replace("world", "there") # literal, ALL occurrences
# PHP
preg_replace('/world/', 'there', 'hello world', 1) # limit 1
# Replace literal string (no regex)
"hello.world".replace(".", " ") # "hello world" (JS, literal)
"hello.world".replaceAll(".", " ") # "hello world" (JS, literal)
# Python: str.replace is literal
"hello.world".replace(".", " ") # "hello world"
# Replace using regex with special chars
"1.5".replace(/\./g, ",") # "1,5" (escape dot)
"1+2=3".replace(/\+/g, "-") # "1-2=3" (escape +)
# Chain replacements
" Hello World ".trim().replace(/\s+/g, "_").toLowerCase()
# "hello_world"
# Python chain
"_".join(" Hello World ".strip().split()).lower()
# "hello_world"Remplacer tout
Comportement du replace-all : JS exige le flag /g avec regex ou replaceAll avec chaînes ; re.sub et str.replace de Python remplacent tous deux tout par défaut ; replaceAll (regex) et replace (littéral) de Java font tous les deux tout ; preg_replace de PHP fait tout. Pour limiter, utilisez count (Python) ou $limit (PHP).
# Replace ALL occurrences
# JavaScript: requires /g flag
"a-b-c-d".replace(/-/g, "+") # "a+b+c+d"
"a-b-c-d".split("-").join("+") # "a+b+c+d" (alternative)
# JavaScript: replaceAll (ES2021+)
"a-b-c-d".replaceAll("-", "+") # "a+b+c+d" (string, not regex)
"a-b-c-d".replaceAll(/-/g, "+") # needs /g flag with regex
# Python: re.sub does all by default
import re
re.sub(r"-", "+", "a-b-c-d") # "a+b+c+d"
# Python: str.replace also does all
"a-b-c-d".replace("-", "+") # "a+b+c+d" (literal)
# Java
"a-b-c-d".replaceAll("-", "+") # regex, all
"a-b-c-d".replace("-", "+") # literal, all
# PHP
preg_replace('/-/', '+', 'a-b-c-d') # all
# Go
regexp.MustCompile("-").ReplaceAllString("a-b-c-d", "+") # "a+b+c+d"
# Count occurrences
const count = (s, re) => (s.match(re) || []).length;
count("a-b-c-d", /-/g) # 3
# Replace with limit (Python, PHP)
re.sub(r"-", "+", "a-b-c-d", count=2) # "a+b+c-d"
preg_replace('/-/', '+', 'a-b-c-d', 2) # "a+b+c-d"
# Global case-insensitive replace
"Hello hello HELLO".replace(/hello/gi, "hi") # "hi hi hi"Groupes de capture dans le replace
Référencez les groupes capturés dans le remplacement : JS/Java utilisent $1, $2 (et $& pour toute la correspondance) ; Python \1, \2 ou \g<1> (préféré, évite l'ambiguïté avec \10+) ; PHP accepte $1 ou \1. Utilisez $& (JS) / $0 (Java) / \g<0> (Python) pour la correspondance entière. Échappez le $ littéral en $$ en JS.
# Use captured groups in replacement
# Swap two words
"hello world".replace(/^(\w+) (\w+)$/, "$2 $1") # "world hello"
# Reformat date
"2024-01-15".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3/$2/$1")
# "15/01/2024"
# Wrap matches
"hello".replace(/\w+/g, "[$&]") # "[hello]"
"hello world".replace(/\w+/g, "[$&]") # "[hello] [world]"
# Duplicate matches
"abc".replace(/(\w)/g, "$1$1") # "aabbcc"
# Conditional-like behavior with alternation
"Mr Smith".replace(/(Mr|Ms|Mrs) (\w+)/, "$2, $1.")
# "Smith, Mr."
# Python: \1, \2 or \g<1>, \g<2> (preferred)
import re
re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\3/\2/\1", "2024-01-15")
# "15/01/2024"
re.sub(r"(\w+)", r"[\1]", "hello") # "[hello]"
# Use named groups
"2024-01-15".replace(
/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/,
"$<d>/$<m>/$<y>"
) # "15/01/2024"
# Python named
re.sub(
r"(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})",
r"\g<d>/\g<m>/\g<y>",
"2024-01-15"
)
# Reference whole match: $& (JS), $0 (Java), \g<0> (Python)
"abc".replace(/\w/g, "[$&]") # "[a][b][c]"
re.sub(r"\w", r"[\g<0>]", "abc") # "[a][b][c]"
# Literal $ in replacement (JS): use $$
"price".replace(/price/, "$$100") # "$100"Conversion de casse
Conversion de casse via regex + remplacement par fonction : title case (capitaliser chaque mot), conversions camelCase↔snake_case↔kebab-case utilisent groupes de capture plus toUpperCase/toLowerCase. Python utilise des lambda pour le même effet. Le motif ([A-Z]) capturé avant le remplacement est la clé des conversions de style de casse.
# Capitalize first letter of each word (title case)
"hello world".replace(/\b\w/g, c => c.toUpperCase())
# "Hello World"
# Capitalize first letter of string only
"hello world".replace(/^\w/, c => c.toUpperCase())
# "Hello world"
# Lowercase first letter, rest unchanged
"HelloWorld".replace(/^\w/, c => c.toLowerCase())
# "helloWorld"
# camelCase to snake_case
"myVariableName".replace(/([A-Z])/g, "_$1").toLowerCase()
# "my_variable_name"
# snake_case to camelCase
"my_variable_name".replace(/_([a-z])/g, (_, c) => c.toUpperCase())
# "myVariableName"
# kebab-case to camelCase
"my-variable-name".replace(/-([a-z])/g, (_, c) => c.toUpperCase())
# "myVariableName"
# camelCase to kebab-case
"myVariableName".replace(/([A-Z])/g, "-$1").toLowerCase()
# "my-variable-name"
# UPPER_CASE to lowerCase
"MY_VAR_NAME".replace(/_/g, "").toLowerCase()
# "myvarname" (without proper conversion)
# Constant case to camelCase
"MY_VAR_NAME".toLowerCase().replace(/_([a-z])/g, (_, c) => c.toUpperCase())
# "myVarName"
# Sentence case: capitalize first letter of each sentence
"hello. world. foo.".replace(/(^|\.\s+)([a-z])/g, (_, p, c) => p + c.toUpperCase())
# "Hello. World. Foo."
# Python equivalents
import re
re.sub(r"\b\w", lambda m: m.group().upper(), "hello world")
# "Hello World"
re.sub(r"([A-Z])", r"_\1", "myVar").lower()
# "my_var"Trim et nettoyage
Nettoyage courant : trim (utilisez le .trim() intégré en JS, .strip() en Python — plus rapide), compacter les espaces multiples (\s+ -> espace unique), normaliser les fins de ligne (CRLF/CR -> LF), retirer les commentaires. Utilisez le flag multiligne (/m) pour les opérations par ligne comme retirer les espaces de fin de chaque ligne.
# Trim leading and trailing whitespace
" hi ".replace(/^\s+|\s+$/g, "") # "hi"
# Note: JS String.prototype.trim() is preferred: " hi ".trim()
# Trim leading only
" hi ".replace(/^\s+/, "") # "hi "
# Or: " hi ".replace(/^\s+/g, "")
# Trim trailing only
" hi ".replace(/\s+$/, "") # " hi"
# Collapse multiple spaces into one
"a b c".replace(/\s+/g, " ") # "a b c"
# Collapse but preserve newlines
"a b
c".replace(/[ \t]+/g, " ").replace(/\n{2,}/g, "\n")
# "a b
c"
# Remove all whitespace
"a b c".replace(/\s/g, "") # "abc"
"a b c".replace(/\s+/g, "") # "abc"
# Remove blank lines
"text\n\n\nmore".replace(/^\s*$(?:\n|$)/gm, "")
# "text
more"
# Normalize line endings
"text\r\nmore".replace(/\r\n/g, "\n") # CRLF -> LF
"text\rmore".replace(/\r/g, "\n") # CR -> LF
# Remove trailing whitespace from each line
"text \nmore ".replace(/\s+$/gm, "")
# "text
more"
# Strip comments (/* */ and //)
code.replace(/\/\*[\s\S]*?\*\//g, "") # block comments
code.replace(/\/\/.*$/gm, "") # line comments
# Python equivalents
import re
re.sub(r"^\s+|\s+$", "", " hi ") # "hi"
re.sub(r"\s+", " ", "a b c") # "a b c"
re.sub(r"\s+$", "", "a ", flags=re.M) # trim trailing per lineRetirer les tags HTML
Retirez les tags HTML avec /<[^>]+>/g (naïf mais marche pour les cas simples). Retirez <script>/<style> avec leur contenu via le paresseux [\s\S]*?. Pour du vrai HTML, utilisez un parseur (DOM en JS, BeautifulSoup en Python) — la regex échoue sur les tags imbriqués, attributs avec > et HTML mal formé. Décodez les entités avec le DOM ou html.unescape (Python).
# Naive: remove anything between < and >
"<p>Hello</p>".replace(/<[^>]+>/g, "") # "Hello"
# Strip all tags but keep content
"<div><p>Hello <b>world</b></p></div>".replace(/<[^>]+>/g, "")
# "Hello world"
# Remove specific tag
"<div>keep</div>".replace(/<\/?div>/g, "") # "keep"
# Remove script and style blocks (with content)
html.replace(/<script[\s\S]*?<\/script>/gi, "")
html.replace(/<style[\s\S]*?<\/style>/gi, "")
# Decode basic HTML entities
"AT&T".replace(/&/g, "&")
"<tag>".replace(/</g, "<").replace(/>/g, ">")
" ".replace(/ /g, " ")
""".replace(/"/g, '\"')
# Decode all entities via DOM (JS)
function decodeEntities(s) {
const t = document.createElement("textarea");
t.innerHTML = s;
return t.value;
}
# Remove attributes from tags
'<a href="x" class="y">link</a>'.replace(/(<\w+)[^>]*>/g, "$1>")
# "<a>link</a>" (but the </a> stays; need to handle closing too)
# Self-closing tags
html.replace(/<\w+[^>]*/>/g, "")
# Strip HTML comments
html.replace(/<!--[\s\S]*?-->/g, "")
# Python
import re
re.sub(r"<[^>]+>", "", "<p>Hello</p>") # "Hello"
re.sub(r"<script[\s\S]*?</script>", "", html, flags=re.I)
# WARNING: regex is fragile for HTML parsing.
# Use DOMParser (JS) or BeautifulSoup (Python) for real HTML.Extraction et découpage
Extraire la première correspondance
Extraire la première correspondance : String.match() en JS retourne un tableau (ou null), re.search de Python un objet Match (ou None), Matcher.find() de Java avance vers la correspondance suivante, preg_match de PHP remplit le tableau avec les groupes. Utilisez search (Python) quand le motif peut être n'importe où — match ancre au début.
# Extract first match
# JavaScript
const m = "price: $42.50, tax: $3.00".match(/\$(\d+\.\d{2})/);
// m[0] = "$42.50", m[1] = "42.50"
if (m) console.log(m[1]); // "42.50"
# Python
import re
m = re.search(r"\$(\d+\.\d{2})", "price: $42.50, tax: $3.00")
if m:
print(m.group(1)) # "42.50"
# Java
Matcher m = Pattern.compile("\\$(\\d+\\.\\d{2})")
.matcher("price: $42.50");
if (m.find()) { String price = m.group(1); }
# PHP
if (preg_match('/\$(\d+\.\d{2})/', 'price: $42.50', $m)) {
echo $m[1]; // "42.50"
}
# Extract with named groups
const m2 = "2024-01-15".match(
/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
);
if (m2) console.log(m2.groups.year); // "2024"
# Test if pattern exists (no extraction needed)
const has = /\d{4}-\d{2}-\d{2}/.test("date: 2024-01-15"); // true
# Python: search vs match vs fullmatch
re.search(r"abc", "xabcx") # finds anywhere
re.match(r"abc", "abcx") # anchored at start
re.fullmatch(r"abc", "abc") # entire stringExtraire toutes les correspondances
Extraire toutes les correspondances : match() de JS avec /g retourne un tableau plat de correspondances (sans détail des groupes) ; matchAll (ES2020+) un itérateur avec infos complètes. re.findall de Python retourne une liste de groupes (ou la correspondance entière sans groupes). Utilisez re.finditer pour une itération paresseuse sur du grand texte.
# Extract ALL matches
# JavaScript: with /g flag, match() returns array of matches (no groups)
"1a2b3c".match(/\d/g) # ["1", "2", "3"]
"a1 b2 c3".match(/\d+/g) # ["1", "2", "3"]
# matchAll (ES2020+) returns iterator with full match info
const matches = [..."2024-01-15 2025-02-20".matchAll(/(\d{4})-(\d{2})-(\d{2})/g)];
// matches[0][0]="2024-01-15", matches[0][1]="2024", ...
# Python: re.findall returns list of group(s)
import re
re.findall(r"\d+", "a1 b2 c3") # ["1", "2", "3"]
re.findall(r"(\d+)-(\d+)", "12-34 56-78") # [("12","34"), ("56","78")]
# Note: if groups present, returns tuples of groups, not whole match
# Use (?:...) or non-capturing to get whole match
re.findall(r"\d+-\d+", "12-34 56-78") # ["12-34", "56-78"]
# re.finditer returns match objects (lazy iterator)
for m in re.finditer(r"\d+", "a1 b2 c3"):
print(m.group(), m.start(), m.end())
# Java: Matcher.find() in loop
Matcher m = Pattern.compile("\\d+").matcher("a1 b2 c3");
while (m.find()) { System.out.println(m.group()); }
# PHP: preg_match_all fills multidimensional array
preg_match_all('/\d+/', 'a1 b2 c3', $m, PREG_SET_ORDER);
// $m[0][0] = "1", $m[1][0] = "2", ...
# Count matches
(len("a1 b2 c3".match(/\d/g) || [])) # 3 (JS)
len(re.findall(r"\d", "a1 b2 c3")) # 3 (Python)Découper une chaîne
Découper par regex : String.split(regex) en JS, re.split en Python, String.split en Java, preg_split en PHP, regexp.Split en Go. Les groupes de capture du motif gardent les délimiteurs dans le tableau résultat. Utilisez limit/maxsplit pour plafonner le nombre de découpes. Découpage par espaces : /\s+/ gère espaces multiples, tabulations et retours à la ligne.
# Split string by pattern
# JavaScript
"a,b,c".split(",") # ["a", "b", "c"]
"a, b , c".split(/\s*,\s*/) # ["a", "b", "c"] (trim around comma)
"1-2-3".split("-") # ["1", "2", "3"]
# Split with capture group keeps the delimiter
"a1b2c3".split(/(\d)/) # ["a", "1", "b", "2", "c", "3", ""]
# Limit splits
"a,b,c,d".split(",", 2) # ["a", "b"] (rest in last element)
"a,b,c,d".split(/,/, 2) # ["a", "b"]
# Python
import re
re.split(r"\s*,\s*", "a, b , c") # ["a", "b", "c"]
re.split(r"(\d)", "a1b2c3") # ["a", "1", "b", "2", "c", "3", ""]
re.split(r",", "a,b,c", maxsplit=1) # ["a", "b,c"]
# Java
"a,b,c".split(",") # ["a", "b", "c"]
"a, b , c".split("\\s*,\\s*") # ["a", "b", "c"]
"a,b,c,d".split(",", 2) # ["a", "b,c,d"]
# PHP
preg_split('/\s*,\s*/', 'a, b , c') # ["a", "b", "c"]
preg_split('/(\d)/', 'a1b2c3', -1, PREG_SPLIT_DELIM_CAPTURE)
# Go
regexp.MustCompile("\\s*,\\s*").Split("a, b , c", -1)
# Split on whitespace (any)
"a b\tc\nd".split(/\s+/) # ["a", "b", "c", "d"]
# Split lines
"line1\nline2\r\nline3".split(/\r\n|\r|\n/) # ["line1", "line2", "line3"]Extraire des paires clé-valeur
Extraire les paires clé=valeur avec un motif comme (\w+)\s*[=:]\s*([^,;\n]+). Object.fromEntries + matchAll (JS) ou dict + findall (Python) bâtissent un objet propre. Pour les vraies query strings d'URL et en-têtes HTTP, préférez URL/URLSearchParams intégrés (JS) ou urllib.parse (Python) — ils gèrent correctement l'encodage d'URL.
# Extract key=value pairs
# Match key=value (or key: value)
(\w+)\s*[=:]\s*([^,;\n]+)
# JavaScript
const text = "name=Alice, age=30; city: NYC";
const pairs = [...text.matchAll(/(\w+)\s*[=:]\s*([^,;\n]+)/g)];
const obj = Object.fromEntries(pairs.map(m => [m[1], m[2].trim()]));
// { name: "Alice", age: "30", city: "NYC" }
# Python
import re
text = "name=Alice, age=30; city: NYC"
pairs = re.findall(r"(\w+)\s*[=:]\s*([^,;\n]+)", text)
dict(pairs) # {"name": "Alice", "age": "30", "city": "NYC"}
# URL query string parsing
"?a=1&b=2&c=3".match(/[?&]([^=]+)=([^&]+)/g)
// ["?a=1", "&b=2", "&c=3"]
# Parse query string into object
const qs = "a=1&b=2&c=hello%20world";
const params = Object.fromEntries(
[...qs.matchAll(/([^=&]+)=([^&]*)/g)]
.map(m => [m[1], decodeURIComponent(m[2])])
);
// { a: "1", b: "2", c: "hello world" }
# Python equivalent
from urllib.parse import parse_qs
parse_qs("a=1&b=2&c=hello%20world")
# {"a": ["1"], "b": ["2"], "c": ["hello world"]}
# HTTP header parsing
const headers = "Content-Type: text/html\nAccept: */*";
const headerObj = Object.fromEntries(
[...headers.matchAll(/^(\w[\w-]*):\s*(.+)$/gm)]
.map(m => [m[1], m[2]])
);
// { "Content-Type": "text/html", "Accept": "*/*" }Tokenisation
La tokenisation découpe le texte en unités significatives : mots (\w+), nombres, chaînes, opérateurs, ponctuation. Utilisez l'alternance avec groupes de capture pour les motifs de tokenizer. re.finditer de Python donne des objets match avec positions. Pour une vraie tokenisation NLP, utilisez des bibliothèques comme NLTK ou spaCy — elles gèrent les cas limites que la regex ne peut pas.
# Tokenize: split text into tokens (words, numbers, punctuation)
# Simple word tokenization
\w+ # sequences of word chars
"Hello, world! 42".match(/\w+/g) # ["Hello", "world", "42"]
# Tokenize keeping punctuation
/[A-Za-z0-9]+|[^\sA-Za-z0-9]/g
"Hello, world!".match(/[A-Za-z0-9]+|[^\sA-Za-z0-9]/g)
# ["Hello", ",", "world", "!"]
# Number tokens
/\d+\.?\d*|\.[0-9]+/
"Price 3.14 and .5".match(/\d+\.?\d*|\.[0-9]+/g) # ["3.14", ".5"]
# String literals
/"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/
# Programming language tokens (simplified)
const tokens = source.matchAll(
/(?<comment>\/\/.*$|\/\*[\s\S]*?\*\/)
|(?<string>"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')
|(?<number>\d+\.?\d*)
|(?<ident>[A-Za-z_]\w*)
|(?<op>[+\-*/=<>!&|]+)
|(?<punct>[(){}[\];,.])/gx
);
# Split into words preserving position
import re
for m in re.finditer(r"\w+", "Hello world foo"):
print(m.group(), m.start(), m.end())
# Sentence tokenization (simplified)
text.split(/(?<=[.!?])\s+/)
# Splits on whitespace after . ! or ?
# Whitespace tokenization (preserves tokens)
text.split(/(\s+)/) # keeps whitespace as separate elementsGourmand vs paresseux
Gourmand par défaut
Les quantificateurs gourmands matchent le plus possible, puis reviennent en arrière pour laisser le reste du motif réussir. Cela cause souvent des correspondances inattendues comme HTML : <.+> matche tout <b>...</b><i>...</i> comme un seul. Utilisez des quantificateurs paresseux ou des classes spécifiques pour l'éviter.
# Quantifiers are GREEDY by default - match as much as possible
# * + ? {n,m} all greedy
# Greedy: .* takes everything, then backtracks
"<a> <b> <c>".match(/<.*>/) # ["<a> <b> <c>"] (whole thing!)
# Greedy backtracking example
"12345".match(/\d+\d/) # \d+ takes "1234", last \d takes "5"
# Greedy with anchored end - takes everything then backtracks to find end
"hello world end".match(/^.*(end).*$/) # captures "end"
# Common greedy patterns
.* # entire line (zero or more)
.+ # entire line (one or more)
\d+ # all consecutive digits
\w+ # all consecutive word chars
\s+ # all consecutive whitespace
# HTML gotcha: greedy matches too much
"<b>bold</b> and <i>italic</i>".match(/<.+>/)
# ["<b>bold</b> and <i>italic</i>"] - WRONG, matches across tags!
# Greedy on alternation
"cat or dog".match(/cat|cat dog/) # ["cat"] - first alternative wins
# Email greedy
"a@b@c".match(/.+@.+/) # ["a@b@c"] - greedy .+ takes "a@b"Quantificateurs paresseux
Les quantificateurs paresseux (*? +? ??) matchent le moins possible. Utilisez-les pour trouver la correspondance la plus courte entre délimiteurs : <.*?> pour les tags HTML, ".*?" pour les chaînes quotées. Pour des chaînes quotées simples, '[^']*' est généralement plus rapide et plus clair que '.*?'.
# Add ? after a quantifier to make it LAZY (non-greedy)
# Lazy: match as LITTLE as possible, expand only if needed
# Lazy quantifiers
*? # lazy zero or more
+? # lazy one or more
?? # lazy zero or one
{n,m}? # lazy range
# Lazy: stops at FIRST closing tag
"<a> <b> <c>".match(/<.*?>/) # ["<a>"] - just the first tag
"<b>bold</b> <i>italic</i>".match(/<.+?>/)
# ["<b>"] - just the first opening tag
# Find quoted strings
'"a" and "b"'.match(/".*?"/g) # ['"a"', '"b"']
'"a" and "b"'.match(/".*"/g) # ['"a" and "b"'] (greedy wrong!)
# Capture content between tags
"<div>hello</div>".match(/<div>(.*?)<\/div>/) # captures "hello"
# Lazy vs negated class (often faster alternative)
# These are equivalent but negated class is usually faster:
'"hello"'.match(/"[^"]*"/) # uses negated class - preferred
'"hello"'.match(/".*?"/) # uses lazy - works but slower
# Multiple lazy quantifiers
'(.*?)(.*?)(.*?)' # all lazy, but each expands as needed
# When greedy fails, lazy often helps
# Match XML comments <!-- ... -->
text.match(/<!--[\s\S]*?-->/g) # lazy: stops at first -->Motifs paresseux courants
Motifs paresseux courants : contenu de tag (<tag>(.*?)</tag>), chaînes quotées ('[^']*'), contenu entre crochets, commentaires. Pour du contenu délimité, préférez les classes niées ([^']*) aux quantificateurs paresseux (.*?) — plus clairs et souvent plus rapides. Le paresseux brille vraiment quand le délimiteur fait plusieurs caractères.
# Most common lazy patterns
# Content between tags (HTML/XML)
<([a-z][a-z0-9]*)\b[^>]*>(.*?)<\/\1>
# captures tag name and inner content (lazy)
# Quoted strings
"([^"]*)" # double-quoted (preferred over ".*?")
'([^']*)' # single-quoted
# Bracketed content
\[([^\]]*)\] # content inside [ ]
\(([^()]*)\) # content inside ( )
\{([^{}]*)\} # content inside { }
# Comments
/\*[\s\S]*?\*/ # C-style block comment
<!--.*?--> # HTML comment (with /s for multiline)
# URL in text
https?://\S+?["'\s<>] # URL until delimiter
# Path components
/([^/]+) # one path segment
# Code block in markdown
\`\`\`([\s\S]*?)\`\`\` # fenced code block
# Lazy with anchors for validation
^.*?\bword\b.*$ # line containing "word" (lazy doesn't matter here)
# Variable assignment
(\w+)\s*=\s*("[^"]*"|'[^']*'|\d+)Quand utiliser lequel
Choisissez le gourmand quand vous voulez la correspondance la plus longue (jusqu'au dernier délimiteur) ou que la fin est unique. Choisissez le paresseux quand plusieurs délimiteurs existent ou que vous voulez chaque correspondance séparément. Le mieux : utilisez des classes de caractères spécifiques ([^"/]*) pour éviter le problème entièrement — généralement plus claires et rapides que les quantificateurs paresseux.
# Use GREEDY when:
# - You want the longest possible match
# - The end is uniquely identified
# - You want to capture until the LAST occurrence
# Capture everything to the last occurrence of X
^.*X # greedy: matches up to the LAST X
"everything;until;last;semicolon".match(/^.*;/) # "everything;until;last;"
# Use LAZY when:
# - You want the shortest match
# - Multiple delimiters exist
# - You want to match each occurrence separately
# Match each quoted string
'"a","b","c"'.match(/"[^"]*"/g) # ['"a"', '"b"', '"c"'] - non-lazy, negated
'"a","b","c"'.match(/".*?"/g) # same result with lazy
# When neither works well: use specific character classes
# Match content of <div> (allowing nested non-div tags)
<div\b[^>]*>((?:(?!<div\b)[\s\S])*)<\/div>
# Practical: extract first URL from text
const text = 'visit https://example.com or https://other.com';
const m = text.match(/https?:\/\/[^\s<>"]+/i);
// m[0] = "https://example.com" (greedy on char class, stops at space)
# Use anchored patterns to avoid greediness issues
^.*?word.*$ # lazy doesn't help here - anchored greedy works fine
# Performance: greedy can be FASTER when no backtracking needed
\d+ # greedy but no backtrack issue (concrete chars)
.*?word # lazy to avoid grabbing too muchBacktracking catastrophique
Backtracking catastrophique : des quantificateurs imbriqués avec alternatives qui se recouvrent (comme (a+)+) causent un temps exponentiel sur des entrées qui ne matchent pas. Corrigez avec groupes atomiques (?>...), quantificateurs possessifs (a++), refactoring pour éviter les recouvrements, timeouts (Python 3.11+), ou RE2 (moteur de Go) qui est linéaire mais ne supporte pas les backreferences.
# Catastrophic backtracking: exponential time on certain inputs
# Caused by nested quantifiers with overlapping alternatives
# DANGEROUS: (a+)+ on "aaaaaaaaaaaaaaaaaaaaaaa!"
(a+)+ # nested quantifier - exponential backtracking on no-match
# DANGEROUS: overlapping alternatives
(a|a)*b # tries many combinations before failing
# DANGEROUS: classic email regex
([a-zA-Z0-9._%+-]+@([a-zA-Z0-9.-]+\.)+[a-zA-Z]{2,})+
# nested + with alternation can blow up
# How to detect: test with long inputs that DON'T match
# If it hangs on "aaaaaaa...!" - you have it
# Fixes:
# 1. Use atomic groups (PCRE, Java, .NET - NOT JS)
(?>a+)+ # atomic group - no backtracking into group
# 2. Use possessive quantifiers (Java, PCRE - NOT JS)
a++ # possessive - no backtracking
# 3. Refactor: avoid overlapping alternatives
# Bad: (a|a)*b
# Good: a*b
# 4. Be specific with character classes
# Bad: (.*)*
# Good: [a-z]* (or whatever specific chars)
# 5. Use unrolling the loop technique
# Replace (?:a*b*)+ with a*(?:ba*b)* (for example)
# 6. Set a timeout (Python 3.11+)
import re
re.compile(r"(a+)+").match("a" * 30 + "b", timeout=1.0)
# 7. Use RE2 (linear-time engine) in Go, or Google's re2 library
# RE2 doesn't support backreferences but is immune to this issue
# Test your regex at regex101.com - it warns about catastrophic patternsBackreferences
Backreferences numérotées
Les backreferences (\1, \2) matchent le même texte capturé plus tôt. Usages classiques : mots répétés (\b(\w+)\s+\1\b), paires de tags HTML (<([a-z]+)>...</\1>), guillemets appariés, séparateurs de dates cohérents. Le backreference doit matcher exactement ce que le groupe a capturé — pas seulement re-matcher le motif.
# \1, \2, ... refer to a PREVIOUSLY captured group's match
# The backreference must match the SAME text the group captured
# Find repeated word
\b(\w+)\s+\1\b
# Matches: "hello hello", "the the", "is is"
# Match HTML/XML tag pairs
<([a-z][a-z0-9]*)\b[^>]*>[\s\S]*?</\1>
# <div>...</div>, <p>...</p>, <span class="x">...</span>
# Match paired quotes (single or double)
(["\'])([^\1]*?)\1
# "hello" or 'hello' - same opening and closing quote
# Date with consistent separator
(\d{4})([-/])(\d{2})\2(\d{2})
# 2024-01-15 OK (same -)
# 2024-01/15 REJECTED (different separators)
# Palindrome-ish: abba
(\w)(\w)\2\1
# JavaScript
"hello hello world".match(/\b(\w+)\s+\1\b/) # ["hello hello", "hello"]
"<div>x</div>".match(/<([a-z]+)>([\s\S]*?)<\/\1>/) # ["<div>x</div>", "div", "x"]
# Python
import re
re.search(r"\b(\w+)\s+\1\b", "hello hello") # match
re.search(r"<([a-z]+)>[\s\S]*?</\1>", "<b>x</b>") # match
# Backreferences in replacement (different from in-pattern backrefs)
"hello".replace(/(\w)/g, "$1$1") # "hheelllloo"Backreferences nommées
Les backreferences nommées rendent les motifs auto-documentés. JS/.NET/Java utilisent \k<nom> ; Python/PCRE (?P=nom). Combinez avec les groupes nommés (?<nom>...) pour le matching de paires de tags, délimiteurs appariés et détection de mots répétés. Les backrefs nommées dans le remplacement utilisent $<nom> (JS) ou \g<nom> (Python).
# Named capture group + named backreference
# JavaScript: (?<name>...) then \k<name>
(?<word>\w+)\s+\k<word>
(?<tag>[a-z]+)>[\s\S]*?</\k<tag>>
# Python: (?P<name>...) then (?P=name)
(?P<word>\w+)\s+(?P=word)
(?P<tag>[a-z]+)>[\s\S]*?</(?P=tag)>
# .NET: (?<name>...) then \k<name> (same as JS)
# Java: (?<name>...) then \k<name>
# PHP/PCRE: (?P<name>...) then (?P=name) or \k<name>
# JavaScript example
const re = /\b(?<word>\w+)\s+\k<word>\b/;
"the the cat".match(re) # ["the the", "the"]
# Python example
import re
re.search(r"(?P<word>\w+)\s+(?P=word)", "hello hello") # match
# Practical: match HTML with named groups
const html = '<div class="x"><span>hi</span></div>';
const re2 = /<(?<tag>[a-z][a-z0-9]*)\b[^>]*>(?<content>[\s\S]*?)<\/\k<tag>>/;
const m = html.match(re2);
// m.groups.tag = "div", m.groups.content = '<span>hi</span>'
# Quote matching with named group
const quoteRe = /(?<q>["\'])[^\k<q>]*\k<q>/g;
'text "hello" and \'world\''.match(quoteRe) # ['"hello"', "\'world\'"]
# Named backref in replacement (JS)
"hello hello".replace(/(?<w>\w+)\s+\k<w>/, "$<w>") # "hello"Mots répétés
Détection de mots répétés : \b(\w+)\s+\1\b trouve les mots doublés comme 'the the'. Utilisez /i pour l'insensibilité à la casse. Corrigez-les en remplaçant par $1 (JS) ou \1 (Python). Variantes : triples répétitions avec (\s+\1){2}, seuls les mots courants, exclure les doubles valides comme 'had had' avec un lookahead négatif.
# Find repeated (doubled) words: "the the", "is is"
\b(\w+)\s+\1\b
# Case-insensitive
/\b(\w+)\s+\1\b/i
# JavaScript
const dupRe = /\b(\w+)\s+\1\b/gi;
"I went to the the store and and bought milk".match(dupRe)
# ["the the", "and and"]
# Python
import re
re.findall(r"\b(\w+)\s+\1\b", "the the cat", re.IGNORECASE)
# ["the"]
# Fix doubled words (replace with single)
"I went to the the store".replace(/\b(\w+)\s+\1\b/gi, "$1")
# "I went to the store"
# Python
re.sub(r"\b(\w+)\s+\1\b", r"\1", "the the cat", flags=re.I)
# "the cat"
# Find triple repeats
\b(\w+)(\s+\1){2}\b # "blah blah blah"
# Find any consecutive repeats
\b(\w+)(?:\s+\1)+\b # "blah blah blah blah"
# Limit to specific words
\b(the|and|or|is)\s+\1\b # only common stop words
# Find non-trivial repeats (3+ letters)
\b(\w{3,})\s+\1\b # excludes short words like "is is"
# Skip common valid doubles (very rare in English)
# "had had", "that that" - use negative lookahead to exclude
\b(?!had|that)(\w+)\s+\1\bMatching de tags HTML
Matchez les paires de tags HTML avec <([a-z][a-z0-9]*)\b[^>]*>[\s\S]*?</\1> — capture le nom du tag et utilise un backreference pour garantir que le tag fermant correspond. ATTENTION : la regex NE PEUT PAS gérer les tags imbriqués de même nom (comme <div><div>x</div></div>) — utilisez un vrai parseur (DOM en JS, BeautifulSoup en Python) pour le HTML imbriqué.
# Match opening and closing tag with backreference
<([a-z][a-z0-9]*)\b[^>]*>[\s\S]*?</\1>
# <div>...</div>, <span class="x">...</span>
# JavaScript
const html = '<div class="x"><p>hello</p></div>';
const re = /<([a-z][a-z0-9]*)\b[^>]*>([\s\S]*?)<\/\1>/gi;
const m = html.match(re);
// ["<div class="x"><p>hello</p></div>"]
# Iterate over all top-level tags
const re2 = /<([a-z][a-z0-9]*)\b[^>]*>([\s\S]*?)<\/\1>/gi;
let m2;
while ((m2 = re2.exec(html)) !== null) {
console.log(m2[1], m2[2]);
}
# Python
import re
re.findall(r"<([a-z][a-z0-9]*)\b[^>]*>([\s\S]*?)</\1>",
html, re.IGNORECASE)
# [("div", "<p>hello</p>")]
# Self-closing tags
<([a-z][a-z0-9]*)\b[^>]*/>
# Both opening and self-closing
<([a-z][a-z0-9]*)\b[^>]*(?:/>|>[\s\S]*?</\1>)
# Specific tag
<div\b[^>]*>([\s\S]*?)</div>
# WARNING: backreferences can't handle nested same-name tags
# <div><div>x</div></div> - regex can't match outer properly
# Use a parser for nested HTML
# Attribute extraction
<(?<tag>[a-z]+)(?<attrs>[^>]*)>(?<content>[\s\S]*?)</\k<tag>>Matching de guillemets
Matchez les chaînes quotées avec délimiteurs cohérents via (['\"])([^\1]*?)\1 — capture le guillemet ouvrant et exige le même caractère pour fermer. Pour les chaînes avec guillemets échappés (comme "bonjour \"monde\""), utilisez la plus complexe (['\"])(?:\\.|(?!\1)[^\\])*\1. Les motifs naïfs cassent sur les guillemets échappés.
# Match a quoted string with CONSISTENT quote char
(["\'])([^\1]*?)\1
# "hello" or 'hello' - opening quote remembered, closing must match
# JavaScript
const str = 'She said "hello" and he said \'hi\'';
const re = /(["\'])([^"\']*?)\1/g;
str.match(re) # ['"hello"', "\'hi\'"]
# With named group (clearer)
const re2 = /(?<q>["\'])(?<content>[^\k<q>]*?)\k<q>/g;
# Handle escaped quotes inside
# Allow \" inside double quotes, \' inside single
(["\'])(?:\\.|(?!\1)[^\\])*\1
# "hello \"world\"" matches correctly
# Python
import re
re.findall(r'(["\'])([^\1]*?)\1', 'She said "hello"')
# [('"', 'hello')]
# Practical: extract all quoted strings
text.match(/(["\'])(?:(?!\1).)*\1/g)
# Triple-quoted strings (Python-like)
(?<="""|''')[\s\S]*?\1
# Backtick strings (JS template literals)
`(?:[^\`\\]|\\.)*`
# Replace quoted content
'"hello world"'.replace(/"([^"]*)"/, "[$1]") # "[hello world]"
# WARNING: this naive pattern fails on escaped quotes:
# "hello \"world\"" - the \" ends the match early
# Use the escape-aware version above for productionRegex Unicode
Mode Unicode
Le mode Unicode est essentiel pour le texte non ASCII : JS utilise le flag /u (ES6+), Python 3 est Unicode par défaut (re.ASCII pour restreindre), PHP /u, Java Pattern.UNICODE_CHARACTER_CLASS. Sans /u en JS, les paires de substitution (emoji, CJK) sont mal traitées — quantificateurs et ancres les traitent comme deux unités de code au lieu d'une.
# JavaScript: /u flag for Unicode mode (ES6+)
/^.$/u.test("𝌆") # true (one code point)
/^.$/.test("𝌆") # false (two UTF-16 code units without /u)
# Without /u: surrogate pairs broken
"𝌆".length # 2 (surrogate pair)
/[\uD834\uDF06]/u.test("𝌆") # true (with /u, treats as one code point)
# Python 3: Unicode is default
import re
re.search(r"\w+", "日本語") # matches (Unicode by default)
# re.ASCII or re.A for ASCII-only
re.search(r"\w+", "日本語", re.ASCII) # ASCII-only, no match
# PHP: /u flag for UTF-8 mode
preg_match('/^.$/u', '𝌆') # 1 (match, treats as one code point)
# Java: Pattern.UNICODE_CHARACTER_CLASS
Pattern p = Pattern.compile("\\w+", Pattern.UNICODE_CHARACTER_CLASS);
# .NET: Unicode by default
# Go (RE2): Unicode by default
# IMPORTANT: /u changes quantifier behavior in JS
/[😂]{2}/u.test("😂😂") # true (quantifier on code point)
/[😂]{2}/.test("😂😂") # unpredictable (code units)
# Case-insensitive Unicode (with /iu)
/\w/iu.test("Ω") # true (Σ/σ/ς equivalence)
# Validate astral plane characters (emoji, ancient scripts)
/^[\u{1F300}-\u{1F9FF}]+$/u # emoji range
/[\u{1F600}-\u{1F64F}]/u # emoticonsÉchappements de propriétés \p{...}
Les échappements de propriétés Unicode (\p{L}, \p{N}, \p{Script=Han}, \p{Emoji}) matchent par propriété de caractère, pas par plage de points de code. Bien plus lisibles et robustes que des plages comme [\u4e00-\u9fff]. JS exige le flag /u (ES2018+ pour les propriétés). Python exige le module tiers 'regex' ou Python 3.13+. PHP/Java/.NET/Go le supportent nativement.
# Unicode property escapes (require /u in JS)
# \p{L} or \p{Letter} - any letter (any script)
/^\p{L}+$/u.test("Hello") # true
/^\p{L}+$/u.test("日本語") # true (CJK letters)
/^\p{L}+$/u.test("Привет") # true (Cyrillic)
# \p{N} or \p{Number} - any number
/^\p{N}+$/u.test("123") # true
/^\p{N}+$/u.test("١٢٣") # true (Arabic-Indic digits)
# \p{P} or \p{Punctuation}
/^\p{P}+$/u.test("!?.") # true
# \p{S} or \p{Symbol}
/^\p{S}+$/u.test("$€¥") # true (currency symbols)
# \p{Z} or \p{Separator} (whitespace including Unicode)
/^\p{Z}+$/u.test(" \u3000") # true (incl. ideographic space)
# Negation: \P{...} (uppercase P)
/^\P{L}+$/u.test("123!") # true (no letters)
# Specific scripts
\p{Script=Han} # CJK characters
\p{Script=Latin} # Latin alphabet
\p{Script=Greek} # Greek
\p{Script=Cyrillic} # Russian etc.
# Categories (long form)
\p{Letter} # same as \p{L}
\p{Lowercase_Letter} # same as \p{Ll}
\p{Uppercase_Letter} # same as \p{Lu}
# Emoji
\p{Emoji} # any emoji character
\p{Emoji_Presentation} # emoji with emoji presentation
# JavaScript support: ES2018+
# Python: needs 'regex' module (PyPI) or Python 3.13+
# PHP: /u flag with \p{L} etc.
# Java: \p{L} (Unicode by default)
# .NET: \p{L} by default
# Go (RE2): \p{L} by defaultPropriété lettre \p{L}
\p{L} matche toute lettre de tout script — latin, grec, cyrillique, CJK, arabe, hébreu, etc. Sous-catégories : \p{Lu} (majuscule), \p{Ll} (minuscule), \p{Lo} (autres — idéogrammes CJK, arabe). Utilisez \p{L}+ pour un matching de mots conscient d'Unicode au lieu de \w+ (ASCII seul par défaut).
# \p{L} matches any letter in any script
# Match any word (Unicode-aware)
/\p{L}+/gu # matches "hello", "日本語", "Привет"
# Match a single Latin letter
/\p{Script=Latin}/u
# Specific letter categories
\p{Lu} # uppercase letter (A, B, Ω, Ψ)
\p{Ll} # lowercase letter (a, b, ω, ψ)
\p{Lt} # titlecase letter (Dž, Lj - rare)
\p{Lm} # modifier letter (ˆ, ˇ)
\p{Lo} # other letter (CJK, Arabic, Hebrew)
# JavaScript examples
"Hello Ωμέγα".match(/\p{L}+/gu) # ["Hello", "Ωμέγα"]
"hello WORLD".match(/\p{Lu}+/gu) # ["WORLD"]
"Hello".match(/\p{Ll}+/gu) # ["ello"]
# Validate Unicode identifier
/^[\p{L}_][\p{L}\p{N}_]*$/u
# Match Capitalized Unicode word
/\p{Lu}\p{Ll}*/u # "Hello", "Ωμέγα" (if Ω is uppercase)
# Count letters
const text = "Hello 世界 123";
const letters = text.match(/\p{L}/gu) || [];
// ["H", "e", "l", "l", "o", "世", "界"]
# Python (with 'regex' module)
import regex
regex.findall(r"\p{L}+", "Hello 世界")
# Split on non-letters (Unicode-aware)
"hello, world!世界".split(/\P{L}+/u) # ["hello", "world", "世界"]Propriété nombre \p{N}
\p{N} matche tout nombre : ASCII 0-9, arabo-indien ٠-٩, devanagari ०-९, chiffres romains, fractions. Sous-catégories : \p{Nd} (chiffres décimaux), \p{Nl} (nombres-lettres comme Ⅷ), \p{No} (autres comme ½, ²). Pour de l'ASCII seul, utilisez [0-9] explicitement — \d en JS sans /u est ASCII, mais avec /u matche les chiffres Unicode.
# \p{N} matches any number character in any script
# Match digits in any script
\p{N}+ # 123, ١٢٣ (Arabic-Indic), १२३ (Devanagari), etc.
# Subcategories
\p{Nd} # decimal digit (0-9, ٠-٩ Arabic, ०-९ Devanagari)
\p{Nl} # letter number (Roman numerals Ⅷ, etc.)
\p{No} # other number (fractions ½, superscripts ²)
# JavaScript
"Price: 123, Arabic: ١٢٣".match(/\p{N}+/gu)
# ["123", "١٢٣"]
# Match only ASCII digits
/[0-9]/ # ASCII digit
/\d/ # in JS without /u: same as [0-9]
/\d/u # with /u: matches Unicode digits too!
# ASCII-only number (always)
/[0-9]+/
# Match decimals (with optional decimal point)
/\p{N}+(?:\.\p{N}+)?/u
# Count digits (any script)
const text = "123 ١٢٣";
const digits = text.match(/\p{Nd}/gu) || [];
// ["1", "2", "3", "١", "٢", "٣"]
# Python
import regex
regex.findall(r"\p{N}+", "123 ١٢٣")
# Extract version numbers (ASCII only)
const v = "Version 1.2.3 released";
v.match(/[0-9]+(?:\.[0-9]+)+/)[0] # "1.2.3"
# Currency with Unicode digits
/\p{Sc}\p{Nd}+(?:\.\p{Nd}+)?/u # $123.45, €١٢٣.٤٥Matching d'emoji
Matchez les emoji avec \p{Emoji} (ES2018+ en JS, exige /u). Plages courantes : \u{1F600}-\u{1F64F} (émoticônes), \u{1F300}-\u{1F5FF} (symboles). Le vrai matching d'emoji est complexe — les séquences ZWJ (👨👩👧) joignent plusieurs points de code, les sélecteurs de variation (\uFE0F) changent le rendu, les drapeaux sont des paires d'indicateurs régionaux. Pour un matching complet des emoji, utilisez une bibliothèque dédiée.
# Match emoji (requires /u flag in JS)
# Simple emoji property
/\p{Emoji}/u # any emoji character
/^\p{Emoji}+$/u.test("👋😀🎉") # true
# Emoji with presentation (displayed as emoji, not text)
/\p{Emoji_Presentation}/u
# Common emoji ranges (for older engines without \p{Emoji})
/[\u{1F600}-\u{1F64F}]/u # emoticons
/[\u{1F300}-\u{1F5FF}]/u # symbols & pictographs
/[\u{1F680}-\u{1F6FF}]/u # transport & map
/[\u{1F700}-\u{1F77F}]/u # alchemical
/[\u{2600}-\u{26FF}]/u # misc symbols (☀ ☂ ☎)
/[\u{2700}-\u{27BF}]/u # dingbats (✁ ✂ ✃)
# Combined range
/[\u{1F300}-\u{1F9FF}\u{2600}-\u{27BF}]/u
# Count emoji in text
const text = "Hello 👋😀 world 🎉";
const emoji = text.match(/\p{Emoji}/gu) || [];
// ["👋", "😀", "🎉"]
# Strip emoji from text
text.replace(/\p{Emoji}/gu, "") # "Hello world "
# Emoji with modifiers (skin tones, ZWJ sequences)
# 👨👩👧 is actually multiple code points joined by ZWJ (\u200D)
/\p{Emoji}(?:\u200D\p{Emoji})*/u
# matches a ZWJ sequence as one emoji
# Emoji with variation selector (\uFE0F)
/\p{Emoji}\uFE0F?/u # optional variation selector
# Flag emoji (regional indicators)
/[\u{1F1E6}-\u{1F1FF}]{2}/u # 🇺🇸, 🇨🇳, etc.
# JavaScript support: ES2018+ (\p{Emoji})
# Python: needs 'regex' module
# PHP: /u flag with \p{Emoji}Différences entre langages
JavaScript
Regex JavaScript : le littéral /motif/flags est le plus courant. ES2018+ a ajouté lookbehind, groupes nommés, échappements de propriétés Unicode. ES2020+ a ajouté matchAll (plus sûr que /g+exec). Attention au piège de lastIndex avec /g et exec(). Pour des motifs dynamiques, utilisez le constructeur RegExp. Échappez les métacaractères quand vous bâtissez des motifs depuis une saisie utilisateur.
# JavaScript regex features
# Literal syntax (preferred for static patterns)
const re = /pattern/flags;
# Constructor (for dynamic patterns)
const re2 = new RegExp("pattern", "flags");
# Flags: g (global), i (case-insensitive), m (multiline),
# s (dotAll, ES2018+), u (Unicode), y (sticky)
# Methods
/pattern/.test(string) # boolean
string.match(/pattern/) # match info or array
string.match(/pattern/g) # array of matches (no groups)
[...string.matchAll(/pattern/g)] # iterator (ES2020+)
string.replace(/pattern/, "repl") # replace first
string.replace(/pattern/g, "repl") # replace all
string.split(/pattern/) # split
string.search(/pattern/) # index of first match or -1
# Named groups (ES2018+)
const m = "2024-01-15".match(/(?<y>\d{4})/);
m.groups.y # "2024"
# Lookbehind (ES2018+, not supported in old Safari)
/(?<=\$)\d+/.test("$100") # true
# Unicode property escapes (ES2018+)
/^\p{L}+$/u.test("Hello") # true
# Gotcha: /g with exec() maintains lastIndex
const r = /a/g;
r.exec("aaa"); r.lastIndex # 1
r.exec("aaa"); r.lastIndex # 2
# Use matchAll or reset lastIndex to 0
# String.prototype.replaceAll (ES2021+)
"a-b-c".replaceAll("-", "+") # "a+b+c"
# Escape function for literal strings
function escapeRegExp(s) {
return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}Python
Le module re de Python utilise des chaînes brutes (r"") pour éviter le double échappement. Fonctions clés : search (n'importe où), match (ancré au début), fullmatch (entier), findall, finditer, sub (remplacer), split. Syntaxe de groupes nommés propre à Python : (?P<nom>...) et (?P=nom). Python 3.11+ ajoute le timeout regex. Le module tiers 'regex' ajoute les propriétés \p{...} et les motifs récursifs.
# Python regex (re module)
import re
# Raw strings (r"...") avoid double-escaping
pattern = r"\bword\b"
re.search(pattern, text) # find anywhere
re.match(pattern, text) # anchored at start
re.fullmatch(pattern, text) # entire string
# Flags (constants)
re.IGNORECASE # or re.I - case-insensitive
re.MULTILINE # or re.M - ^ $ match line boundaries
re.DOTALL # or re.S - . matches newline
re.VERBOSE # or re.X - allow whitespace and comments
re.ASCII # or re.A - ASCII-only for \w \d \s
re.UNICODE # default in Python 3
# Combine flags with |
re.search(pattern, text, re.IGNORECASE | re.MULTILINE)
# Inline flags
(?i)pattern # case-insensitive
(?im)pattern # multiple inline flags
(?i:pattern) # scoped (Python 3.6+)
# Common functions
re.search(pattern, string, flags) # Match or None
re.match(pattern, string, flags) # Match or None (anchored)
re.fullmatch(pattern, string) # Match or None (entire)
re.findall(pattern, string) # list of matches or tuples
re.finditer(pattern, string) # iterator of Match objects
re.sub(pattern, repl, string, count=0) # replace
re.split(pattern, string, maxsplit=0) # split
# Named groups (Python-specific syntax)
(?P<name>pattern) # capture
(?P=name) # backreference
\g<name> # in replacement
# Compiled pattern (faster for reuse)
p = re.compile(r"\d+", re.IGNORECASE)
p.search("abc 123")
# Timeout (Python 3.11+)
re.compile(r"(a+)+").match(long_string, timeout=1.0)
# Third-party 'regex' module adds: \p{...}, variable lookbehind, recursJava
La regex Java exige un double échappement dans les chaînes ("\\d" pour \d). Le duo Pattern/Matcher sépare compilation et matching. find() avance vers la correspondance suivante ; matches() exige que toute la chaîne matche ; lookingAt() ancre au début. Java supporte les quantificateurs possessifs (a++) et groupes atomiques (?>...). Le lookbehind doit être de longueur fixe. Java 7+ a ajouté les groupes nommés.
# Java regex (java.util.regex)
import java.util.regex.*;
# Compile pattern (double-escape backslashes in Java strings)
Pattern p = Pattern.compile("\\bword\\b");
Matcher m = p.matcher("a word here");
# Methods
m.find() # finds next match (boolean)
m.matches() # entire string matches (boolean)
m.lookingAt() # matches at start (boolean)
m.group() # entire match
m.group(1) # first capture group
m.start() # start index
m.end() # end index
# Replace
m.replaceAll("repl") # all matches
m.replaceFirst("repl") # first match only
# String convenience methods (compile internally)
"abc".matches("a.c") # true (entire string)
"a-b-c".replaceAll("-", "+") # "a+b+c" (regex)
"a-b-c".replace("-", "+") # "a+b+c" (literal)
"a-b-c".split("-") # ["a", "b", "c"]
# Flags (constants)
Pattern.CASE_INSENSITIVE # or 1 << 1
Pattern.MULTILINE # or 1 << 2
Pattern.DOTALL # or 1 << 3
Pattern.UNICODE_CHARACTER_CLASS # or 1 << 7
Pattern.COMMENTS # or 1 << 4
# Combine flags with |
Pattern.compile("abc", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE)
# Inline flags
(?i)abc # case-insensitive
(?id)abc # multiple
(?i:abc) # scoped
# Named groups (Java 7+)
(?<name>pattern)
\k<name> # backreference
${name} # in replacement
# Lookbehind: must be FIXED length
(?<=ab|cd)x # OK (same length)
(?<=ab|abc)x # ERROR (different length)
# Possessive quantifiers (Java supports)
a++ a*+ a?+ a{2,5}+
# Atomic groups
(?>a|b)
# Stream matches (Java 9+)
p.matcher(input).results().forEach(m -> ...);PHP (PCRE)
PHP utilise PCRE avec syntaxe de délimiteur (/motif/flags). Fonctions : preg_match (correspondance unique), preg_match_all (toutes), preg_replace, preg_replace_callback, preg_split. Les flags viennent après le délimiteur fermant (i, m, s, x, u). Groupes nommés : (?P<nom>...) ou (?<nom>...). Utilisez le flag /u pour l'UTF-8. Choisissez un autre délimiteur (#, ~) si votre motif contient /.
# PHP regex (PCRE - Perl-Compatible Regular Expressions)
# Pattern delimited by / (or other chars like #, ~, |)
/^[a-z]+$/i
'~^[a-z]+$~i'
# Functions
preg_match('/pattern/', $subject) # 0 or 1 (bool-ish)
preg_match('/pattern/', $subject, $matches) # fills $matches
preg_match_all('/pattern/', $subject, $matches) # count, fills $matches
preg_replace('/pattern/', 'repl', $subject) # replace all
preg_replace_callback('/pattern/', fn, $subject) # function replace
preg_split('/pattern/', $subject) # split
# Flags after closing delimiter
i # case-insensitive
m # multiline (^ $ at line boundaries)
s # dotall (. matches newline)
x # extended (whitespace ignored, # comments)
u # treat pattern and subject as UTF-8
# Combine: /pattern/imsu
# $matches structure
preg_match('/(\w+)@(\w+)/', 'user@host', $m);
# $m[0] = "user@host" (whole match)
# $m[1] = "user" (group 1)
# $m[2] = "host" (group 2)
# preg_match_all with PREG_SET_ORDER
preg_match_all('/(\w+)/', 'a b c', $m, PREG_SET_ORDER);
# $m[0] = ["a", "a"], $m[1] = ["b", "b"], ...
# Named groups
/(?P<name>\w+)/ # PHP/PCRE style (also (?<name>...))
/(?<name>\w+)/ # alternative
\k<name> # backreference
$matches['name'] # access by name
# Replacement references
$1, $2 # numbered groups
\1, \2 # also valid
${1} # unambiguous (e.g., ${1}0 to avoid $10)
# Unicode properties (with /u flag)
preg_match('/^\p{L}+$/u', 'Hello')
# PCRE-specific features
(?P<name>...) # named (Python-compatible)
(?<name>...) # named (alternative)
(?P=name) # backreference
(?>...) # atomic group
a++ # possessive
\R # any line break sequence
(*FAIL) # force fail
(*SKIP) # skip in findall
# Delimiter alternatives (when pattern contains /)
# /pattern/, #pattern#, ~pattern~, |pattern|, !pattern!Go (RE2)
Go utilise RE2 — un moteur à temps linéaire SANS backreferences, lookbehind, groupes atomiques ni quantificateurs possessifs. En échange, RE2 est immunisé contre le backtracking catastrophique. Méthodes : MatchString (bool), FindString (première), FindAllString (toutes), ReplaceAllString, Split. Utilisez des chaînes brutes (backticks) pour éviter le double échappement. Flags en ligne seulement : (?i), (?m), (?s).
# Go regex (RE2 engine - linear time, no backreferences)
import "regexp"
# Compile pattern (must use raw string `...` or escape backslashes)
re := regexp.MustCompile(`\bword\b`)
re := regexp.MustCompile("\\bword\\b") # with escaping
# Methods
re.MatchString("a word here") # bool
re.FindString("a word here") # first match or ""
re.FindAllString("a b c", -1) # []string of all matches
re.FindStringSubmatch("user@host") # [whole, group1, group2, ...]
re.FindAllStringSubmatch(text, -1) # [][]string
re.FindStringIndex("abc") # [start, end] or nil
re.ReplaceAllString("a-b-c", "+") # "a+b+c"
re.ReplaceAllStringFunc(text, func)
re.Split("a,b,c", -1) # []string
# -1 means "all matches"; positive N limits splits/matches
# Named groups
re := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})`)
m := re.FindStringSubmatch("2024-01")
# m[0]="2024-01", m[1]="2024", m[2]="01"
# Access by name
re.SubexpNames() # ["", "year", "month"]
# IMPORTANT: RE2 limitations
# - NO backreferences (\1)
# - NO atomic groups (?>...)
# - NO possessive quantifiers (a++)
# - NO lookbehind (?<=...)
# - NO lookahead (?!...) — but (?=...) IS supported
# - NO recursive patterns
# - NO conditional patterns
# In exchange: linear-time guarantee (no catastrophic backtracking)
# Flags (inline only — no separate flags arg)
(?i) # case-insensitive
(?m) # multiline
(?s) # dotall
(?i)pattern # applies to whole pattern
(?i)abc(?-i)def # scoped (PCRE-style, not in Go)
# Compile vs MustCompile
re, err := regexp.Compile(pattern) # returns error
re := regexp.MustCompile(pattern) # panics on error
# Quote literal string for safe regex use
regexp.QuoteMeta("1.5") # "1\\.5".NET / C#
La regex .NET est riche en fonctionnalités : groupes nommés (?<nom>...), balancing groups (uniques — peuvent matcher des structures imbriquées comme des parenthèses équilibrées), timeouts, MatchEvaluator pour les remplacements par fonction. Utilisez les chaînes verbatim (@"") pour éviter le double échappement. RegexOptions.Singleline signifie dotall (nom déroutant). .NET supporte le plus de fonctionnalités regex des grands moteurs.
# .NET regex (System.Text.RegularExpressions)
using System.Text.RegularExpressions;
# Static methods
Regex.IsMatch("abc", "a.c") # bool
Regex.Match("abc", "a.c") # first match
Regex.Matches("a1 b2", "\d+") # all matches
Regex.Replace("a-b-c", "-", "+") # "a+b+c"
Regex.Split("a,b,c", ",") # string[]
# Instance (compiled for reuse)
Regex re = new Regex("\\d+", RegexOptions.Compiled);
re.Match("abc 123");
re.Matches("abc 123 456");
re.Replace("abc 123", "X");
# Flags (RegexOptions enum)
RegexOptions.IgnoreCase # i
RegexOptions.Multiline # m
RegexOptions.Singleline # s (dotall - confusing name!)
RegexOptions.ExplicitCapture # only named groups capture
RegexOptions.IgnorePatternWhitespace # x (extended)
RegexOptions.Compiled # compile to IL (faster, slower startup)
RegexOptions.CultureInvariant
# Combine with |
new Regex("abc", RegexOptions.IgnoreCase | RegexOptions.Multiline)
# Named groups (.NET style)
(?<name>pattern) # capture
(?<name1>...) (?<name2>...) # multiple
\k<name> # backreference
${name} # in replacement
# Alternation in group names (balancing groups - .NET specific)
(?<name1-name2>...) # pop name2 stack into name1
# Group access
Match m = re.Match("2024-01-15");
m.Groups["year"].Value
m.Groups[1].Value
# Replace with MatchEvaluator (function)
Regex.Replace("abc", "\w", m => m.Value.ToUpper()) # "ABC"
# Timeouts (.NET 4.5+)
Regex re = new Regex("a+", RegexOptions.None, TimeSpan.FromSeconds(1));
# Unicode supported by default
Regex.IsMatch("Hello", @"\p{L}+") # true (note: @"" verbatim string)
# Verbatim strings (@"...") avoid double-escaping
@"\d+" # same as "\\d+" but cleaner
# Surprisingly powerful: balancing groups for nested matching
# Can match balanced parentheses (unique to .NET)
@"((?:[^()]+|(?<Open>\()|(?<Close-Open>\)))*)"Techniques avancées
Groupes atomiques
Les groupes atomiques (?>...) empêchent le backtracking dans le groupe une fois matché. Utiles pour la performance (évite le backtracking catastrophique) et pour verrouiller des correspondances. Supportés par PCRE, Java, .NET et le module 'regex' de Python — PAS par JavaScript. Alternative en JS : refactorer le motif ou utiliser des classes spécifiques pour éviter le backtracking.
# Atomic group: (?>...) - once matched, NO backtracking into it
# Supported in PCRE, Java, .NET — NOT in JavaScript or Python's re
# Greedy with backtracking
\d+a # in "123a", \d+ takes "123", then backtracks to "12" if needed
(?>\d+)a # atomic: \d+ takes "123" and CANNOT give back
# When atomic helps: prevent catastrophic backtracking
# Dangerous: (a+)+b on "aaaa...!"
# Safe (atomic): (?>a+)+b or (?>a+b)
# Use case: prevent unwanted backtracking in alternation
# Without atomic: tries each alternative, backtracks on fail
(?>cat|category) # if "cat" matches, won't try "category"
# Practical: match HTML tag without backtracking issues
(?><[a-z][a-z0-9]*\b[^>]*>)
# Quoted string without backtracking issues
(?>"[^"]*")
# Java
Pattern p = Pattern.compile("(?>\\d+)a");
# PHP/PCRE
preg_match('/(?>\d+)a/', '123a')
# .NET
new Regex("(?>\d+)a")
# Python: not in re module; use 'regex' module
import regex
regex.search(r"(?>\d+)a", "123a")
# JavaScript: NOT supported
# Use possessive quantifiers (also not in JS) or refactor patternQuantificateurs possessifs
Les quantificateurs possessifs (a++, a*+, a?+) ressemblent aux gourmands mais ne rendent jamais leurs correspondances. Équivalents aux groupes atomiques mais plus courts. Supportés en Java et PCRE — PAS en .NET, JavaScript ni le re de Python. Utilisez les groupes atomiques (?>...) comme alternative portable. Les deux préviennent le backtracking catastrophique en évitant le backtracking inutile.
# Possessive: a++ a*+ a?+ a{n,m}+
# Like greedy but NEVER gives back (no backtracking)
# Greedy (gives back if needed)
\d+a # "123a": \d+ takes "123", matches a
\d+x # "123x": \d+ takes "123", then x matches
# Possessive (never gives back)
\d++a # "123a": \d+ takes "123", matches a
\d++x # "123x": \d+ takes "123", x fails - NO backtrack, FAIL
# When possessive helps: avoid catastrophic backtracking
# Dangerous: (a+)+ on "aaaaaa!"
# Possessive: (a++)+ or (?>a+)+
# Both prevent exponential backtracking
# Common possessive patterns
"[^"]*"++ # possessive quoted string
<[a-z]++> # possessive tag name
\d++\.\d++ # possessive decimal
# Java supports possessive quantifiers
Pattern.compile("\\d++a");
# PHP/PCRE supports possessive
preg_match('/\d++a/', '123a')
# .NET: does NOT support possessive quantifiers directly
# Use atomic groups instead: (?>\d+)a
# Python 're': NOT supported
# Python 'regex' module: supports \d++ ? Actually no, use (?>\d+)
# JavaScript: NOT supported
# Use atomic groups (also not in JS) or refactor
# Comparison: possessive vs atomic
\d++ # possessive quantifier (Java, PCRE)
(?>\d+) # atomic group (Java, PCRE, .NET)
# Both prevent backtracking; possessive is shorter syntaxMotifs conditionnels
Les motifs conditionnels (?(condition)oui|non) matchent différents motifs selon qu'un groupe a matché ou qu'un lookahead réussit. Supportés par PCRE, .NET, Perl et le module 'regex' de Python — PAS par JavaScript ni Java. Contournement dans les moteurs non supportés : alternance, plusieurs motifs combinés en code, ou lookarounds.
# Conditional: (?(condition)yes-pattern|no-pattern)
# PCRE, .NET, Perl — NOT JavaScript or Python's re
# Conditional based on group match
(?(1)yes|no) # if group 1 matched, use yes-pattern; else no-pattern
(?(<name>)yes|no) # named group version
# Example: match "Mr. Smith" or "Smith" based on title presence
(Mr\.\s+)?(\w+)(?(1)\s+\2|) # if title, require last name repeated?
# Practical: optional separator
# If first separator was -, second must be -
# If first was /, second must be /
(\d{4})([-/]?)(\d{2})(?(2)\2|[-/]?)(\d{2})
# Conditional based on lookahead
(?(?=\d)\d+|[a-z]+) # if next is digit, match digits; else letters
# Python 'regex' module supports conditionals
import regex
regex.search(r"(?(1)yes|no)", text)
# .NET supports conditionals
new Regex("(?(1)yes|no)")
# PCRE/PHP supports conditionals
preg_match('/(?(1)yes|no)/', $text)
# Java: does NOT support conditionals directly
# Use alternation and lookarounds as workaround
# JavaScript: NOT supported
# Refactor with alternation:
# (?(1)A|B) becomes: (?:group1A|B) in some cases
# Or use two separate patterns and combine in code
# Real-world: parse key-value where value is conditional
# If key is "url", value must be URL; if "count", value must be number
(url|count):(?(?<=url:)https?://\S+|\d+)Récursion (PCRE)
Les motifs récursifs (?R) matchent des structures imbriquées comme des parenthèses équilibrées, du HTML imbriqué ou des expressions mathématiques. PCRE/Perl et le module 'regex' de Python le supportent directement. .NET utilise plutôt les « balancing groups » uniques. JavaScript et Java ne supportent PAS la récursion regex — utilisez un parseur ou une approche par pile pour les structures imbriquées.
# Recursive patterns: (?R) or (?N) - match nested structures
# PCRE, Perl, .NET (balancing groups) — NOT JS, Java, Python re
# Match balanced parentheses (PCRE)
\((?:[^()]+|(?R))*\)
# Matches: "(a)", "(a(b)c)", "((a)(b))", etc.
# Named recursion (PCRE)
(?<paren>\((?:[^()]+|(?&paren))*\))
# Match nested HTML/XML tags (PCRE)
(?<tag><([a-z]+)(?:[^>]+)>[^<]*</\2>|<([a-z]+)(?:[^>]+)>(?R)*</\3>)
# Python 'regex' module supports recursion
import regex
regex.search(r"\((?:[^()]+|(?R))*\)", "(a(b)c)")
# .NET: use balancing groups instead of recursion
# Match balanced parens:
\((?:[^()]+|(?<Open>\()|(?<Close-Open>\)))*\)
# More complex but powerful
# PHP/PCRE
preg_match('/\((?:[^()]+|(?R))*\)/', '(a(b)c)')
# JavaScript: NOT supported
# Use a parser or stack-based approach in code
function matchBalanced(s) {
let depth = 0, start = -1, results = [];
for (let i = 0; i < s.length; i++) {
if (s[i] === "(") { if (depth === 0) start = i; depth++; }
else if (s[i] === ")") {
depth--;
if (depth === 0 && start !== -1) {
results.push(s.slice(start, i + 1));
start = -1;
}
}
}
return results;
}
# Java: NOT supported
# Use third-party library or stack-based parserConseils de performance
Performance regex : compilez les motifs pour réutilisation, soyez spécifique (évitez .), ancrez quand possible, utilisez des groupes non capturants, évitez le backtracking catastrophique, préférez les classes niées aux quantificateurs paresseux, ordonnez l'alternance par vraisemblance, réglez des timeouts pour les entrées non fiables. Utilisez les méthodes de String (trim, split, indexOf) quand elles suffisent — souvent plus rapides que la regex.
# 1. Compile patterns for reuse (Python, Java)
import re
p = re.compile(r"\d+") # compile once
for line in lines:
p.search(line) # reuse
# 2. Be specific - avoid . when you know the char class
# Bad: .*
# Good: [a-z]* or \w* or [^,]*
# Faster and clearer intent
# 3. Anchor when possible
# Bad: \d+
# Good: ^\d+$ (if validating entire string)
# Anchors let the engine fail fast
# 4. Use non-capturing groups when you don't need captures
# Bad: (\d{1,3}\.){3}\d{1,3}
# Good: (?:\d{1,3}\.){3}\d{1,3}
# Saves memory and time
# 5. Avoid catastrophic backtracking
# Bad: (a+)+b on "aaaa...!"
# Good: a++b (possessive) or (?>a+)b (atomic) or a*b
# 6. Prefer negated classes over lazy quantifiers for delimited content
# Slower: ".*?"
# Faster: "[^"]*"
# 7. Use atomic groups / possessive quantifiers when safe
(?>\d+) # no backtracking needed for digits
# 8. Order alternation by likelihood
# Bad: (rare|common)
# Good: (common|rare)
# Engine tries left to right
# 9. Avoid nested quantifiers on overlapping alternatives
# Bad: (a|a)*b
# Good: a*b
# 10. Set timeouts for untrusted input (Python 3.11+, .NET 4.5+)
re.compile(pattern).match(input, timeout=1.0)
# 11. Use RE2 for untrusted patterns (Go, or libraries)
# Linear time, immune to catastrophic backtracking
# Trade-off: no backreferences
# 12. Benchmark with realistic data
# Use timeit (Python) or performance.now() (JS)
# 13. Avoid lookahead/lookbehind when a simpler pattern works
# Bad: (?<=\$)\d+
# Good: \$(\d+) and use group 1 (often faster)
# 14. Use String methods for simple operations
# Bad: text.replace(/^\s+|\s+$/g, "")
# Good: text.trim() (much faster)Snippets Regex associés
Copy-paste ready code for common tasks.
Character Classes
Match sets and ranges of characters.
Quantifiers
Control how many times a token repeats.
Groups and Capturing
Capture, non-capture, and named groups.
Lookaround
Zero-width assertions around a position.
Alternation
Match one of several branches.
Anchors
Match positions instead of characters.
Backreferences
Reuse a previously captured group.
Common Patterns
Practical patterns for everyday validation.
Was this helpful?