REGEX

Note importante : sans meta-caracteres (ni ., ni [], ni +...), une regex est juste une chaine litterale. allo matche le mot allo. 418 matche les 3 chiffres 4, 1, 8 dans cet ordre.

Autres classes utiles :

[A-Z]       une lettre majuscule
[A-Za-z]    une lettre (peu importe la casse)
[a-zA-Z0-9] alphanumerique
[0-9a-fA-F] un chiffre hexa

Equivalences :

{0,1}   equivalent a ?
{1,}    equivalent a +
{0,}    equivalent a *
{,5}    au maximum 5 fois
{3,}    au moins 3 fois

Exemples concrets :

colou?r       matche "color" ET "colour"
hel+o         matche "helo", "hello", "helllo"...
[0-9]{4}      exactement 4 chiffres (annee)
[a-z]{3,8}    mot de 3 a 8 lettres minuscules

Memo important : 2 sens pour ^

• ^abc : ancre debut de ligne (en DEHORS de crochets)
• [^abc] : negation (en DEBUT de crochets)

Memo important : le tiret - dans une classe

• [a-z] : intervalle (tiret au MILIEU)
• [abc-] : litteral (tiret a la FIN ou au debut)
• [\-] : echappe (litteral peu importe la position)

[0-9] = un seul caractere parmi l'intervalle 0 a 9 (donc 0, 1, 2, ..., 9). Le tiret signifie "intervalle".

[009] = un seul caractere parmi la liste {0, 0, 9}. Le 0 est en double mais c'est comme si on avait [09]. Donc : 0 ou 9.

009 (sans crochets) = la chaine litterale 009 (trois caracteres dans cet ordre).

Piege classique : [A-z] n'est PAS [A-Za-z] ! Entre Z et a dans la table ASCII, il y a des caracteres comme [ \ ] ^ _ `. Toujours preferer [A-Za-z].

Memo crucial :

• Coller des caracteres = concatenation (chaque caractere doit etre la, dans cet ordre)
• Coller des mots avec | entre = alternation (un seul des deux mots)
• Coller des lettres dans [ ] = classe (un seul caractere parmi)
• Le ( ) regroupe pour appliquer un quantificateur ou pour faire une capture

En pratique on prefere :

# Pour chainer avec le reste du numero
(418|514|819)-[0-9]{3}-[0-9]{4}

# a) Sans indicatif (3 chiffres - 4 chiffres)
[0-9]{3}-[0-9]{4}
# Equivalent avec repetition manuelle
[0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]

# b) Avec indicatif obligatoire (n'importe quel)
[0-9]{3}-[0-9]{3}-[0-9]{4}

# c) Indicatif fixe 418 (litteral)
418-[0-9]{3}-[0-9]{4}

# d) Indicatif 418 facultatif (groupe + ?)
(418-)?[0-9]{3}-[0-9]{4}

Notes :

• {N} et [chiffre][chiffre]... sont equivalents. Le premier est plus compact, le second est plus lisible quand on apprend.
• Pour rendre un fragment FACULTATIF : l'entourer de parentheses et ajouter ?. Sans parentheses, le ? ne s'applique qu'au caractere precedent.
• (418-)?[0-9]... matche 418-555-1234 ET 555-1234.

La page suivante (Q8) generalise au cas ou l'indicatif peut etre l'un de plusieurs (418, 514, 819) avec ou sans parentheses.

# a) Au choix obligatoire
(418|514|819)-[0-9]{3}-[0-9]{4}

# b) Au choix facultatif
((418|514|819)-)?[0-9]{3}-[0-9]{4}

# c) Methode 1 : chaque parenthese facultative independamment
\(?(418|514|819)\)?-[0-9]{3}-[0-9]{4}

Caracteristique de la methode 1 : les deux parentheses sont facultatives independamment l'une de l'autre. C'est plus court a ecrire, mais ca accepte aussi des cas asymetriques comme (418-555-1234 (parenthese ouvrante seule) ou 418)-555-1234 (fermante seule). Si on veut empecher l'asymetrie, il faut une alternative explicite : c'est l'objet de la question suivante (Q9).

Pour pratiquer les regex sur des exemples reels : regex101.com.

# Methode 2 : alternative explicite des deux formes complete
(\((418|514|819)\)|(418|514|819))-[0-9]{3}-[0-9]{4}

Decryptage :

• \((418|514|819)\) : indicatif avec les 2 parentheses
• (418|514|819) : indicatif sans parentheses
• (... | ...) : un OU l'autre, mais pas un melange

Comparaison avec methode 1 (Q8c) :

Version "parfaite" avec ancres :

^(\((418|514|819)\)|(418|514|819))-[0-9]{3}-[0-9]{4}$

La methode 2 est plus stricte et plus correcte en production. La methode 1 est plus courte mais accepte des bizarreries que la methode 2 refuse.

# a) Recherche simple (motif fixe)
grep "Failed password" /var/log/auth.log

# b) Alternation : -E pour ERE, le | sans backslash
grep -E "Failed|Invalid" /var/log/auth.log

# c) Afficher seulement les matches (utile avec une regex precise)
grep -oE "Failed [a-z]+" /var/log/auth.log

Options frequentes de grep :

• -E = regex etendue (ERE) : |, +, ?, {} sans backslash
• -i = insensible a la casse
• -v = inverse (lignes qui NE matchent PAS)
• -n = numero de ligne
• -c = compte les lignes (au lieu de les afficher)
• -r = recursif dans un repertoire
• -l = liste seulement les noms de fichiers

BRE vs ERE : En BRE (sans -E), + et ? doivent etre echappes \+ \?. Avec -E, ils gardent leur sens regex direct.

# a) Substitution sans modifier le fichier
sed 's/ERROR/WARN/g' app.log

# b) Modifier le fichier directement (in-place)
sed -i 's/ERROR/WARN/g' app.log

# c) Supprimer les lignes commencant par #
sed '/^#/d' config.conf

Decryptage de la substitution :

sed 's/MOTIF/REMPLACEMENT/FLAGS' fichier
       ^       ^             ^
       |       |             flags : g (global), i (case-insensitive)
       |       le remplacement
       le motif (regex)

Autres operations sed :

• sed -n '/motif/p' : afficher seulement les lignes qui matchent
• sed '5d' : supprimer la ligne 5
• sed '1,10d' : supprimer les lignes 1 a 10
• sed 's|ancien|nouveau|g' : delimiter avec | si / dans le motif

Backreferences : dans le remplacement, \1 = premier groupe capture.

# Inverser nom prenom dans un fichier "Prenom Nom"
sed -E 's/^([A-Z][a-z]+) ([A-Z][a-z]+)$/\2 \1/' fichier.txt

# a) Extraire toutes les IPs (note les \. pour le point litteral)
grep -oE "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+" /var/log/apache2/access.log
# Plus precis (1 a 3 chiffres par groupe)
grep -oE "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" /var/log/apache2/access.log

# b) Top 5 des IPs les plus frequentes
grep -oE "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+" /var/log/apache2/access.log \
    | sort | uniq -c | sort -rn | head -5

Decryptage de la chaine de commandes :

• grep -oE : ne montre que les IPs (pas les lignes)
• sort : trie pour grouper les IPs identiques
• uniq -c : compte les doublons (besoin que ce soit deja trie)
• sort -rn : tri inverse numerique (de la plus frequente)
• head -5 : les 5 premieres

Sortie attendue :

     12 192.168.1.42
      8 10.0.0.5
      5 203.0.113.7
      3 198.51.100.99
      2 192.168.1.50

Variante plus stricte (vraie IP, octets <= 255) :

# Regex precise pour octets 0-255 (complexe)
grep -oE "(25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})\.(25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})\.(25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})\.(25[0-5]|2[0-4][0-9]|[01]?[0-9]{1,2})" log
# En pratique [0-9]+\.[0-9]+\.[0-9]+\.[0-9]+ suffit dans 99% des cas