Regex — Cheat Sheet

[abc]          # a, b ou c
[^abc]         # ni a, ni b, ni c
[a-z]          # toute lettre minuscule
[A-Z]          # toute lettre majuscule
[0-9]          # tout chiffre
[a-zA-Z0-9]   # tout alphanumérique
[a-z&&[^aeiou]]  # consonnes (Java/Perl)
[\u00C0-\u017E]  # lettres latines étendues (Unicode)

.*          # greedy : prend le plus possible
.*?         # lazy : prend le moins possible
.+?         # lazy
.{2,5}?     # lazy

# Exemple avec <b>texte</b><b>autre</b>
<b>.*</b>   # → <b>texte</b><b>autre</b>  (greedy, trop)
<b>.*?</b>  # → <b>texte</b>  (lazy, correct)

(abc)              # groupe capturant
(?:abc)            # groupe non capturant (plus performant)
(?P<nom>abc)       # groupe nommé (Python/PCRE)
(?<nom>abc)        # groupe nommé (PCRE/.NET)

cat|dog            # alternance : cat OU dog
(cat|dog) food     # (cat food) ou (dog food)

# Références arrière (backreferences)
(\w+)\s\1          # mot répété (ex: "le le")
(?P<mot>\w+)\s(?P=mot)  # avec groupe nommé (Python)

# Lookahead positif : suivi de ...
\d+(?= euros)      # chiffres suivis de " euros"

# Lookahead négatif : NON suivi de ...
\d+(?! euros)      # chiffres NOT suivis de " euros"

# Lookbehind positif : précédé de ...
(?<=\$)\d+         # chiffres précédés de "$"

# Lookbehind négatif : NON précédé de ...
(?<!\$)\d+         # chiffres NOT précédés de "$"

# Inline flags (PCRE)
(?i)hello          # insensible à la casse depuis ici
(?im)^hello$       # multi-flag

# Mode verbose (commentaires dans la regex)
(?x)
  \d{4}            # année
  [-/]             # séparateur
  \d{2}            # mois
  [-/]
  \d{2}            # jour

. * + ? ^ $ { } [ ] | ( ) \

www\.example\.com   # matcher un point littéral
\(texte\)           # matcher des parenthèses littérales
\d+\.\d+            # nombre décimal (ex: 3.14)

# Email (simplifié)
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

# IPv4
^(\d{1,3}\.){3}\d{1,3}$

# IPv4 stricte (0-255)
^(25[0-5]|2[0-4]\d|[01]?\d\d?)(\.(25[0-5]|2[0-4]\d|[01]?\d\d?)){3}$

# IPv6 (simplifiée)
^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

# URL
^https?://[\w.-]+(?:\.[\w.-]+)+[\w\-._~:/?#[\]@!$&'()*+,;=.]+$

# Date ISO 8601 (YYYY-MM-DD)
^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$

# Heure (HH:MM:SS)
^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$

# Numéro de téléphone belge
^(\+32|0)(4[5-9]\d|[1-9]\d)\d{6}$

# Code postal belge
^[1-9]\d{3}$

# CIDR
^(\d{1,3}\.){3}\d{1,3}\/([0-9]|[1-2][0-9]|3[0-2])$

# UUID v4
^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$

# Hash SHA-256
^[a-f0-9]{64}$

# Adresse MAC
^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$

# Lignes vides
^\s*$

# Espaces en début/fin de ligne
^\s+|\s+$

# Balises HTML
<[^>]+>

# Commentaires C/C++
//.*$|/\*[\s\S]*?\*/

# Adresses IP dans un log
\b\d{1,3}(?:\.\d{1,3}){3}\b

# Numéros de version sémantique
v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?

# Chemins Unix
(/[\w.-]+)+/?

# Variables d'environnement
\$\{?[A-Z_][A-Z0-9_]*\}?

grep -E "regex+"          # ERE (Extended Regular Expressions)
grep -P "regex(?=lookahead)"  # PCRE (Perl-Compatible)
grep -G "regex\+"         # BRE (Basic, défaut) — + doit être échappé
grep -F "chaine.fixe"     # chaîne fixe, pas de regex

grep -E "^(ERROR|WARN)" app.log      # lignes d'erreur ou warning
grep -P "(\d{1,3}\.){3}\d{1,3}" access.log  # IPs dans un log
grep -Eo "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}"  # extraire les IPs

sed 's/pattern/remplacement/'      # BRE par défaut
sed -E 's/pattern+/remplacement/'  # ERE
sed -E 's/(groupe1)(groupe2)/\2\1/' # inverser deux groupes
sed -n '/^ERROR/p'                  # afficher les lignes matchant
sed '/^#/d'                         # supprimer les commentaires
sed -E 's/[[:space:]]+/ /g'        # compresser les espaces

awk '/^ERROR/ {print $0}'           # lignes matchant
awk '!/^#/ {print $1, $3}'         # exclure les commentaires
awk -F: '$3 > 1000 {print $1}'     # utilisateurs avec UID > 1000
awk 'NR%2==0'                       # lignes paires

find . -regex ".*\.log\.[0-9]+"    # fichiers de log archivés
find . -iregex ".*\.(jpg|png|gif)" # images (insensible casse)

# Assertions conditionnelles
(?(condition)oui|non)

# Possession (atomic groups — PCRE2)
\d++           # chiffres, pas de backtrack
[a-z]++        # lettres, pas de backtrack

# Reset de numérotation de groupe
(?|(\d+)|([a-z]+))   # les deux alternatives partagent le groupe 1

# Récursion (PCRE2)
(?P<expr>\d+|\((?P>expr)[+\-*/](?P>expr)\))

# Unicode properties
\p{Lu}         # lettre majuscule Unicode
\p{Ll}         # lettre minuscule Unicode
\p{N}          # tout chiffre Unicode
\p{L}          # toute lettre Unicode
\P{L}          # tout ce qui N'EST PAS une lettre

# Outils de test
echo "test string" | grep -P "votre_regex"       # tester avec grep
echo "test" | sed -E 's/pattern/replacement/'     # tester avec sed

# Débogage Python
python3 -c "
import re
pattern = r'votre_regex'
text = 'votre texte'
m = re.search(pattern, text)
print(m.groups() if m else 'Pas de match')
"