Expressions régulières de base sous Linux

Les expressions régulières (regex) sont le langage commun de grep, sed et awk. Sans elles, vous cherchez du texte ligne par ligne. Avec elles, vous filtrez des milliers de lignes en une commande, extrayez des champs structurés et détectez des anomalies dans des logs en production.

Ce guide couvre les regex POSIX — utilisées nativement par les outils Linux — et leur extension ERE que grep -E et sed -E activent.

Ce que vous allez apprendre

Utiliser les ancres ^ et $, le point . et les classes [...]
Appliquer les quantificateurs BRE (\{n,m\}) et ERE ({n,m}, +, ?)
Extraire seulement la partie matchée avec grep -oE
Nettoyer un fichier de config avec sed et des regex
Reformater des données avec des groupes de capture $...$ et \1
Reconnaître et éviter les deux pièges les plus fréquents

Dans quel contexte ?

Vous ne maîtrisez pas les regex pour faire beau sur un CV — vous en avez besoin dès que vous travaillez sérieusement avec grep, sed ou awk. Exemples concrets : extraire toutes les adresses IP d’un log pour les bloquer dans un pare-feu ; détecter les lignes d’un fichier de configuration qui ne respectent pas un format attendu avant de le déployer ; corriger en masse des noms de variables dans des dizaines de fichiers de config ; filtrer uniquement les erreurs critiques dans un flux de logs en temps réel. Les regex sont transversales — une fois que vous les maîtrisez dans grep, vous les réutilisez immédiatement dans sed, awk, Python, votre IDE et vos pipelines CI. C’est l’un des investissements techniques les mieux amortis en administration système.

BRE vs ERE : les deux dialectes POSIX

Linux utilise deux variantes de POSIX regex :

Dialecte	Activé par	Syntaxe quantificateurs
BRE (Basic)	`grep`, `sed` par défaut	`\{n,m\}`, `\+`, `\?`
ERE (Extended)	`grep -E`, `sed -E`, `awk`	`{n,m}`, `+`, `?`, `\|`

Les blocs de base

Ancres — fixer la position

grep '^192' serveurs.txt        # lignes commençant par 192
grep '\.com$' serveurs.txt      # lignes se terminant par .com
grep '^$' fichier.txt           # lignes vides
grep -v '^#' config.ini         # exclure les commentaires

Les ancres ne consomment pas de caractères, elles fixent où le match doit se produire.

Classes de caractères

Une classe [...] matche un seul caractère parmi ceux listés :

grep '[0-9]' fichier.txt        # contient un chiffre
grep '[a-zA-Z]' fichier.txt     # contient une lettre
grep '[^0-9]' fichier.txt       # contient un non-chiffre (^ = négation)

Les classes POSIX sont portables entre distributions :

Classe	Équivalent	Usage
`[[:digit:]]`	`[0-9]`	Chiffres
`[[:alpha:]]`	`[a-zA-Z]`	Lettres
`[[:alnum:]]`	`[a-zA-Z0-9]`	Lettres et chiffres
`[[:space:]]`	`[ \t\n]`	Espaces et tabulations
`[[:lower:]]`	`[a-z]`	Minuscules
`[[:upper:]]`	`[A-Z]`	Majuscules

# Lignes qui commencent par des espaces (indentation)
grep '^[[:space:]]\+' config.ini

# Lignes vides ou avec seulement des espaces
grep '^[[:space:]]*$' config.ini

Le point `.`

. matche n’importe quel caractère (sauf saut de ligne) :

grep 'ser.eur' serveurs.txt     # serv-eur, ser_eur, serveur...
grep '10\.0' serveurs.txt       # 10.0 littéral (point échappé)

Quantificateurs

Ils s’appliquent au caractère ou groupe qui précède :

BRE	ERE	Signification
`*`	`*`	0 ou plus
`\+`	`+`	1 ou plus
`\?`	`?`	0 ou 1 (optionnel)
`\{n\}`	`{n}`	Exactement n fois
`\{n,m\}`	`{n,m}`	Entre n et m fois
`\{n,\}`	`{n,}`	n ou plus

# BRE — octets dans une adresse IP (1 à 3 chiffres)
grep '[0-9]\{1,3\}\.[0-9]\{1,3\}' serveurs.txt

# ERE — même chose, syntaxe plus lisible
grep -E '[0-9]{1,3}\.[0-9]{1,3}' serveurs.txt

grep -E : les super-pouvoirs ERE

ERE ajoute l’alternance | et les parenthèses () sans backslash :

# Codes d'erreur 4xx ou 5xx dans un access.log
grep -E '" [45][0-9]{2} ' access.log

# Lignes qui contiennent error OU warning (insensible à la casse)
grep -iE 'error|warning' syslog

# Séquences de 2 à 4 chiffres adjacents
grep -E '[0-9]{2,4}' fichier.txt

grep -o : extraire seulement le match

Par défaut, grep affiche la ligne entière. -o n’affiche que la partie matchée :

# Extraire toutes les adresses IP d'un log
grep -oE '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' access.log

192.168.1.10
10.0.0.5
192.168.1.20
172.16.0.1
192.168.1.10

Combiner avec sort | uniq -c | sort -rn pour un top des IP :

grep -oE '[0-9]{1,3}(\.[0-9]{1,3}){3}' access.log \
  | sort | uniq -c | sort -rn | head -10

Valider un format

# Adresses email (format simplifié)
grep -E '^[[:alnum:]._+-]+@[[:alnum:].-]+\.[[:alpha:]]{2,}$' fichier.txt

# Adresses IPv4 strictes (0-255 par octet — approximation utile)
grep -E '^([0-9]{1,3}\.){3}[0-9]{1,3}$' serveurs.txt

sed -E : transformer avec des regex

Nettoyer un fichier de configuration

# Supprimer les commentaires et lignes vides
sed '/^#/d; /^$/d' config.ini

# Supprimer les espaces en début de ligne
sed 's/^[[:space:]]*//' config.ini

# Normaliser le séparateur — accepter ' = ' et '=' → uniformiser en '='
sed -E 's/ *= */=/' config.ini

Enchaîner les trois :

sed '/^#/d; /^$/d' config.ini \
  | sed 's/^[[:space:]]*//' \
  | sed -E 's/ *= */=/'

serveur=web-prod-01
port=8080
timeout=30
debug=false
max_connections=100
log_level=INFO

Groupes de capture et backreferences

Les parenthèses capturent une partie du match, réutilisable avec \1, \2… :

# Convertir une date ISO en format DD/MM/YYYY
echo "2026-04-09" | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/'
# → 09/04/2026

# Inverser prénom et nom (séparés par une virgule)
echo "Robert, Stephane" | sed -E 's/([^,]+), ([^,]+)/\2 \1/'
# → Stephane Robert

Les quantificateurs sont gourmands par défaut — ils matchent le plus possible.

echo '<b>gras</b> et <i>italique</i>' | grep -oE '<.*>'
# → <b>gras</b> et <i>italique</i>   ← tout d'un coup !

Solution POSIX : utiliser une classe négative [^>]* au lieu de .* :

echo '<b>gras</b> et <i>italique</i>' | grep -oE '<[^>]*>'
# → <b>
# → </b>
# → <i>
# → </i>

awk avec des regex

awk utilise ERE nativement. Les patterns s’écrivent entre / :

# Afficher les lignes dont l'IP est dans 192.168.1.x
awk '/^192\.168\.1\./' access.log

# Lignes avec status HTTP 200 (champ 9)
awk '$9 == 200' access.log

# Combiner condition champ et regex
awk '$9 ~ /^[45]/' access.log    # status 4xx ou 5xx
awk '$9 !~ /^[45]/' access.log   # status autre que 4xx/5xx

L’opérateur ~ teste une regex sur un champ, !~ en est la négation.

Cas d’usage admin récapitulatifs

# Top 5 des IP les plus actives dans un access.log
grep -oE '^[0-9.]+' access.log | sort | uniq -c | sort -rn | head -5

# Toutes les lignes d'erreur (ERROR ou WARN, peu importe la casse)
grep -iE 'error|warn' /var/log/syslog | tail -20

# Extraire les ports ouverts d'un ss -tulnp
ss -tulnp | grep -oE ':[0-9]+' | sort -t: -k2 -n | uniq

# Valider que toutes les lignes d'un fichier d'inventaire sont au bon format IP
grep -vE '^([0-9]{1,3}\.){3}[0-9]{1,3}$' inventaire.txt \
  && echo "Format invalide détecté !"

# Nettoyer un /etc/hosts : enlever commentaires et lignes vides
grep -vE '^[[:space:]]*(#|$)' /etc/hosts

À retenir

grep = BRE par défaut ; ajoutez -E pour ERE dès que vous utilisez +, ?, {n} ou |.
grep -o extrait seulement la partie matchée — combinez avec sort | uniq -c pour des statistiques.
sed -E 's/pattern/remplacement/' transforme ; les groupes (...) se rappellent avec \1.
Deux pièges à éviter : le point non échappé (\. pour un point littéral) et la gourmandise ([^x]* au lieu de .*).
Les classes POSIX [[:digit:]], [[:alpha:]], [[:space:]] sont portables sur toutes les distributions.

Prochaines étapes

Suivre un log en temps réel tail -f, journalctl -f et grep en temps réel pour observer un système en production.

Transformer du texte avec cut, tr et paste Extraire des colonnes, convertir et fusionner du texte.

Trier, compter et dédoublonner sort, uniq, wc et comm pour analyser des listes et des logs.

Filtrer et extraire du texte Les fondamentaux de grep, cut, sort et diff.

Référence grep Toutes les options grep : -E, -o, -v, -c, --line-buffered, contexte -A/-B/-C — le condensé pour filtrer en pipeline.

Référence sed Commandes sed, adresses, scripts multi-expressions — le condensé pour la substitution en flux.