Maîtriser grep : Recherche de motifs

Quand on doit trouver une ligne d’erreur dans un log de plusieurs milliers de lignes, rechercher un mot-clé dans du code source ou filtrer la sortie d’une commande, grep est l’outil incontournable. Simple et puissant, grep permet de rechercher des motifs textuels (simples ou regex) et d’afficher les lignes correspondantes, directement en ligne de commande.

Ce que vous allez apprendre

• Rechercher un motif simple dans un fichier
• Utiliser les options essentielles -i, -v, -n, -c
• Afficher le contexte avec -A, -B, -C
• Utiliser des expressions régulières basiques et étendues (-E)
• Faire des recherches récursives avec -r

La commande grep dans l’écosystème Linux

grep fait partie des commandes de traitement de texte sous Linux. Chaque outil a sa spécialité :

Commande	Spécialité	Quand l’utiliser
grep	Filtrer des lignes par motif	Rechercher, filtrer, diagnostiquer
awk	Traitement avancé de colonnes	Calculs, conditions, formats complexes
sed	Éditer du texte en flux	Remplacer, supprimer, insérer
cut	Extraire des colonnes	Fichiers délimités (CSV, TSV)
find	Rechercher des fichiers	Trouver par nom, taille, date
xargs	Transformer stdin en arguments	Chaîner commandes sur listes

Glissez pour voir

Quand utiliser grep vs awk ?

Situation	grep	awk
Rechercher un mot dans un fichier	✅ grep "mot" fichier	✅ mais overkill
Ignorer la casse	✅ grep -i "mot"	✅ tolower()
Afficher les lignes contenant un pattern	✅ Parfait	✅
Extraire une colonne spécifique	❌	✅ awk '{print $2}'
Compter les occurrences exactes	❌ -c compte les lignes	✅
Calculs sur les lignes trouvées	❌	✅
Conditions complexes (ET, OU, IF)	⚠️ Limité	✅

Glissez pour voir

Combinaisons fréquentes :

# grep + cut : filtrer puis extraire une colonne
grep 'ERROR' app.log | cut -d' ' -f4

# grep + sort + uniq : compter les types d'erreurs
grep 'ERROR' app.log | cut -d':' -f2 | sort | uniq -c

# grep + xargs : agir sur les fichiers contenant un motif
grep -rl 'TODO' src/ | xargs -I{} echo "Fichier à traiter: {}"

# grep + wc : compter les lignes correspondantes
grep -c 'ERROR' *.log | grep -v ':0$'

Comprendre la commande grep en 2 min

🧠 Modèle mental — Comment fonctionne grep

grep = Définir l'entrée → Spécifier le motif → Obtenir les lignes correspondantes

Points clés

• grep filtre les lignes contenant un motif (texte ou regex)
• Sans fichier, grep lit depuis stdin (pipe)
• Par défaut, la recherche est sensible à la casse
• -i pour ignorer la casse, -v pour inverser (lignes sans le motif)
• -n affiche les numéros de lignes, -c compte les occurrences
• grep -E (ou egrep) active les regex étendues (|, +, ?, etc.)

Règles d'or

1

Toujours protéger le motif avec des guillemets Évite que le shell interprète les caractères spéciaux (*, ?, |, etc.)

2

Utiliser -E pour les regex avec alternance ou quantificateurs grep basique nécessite d'échapper | + ? (), -E les active directement

Vocabulaire essentiel

-i

Ignorer la casse (case-insensitive)

-v

Inverser : lignes SANS le motif

-n

Afficher les numéros de ligne

-c

Compter les lignes (pas les occurrences)

-r

Recherche récursive dans les dossiers

-l

Afficher uniquement les noms de fichiers

📚 Pour aller plus loin — 6 options avancées

-E

Regex étendues (egrep)

-w

Mot entier uniquement

-o

Afficher uniquement la correspondance

-A N

N lignes après chaque match

-B N

N lignes avant chaque match

-C N

N lignes de contexte (avant et après)

grep lit le fichier ou stdin ligne par ligne, teste si le motif est présent, puis affiche les lignes correspondantes sur stdout.

Syntaxe minimale

grep [OPTIONS] MOTIF [FICHIER...]

Les modes de recherche

grep propose plusieurs modes selon le type de motif :

Mode	Commande	Usage	Exemple
Texte simple	grep	Motifs littéraux	grep "ERROR" log.txt
Regex basique (BRE)	grep	Métacaractères basiques	grep "^[0-9]" file
Regex étendue (ERE)	grep -E	|, +, ?, () sans échappement	grep -E "a|b"
Texte littéral	grep -F	Désactive les regex	grep -F "*.txt" file

Glissez pour voir

Les options essentielles

Option	Effet	Exemple
-i	Ignorer la casse	grep -i "error"
-v	Inverser (lignes sans le motif)	grep -v "DEBUG"
-n	Afficher les numéros de ligne	grep -n "ERROR"
-c	Compter les lignes	grep -c "ERROR"
-l	Afficher uniquement les noms de fichiers	grep -l "TODO"
-r	Recherche récursive	grep -r "TODO" src/
-w	Mot entier uniquement	grep -w "port"
-o	Afficher uniquement la correspondance	grep -o "[0-9]*"

Glissez pour voir

Afficher le contexte

Pour comprendre le contexte d’une correspondance (crucial pour le débogage) :

Option	Effet	Exemple
-A N	N lignes après (After)	grep -A 3 "ERROR"
-B N	N lignes avant (Before)	grep -B 2 "ERROR"
-C N	N lignes avant et après (Context)	grep -C 2 "ERROR"

Glissez pour voir

# Voir ce qui s'est passé avant et après une erreur
grep -C 3 "Exception" application.log

# Afficher le contexte après chaque erreur (stack trace)
grep -A 10 "ERROR" app.log

Expressions régulières basiques

Pattern	Signification	Exemple
^motif	Début de ligne	grep "^ERROR"
motif$	Fin de ligne	grep "done$"
.	Un caractère quelconque	grep "err.r"
*	Zéro ou plus du précédent	grep "ab*c"
[abc]	Un parmi a, b ou c	grep "[aeiou]"
[^abc]	Aucun parmi a, b ou c	grep "[^0-9]"
\<mot\>	Mot entier (BRE)	grep "\<port\>"

Glissez pour voir

Expressions régulières étendues (-E)

Avec -E (ou egrep), les métacaractères avancés sont disponibles sans échappement :

Pattern	Signification	Exemple
a|b	a OU b	grep -E "ERROR|WARNING"
+	Un ou plus du précédent	grep -E "[0-9]+"
?	Zéro ou un du précédent	grep -E "colou?r"
(abc)	Groupement	grep -E "(ab)+"
{n,m}	Entre n et m répétitions	grep -E "[0-9]{2,4}"

Glissez pour voir

# Trouver ERROR ou WARNING ou CRITICAL
grep -E "ERROR|WARNING|CRITICAL" app.log

# Trouver les lignes avec un numéro de 2 à 4 chiffres
grep -E "[0-9]{2,4}" data.txt

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

Recherche récursive dans un projet

# Tous les fichiers du dossier courant
grep -r "TODO" .

# Avec numéros de ligne
grep -rn "FIXME" src/

# Uniquement les noms de fichiers
grep -rl "password" /etc/

# Exclure certains dossiers
grep -r "TODO" --exclude-dir={node_modules,.git} .

# Filtrer par extension
grep -r "import" --include="*.py" .

Erreurs typiques (et solutions)

Erreur	Cause	Solution
Aucun résultat	Casse différente	Utiliser -i
Résultats partiels	Correspondance sous-chaîne	Utiliser -w pour mot entier
Regex non reconnue	grep basique	Utiliser -E pour regex étendues
”Binary file matches”	Fichier binaire détecté	Utiliser -a pour forcer texte
grep se trouve lui-même	ps | grep	Ajouter | grep -v grep

Glissez pour voir

Les Modèles de recherche courants

Maintenant que vous comprenez la logique de grep, voici des modèles courants pour des recherches fréquentes.

Ces recettes couvrent les cas d'usage les plus fréquents. Cliquez sur un pattern pour voir la formule complète et un exemple prêt à copier.

Tous Base Inter. Avancé

Recherche simple Base

Trouver les lignes contenant un mot.

grep "ERROR" application.log

Formule grep "MOTIF" <fichier>

Exemple

grep "ERROR" application.log

📋

Paramètres

• MOTIF — Texte ou expression régulière à rechercher

Ignorer la casse Base

Trouver sans distinction majuscules/minuscules.

grep -i "error" logs.txt

Formule grep -i "MOTIF" <fichier>

Exemple

grep -i "error" logs.txt

📋

Paramètres

• -i — Case-insensitive

Exclure un motif Base

Afficher les lignes qui NE contiennent PAS le motif.

grep -v "DEBUG" application.log

Formule grep -v "MOTIF" <fichier>

Exemple

grep -v "DEBUG" application.log

📋

Paramètres

• -v — Inversion : tout sauf le motif

Compter les lignes Base

Compter le nombre de lignes correspondantes.

grep -c "ERROR" application.log

Formule grep -c "MOTIF" <fichier>

Exemple

grep -c "ERROR" application.log

📋

Paramètres

• -c — Retourne uniquement le compte

Avec numéros de lignes Base

Voir à quelles lignes se trouvent les correspondances.

grep -n "ERROR" application.log

Formule grep -n "MOTIF" <fichier>

Exemple

grep -n "ERROR" application.log

📋

Paramètres

• -n — Préfixe chaque ligne par son numéro

Contexte après le match Inter.

Voir N lignes après chaque correspondance.

grep -A 3 "Exception" error.log

Formule grep -A N "MOTIF" <fichier>

Exemple

grep -A 3 "Exception" error.log

📋

Paramètres

• -A N — N lignes après (After)

Contexte avant le match Inter.

Voir N lignes avant chaque correspondance.

grep -B 2 "FAILURE" job.log

Formule grep -B N "MOTIF" <fichier>

Exemple

grep -B 2 "FAILURE" job.log

📋

Paramètres

• -B N — N lignes avant (Before)

Contexte avant et après Inter.

Voir N lignes avant et après chaque correspondance.

grep -C 2 "timeout" network.log

Formule grep -C N "MOTIF" <fichier>

Exemple

grep -C 2 "timeout" network.log

📋

Paramètres

• -C N — N lignes de contexte (Context)

Mot entier uniquement Base

Éviter les correspondances partielles.

grep -w "port" config.conf

Formule grep -w "MOTIF" <fichier>

Exemple

grep -w "port" config.conf

📋

Paramètres

• -w — Mot entier (word boundary)

Recherche récursive Base

Chercher dans tous les fichiers d'un répertoire.

grep -r "TODO" ./src/

Formule grep -r "MOTIF" <dossier>

Exemple

grep -r "TODO" ./src/

📋

Paramètres

• -r — Récursif dans les sous-dossiers

Noms de fichiers uniquement Inter.

Lister les fichiers contenant le motif.

grep -rl "password" /etc/

Formule grep -l "MOTIF" <fichiers>

Exemple

grep -rl "password" /etc/

📋

Paramètres

• -l — Liste uniquement les noms de fichiers

Regex étendues (alternance) Inter.

Chercher plusieurs motifs avec OU.

grep -E "ERROR|WARNING|CRITICAL" app.log

Formule grep -E "MOTIF1|MOTIF2" <fichier>

Exemple

grep -E "ERROR|WARNING|CRITICAL" app.log

📋

Paramètres

• -E — Active les regex étendues
• | — Alternance (OU)

Afficher uniquement le match Avancé

Extraire uniquement la partie correspondante.

grep -oE "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+" access.log

Formule grep -o "PATTERN" <fichier>

Exemple

grep -oE "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+" access.log

📋

Paramètres

• -o — Affiche uniquement la correspondance

Exclure les commentaires Inter.

Ignorer les lignes de commentaires dans les configs.

grep -v "^#" config.conf | grep -v "^$"

Formule grep -v "^#" <fichier> | grep -v "^$"

Exemple

grep -v "^#" config.conf | grep -v "^$"

📋

Paramètres

• ^# — Lignes commençant par #
• ^$ — Lignes vides

Pipeline de filtrage Base

Filtrer la sortie d'une autre commande.

ps aux | grep nginx

Formule <commande> | grep "MOTIF"

Exemple

ps aux | grep nginx

📋

Paramètres

• pipe — grep filtre la sortie d'une commande

Recherche multi-fichiers Base

Chercher dans plusieurs fichiers à la fois.

grep "server" *.conf

Formule grep "MOTIF" <fichier1> <fichier2> ...

Exemple

grep "server" *.conf

📋

Paramètres

• * — Joker shell pour plusieurs fichiers

Les Pièges à éviter

Ces erreurs courantes peuvent faire perdre du temps ou causer des dégâts. Les pièges les plus critiques sont affichés en premier.

Motif sans guillemets

grep *.log fichier.txt (le * est interprété par le shell)

Attention

Le piège : grep *.log fichier.txt (le * est interprété par le shell)

Symptôme : Erreur ou résultats inattendus

Cause : Le shell interprète les caractères spéciaux avant grep

Correction : Toujours mettre le motif entre guillemets

grep "*.log" fichier.txt

Regex basique vs étendue

grep "ERROR|WARNING" ne fonctionne pas

Attention

Le piège : grep "ERROR|WARNING" ne fonctionne pas

Symptôme : Aucun résultat (cherche littéralement "ERROR|WARNING")

Cause : grep basique nécessite d'échapper le | ou d'utiliser -E

Correction : Utiliser grep -E pour les regex étendues

grep -E "ERROR|WARNING" fichier.log

Caractères spéciaux non échappés

grep "prix: 10$" cherche "10" en fin de ligne

Attention

Le piège : grep "prix: 10$" cherche "10" en fin de ligne

Symptôme : Résultats inattendus

Cause : $ est un métacaractère regex (fin de ligne)

Correction : Échapper les caractères spéciaux ou utiliser -F

grep -F "prix: 10$" fichier.txt

Correspondance partielle indésirable

grep "port" trouve aussi "import", "export", "support"

Attention

Le piège : grep "port" trouve aussi "import", "export", "support"

Symptôme : Trop de résultats non pertinents

Cause : grep cherche la sous-chaîne, pas le mot entier

Correction : Utiliser -w pour chercher le mot entier

grep -w "port" config.conf

Oubli de -i pour la casse

grep "error" fichier.log ne trouve pas "ERROR"

Info

Le piège : grep "error" fichier.log ne trouve pas "ERROR"

Symptôme : Lignes manquantes dans les résultats

Cause : Par défaut, grep est sensible à la casse

Correction : Utiliser -i pour ignorer la casse

grep -i "error" fichier.log

grep se trouve lui-même

ps aux | grep nginx affiche aussi la ligne "grep nginx"

Info

Le piège : ps aux | grep nginx affiche aussi la ligne "grep nginx"

Symptôme : Une ligne parasite avec "grep" dans les résultats

Cause : Le processus grep apparaît dans la liste ps

Correction : Ajouter | grep -v grep ou utiliser [n]ginx

ps aux | grep nginx | grep -v grep

-c compte les lignes, pas les occurrences

grep -c "mot" compte 2 même si "mot" apparaît 5 fois sur 2 lignes

Info

Le piège : grep -c "mot" compte 2 même si "mot" apparaît 5 fois sur 2 lignes

Symptôme : Compte inférieur au nombre réel d'occurrences

Cause : -c compte les lignes contenant le motif, pas le nombre total

Correction : Pour compter les occurrences : grep -o | wc -l

grep -o "mot" fichier.txt | wc -l

Fichiers binaires ignorés

grep dans un fichier binaire affiche "Binary file matches"

Info

Le piège : grep dans un fichier binaire affiche "Binary file matches"

Symptôme : Message au lieu du contenu

Cause : grep détecte le binaire et n'affiche pas le contenu

Correction : Utiliser -a pour forcer le traitement comme texte

grep -a "motif" fichier.bin

Cheatsheet

📋 Cheatsheet grep

Imprimer

📝 Syntaxe :

grep "motif" fichier Recherche simple

🚀 Commandes types :

Recherche simple Trouver les lignes contenant un mot.

grep "ERROR" application.log

Ignorer la casse Trouver sans distinction majuscules/minuscules.

grep -i "error" logs.txt

Exclure un motif Afficher les lignes qui NE contiennent PAS le motif.

grep -v "DEBUG" application.log

Compter les lignes Compter le nombre de lignes correspondantes.

grep -c "ERROR" application.log

Avec numéros de lignes Voir à quelles lignes se trouvent les correspondances.

grep -n "ERROR" application.log

⚙️ Options

grep -i	Ignorer la casse	grep -i "error" log.txt
grep -v	Inverser (exclure)	grep -v "DEBUG" log.txt
grep -n	Numéros de lignes	grep -n "ERROR" log.txt
grep -c	Compter les lignes	grep -c "ERROR" log.txt
grep -w	Mot entier	grep -w "port" config
grep -l	Noms de fichiers uniquement	grep -rl "TODO" .
grep -r	Recherche récursive	grep -r "TODO" src/
grep -o	Afficher uniquement le match	grep -o "IP: [0-9.]*"
grep -A N	N lignes après	grep -A 3 "ERROR"
grep -B N	N lignes avant	grep -B 2 "ERROR"
grep -C N	N lignes contexte	grep -C 2 "ERROR"
grep -E	Regex étendues	grep -E "a|b"
grep -F	Texte littéral (pas regex)	grep -F "*.txt"

Contrôle de connaissances

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

10 questions

5 min.

80% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

Conclusion

La commande grep est l’outil de recherche textuelle le plus utilisé sous Linux. Sa syntaxe simple (grep "motif" fichier) couvre 80% des besoins quotidiens. Les options -i (casse), -v (inverser), -n (numéros), -r (récursif) et -E (regex étendues) permettent de couvrir les cas avancés. Pour du traitement plus complexe (extraction de colonnes, calculs), combinez grep avec awk ou cut.

Articles qui pourraient vous intéresser

• Maîtriser awk pour le traitement de données
• Maîtriser sed pour l’édition de texte
• Maîtriser cut pour l’extraction de colonnes
• Maîtriser find pour la recherche de fichiers

×

📖 Voir la documentation →