grep : rechercher dans du texte

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	Oui, grep "mot" fichier	Oui, mais overkill
Ignorer la casse	Oui, grep -i "mot"	Oui, tolower()
Afficher les lignes contenant un pattern	Oui, Parfait	Oui
Extraire une colonne spécifique	Non	Oui, awk '{print $2}'
Compter les occurrences exactes	Non, -c compte les lignes	Oui
Calculs sur les lignes trouvées	Non	Oui
Conditions complexes (ET, OU, IF)	Attention : Limité	Oui

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

L'ordre des trois éléments n'est pas négociable : les options viennent avant le motif, et le motif avant les fichiers. Si vous inversez motif et fichier, grep cherchera le nom du fichier à l'intérieur du motif traité comme un chemin, et vous obtiendrez une erreur No such file or directory déroutante. Quand [FICHIER...] est absent, grep lit son entrée standard, ce qui est exactement le comportement recherché dans un pipeline.

grep [OPTIONS] MOTIF [FICHIER...]

Les modes de recherche

grep propose plusieurs modes selon le type de motif. Le choix se fait sur une seule question : votre motif contient-il des caractères qui ont un sens spécial en regex ? Si oui et que vous les voulez littéraux, -F est la réponse la plus sûre. Si vous voulez au contraire exploiter l'alternance ou les quantificateurs, -E vous évite d'échapper la moitié du 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

Ces huit options couvrent la quasi-totalité des usages quotidiens. Elles se combinent librement : grep -rin "timeout" /var/log/ cumule la récursivité, la casse ignorée et les numéros de ligne. Deux d'entre elles modifient la nature de la sortie plutôt que la sélection : -c renvoie un nombre, -l renvoie des chemins. Ce sont celles qu'on chaîne dans un script, parce que leur sortie se consomme facilement par une autre commande.

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

Une ligne d'erreur isolée dit rarement ce qui s'est passé. Ces trois options ramènent les lignes voisines et transforment un message brut en séquence lisible. Un détail à connaître : quand deux correspondances sont proches, grep insère une ligne -- entre les blocs de contexte pour marquer la coupure. Cette ligne parasite les traitements en aval, supprimez-la avec --no-group-separator si vous chaînez la sortie.

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

Ces motifs appartiennent au dialecte BRE (Basic Regular Expression), celui que grep utilise sans option. Deux comportements y surprennent : * ne signifie pas « n'importe quoi » comme dans le shell, mais « zéro ou plusieurs fois le caractère précédent » ; et les frontières de mot s'écrivent \< et \>, avec des barres obliques inverses, alors que la plupart des autres options avancées exigent l'inverse. Retenez les deux ancres ^ et $ en priorité, ce sont elles qui éliminent le plus de faux positifs.

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, vous passez en ERE (Extended Regular Expression) et les métacaractères avancés deviennent 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

La commande egrep est obsolescente

Vous croiserez encore egrep "ERROR|WARNING" dans de vieux scripts. Depuis GNU grep 3.8, egrep et fgrep sont déclarés obsolescents : ils affichent un avertissement invitant à les remplacer par grep -E et grep -F, et ont vocation à disparaître. Sur Debian et Ubuntu, /usr/bin/egrep est un simple script de deux lignes qui appelle grep -E, donc sans avertissement : vos scripts fonctionnent, mais ils ne sont pas portables.

Recherche récursive dans un projet

La récursivité est le mode où grep peut devenir lent et bruyant. Deux options règlent presque tout : --exclude-dir pour ignorer les dossiers de dépendances et l'historique Git, --include pour ne cibler qu'un type de fichier. Sans elles, une recherche à la racine d'un projet Node parcourt node_modules et noie le résultat utile. Notez aussi que -r suit les liens symboliques indiqués en argument mais pas ceux rencontrés en chemin ; utilisez -R si vous voulez les suivre tous.

# 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)

Toutes ces situations ont la même signature : grep ne plante pas, il renvoie simplement un résultat qui ne correspond pas à votre attente. C'est ce qui les rend coûteuses, puisque rien ne signale l'erreur. Le réflexe qui les évite presque toutes est de tester le motif sur une seule ligne connue avant de le lancer sur un fichier entier.

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 seize modèles prêts à l'emploi. Chacun donne sa formule générale et un exemple concret.

Recherche simple

Trouver les lignes contenant un mot. La sortie affiche la ligne entière, pas seulement la portion qui correspond ; le code de retour vaut 0 si au moins une ligne correspond, 1 sinon, ce qui rend cette forme utilisable telle quelle dans un test de script.

grep "MOTIF" <fichier>             # formule
grep "ERROR" application.log       # exemple

• MOTIF : texte ou expression régulière à rechercher

Ignorer la casse

Trouver sans distinction majuscules / minuscules. C'est l'option à dégainer en premier quand une recherche ne renvoie rien alors que vous êtes certain du contenu : les niveaux de log s'écrivent ERROR chez les uns, Error chez les autres.

grep -i "MOTIF" <fichier>     # formule
grep -i "error" logs.txt     # exemple

• -i : recherche insensible à la casse

Exclure un motif

Afficher les lignes qui ne contiennent pas le motif.

grep -v "MOTIF" <fichier>            # formule
grep -v "DEBUG" application.log      # exemple

• -v : inverse la sélection

Compter les lignes

Compter le nombre de lignes correspondantes. Attention au sens exact : -c compte les lignes, pas les occurrences. Une ligne qui contient trois fois le motif ne compte que pour un.

grep -c "MOTIF" <fichier>            # formule
grep -c "ERROR" application.log      # exemple

• -c : renvoie uniquement le compte, pas les lignes

Avec numéros de lignes

Voir à quelles lignes se trouvent les correspondances.

grep -n "MOTIF" <fichier>            # formule
grep -n "ERROR" application.log      # exemple

• -n : préfixe chaque ligne par son numéro

Contexte après le match

Voir N lignes après chaque correspondance. C'est la forme adaptée aux traces d'exception, où le message d'erreur tient sur une ligne mais la pile d'appel se déroule sur les suivantes.

grep -A N "MOTIF" <fichier>          # formule
grep -A 3 "Exception" error.log      # exemple

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

Contexte avant le match

Voir N lignes avant chaque correspondance. Utile dans le cas inverse : comprendre ce que le service tentait de faire juste avant l'échec, information qui manque toujours dans la ligne d'erreur elle-même.

grep -B N "MOTIF" <fichier>        # formule
grep -B 2 "FAILURE" job.log        # exemple

• -B N : N lignes avant (Before)

Contexte avant et après

Voir N lignes de part et d'autre de chaque correspondance.

grep -C N "MOTIF" <fichier>          # formule
grep -C 2 "timeout" network.log      # exemple

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

Mot entier uniquement

Éviter les correspondances partielles. Sans cette option, chercher port dans une configuration remonte aussi import, export et support, ce qui noie le résultat utile sous des lignes sans rapport.

grep -w "MOTIF" <fichier>        # formule
grep -w "port" config.conf       # exemple

• -w : impose une frontière de mot

Recherche récursive

Chercher dans tous les fichiers d'un répertoire. Sur un projet réel, ajoutez systématiquement --exclude-dir : sans elle, grep descend dans .git et dans les dossiers de dépendances, et la recherche devient à la fois lente et illisible.

grep -r "MOTIF" <dossier>      # formule
grep -r "TODO" ./src/          # exemple

• -r : descend dans les sous-dossiers

Noms de fichiers uniquement

Lister les fichiers contenant le motif, sans afficher les lignes.

grep -l "MOTIF" <fichiers>        # formule
grep -rl "password" /etc/         # exemple

• -l : n'affiche que les chemins de fichiers

Regex étendues (alternance)

Chercher plusieurs motifs avec un OU. Sans -E, la barre verticale est prise au pied de la lettre et grep cherche la chaîne littérale ERROR|WARNING, qui n'existe nulle part : vous obtenez zéro résultat sans le moindre message d'erreur.

grep -E "MOTIF1|MOTIF2" <fichier>            # formule
grep -E "ERROR|WARNING|CRITICAL" app.log     # exemple

• -E : active les regex étendues
• | : alternance (OU)

Afficher uniquement le match

Extraire uniquement la partie correspondante, pas la ligne entière.

grep -o "PATTERN" <fichier>                              # formule
grep -oE "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+" access.log     # exemple

• -o : affiche uniquement la correspondance

Exclure les commentaires

Ignorer les lignes de commentaires et les lignes vides d'un fichier de configuration.

grep -v "^#" <fichier> | grep -v "^$"          # formule
grep -v "^#" config.conf | grep -v "^$"        # exemple

• ^# : lignes commençant par #
• ^$ : lignes vides

Pipeline de filtrage

Filtrer la sortie d'une autre commande. C'est l'usage le plus courant en administration. Retenez que grep ne voit ici que la sortie standard : les messages d'erreur passent à côté du filtre tant que vous n'ajoutez pas 2>&1.

<commande> | grep "MOTIF"      # formule
ps aux | grep nginx            # exemple

• grep filtre ce qui arrive sur son entrée standard

Recherche multi-fichiers

Chercher dans plusieurs fichiers à la fois. Dès qu'il y a plus d'un fichier, grep préfixe chaque ligne du nom du fichier. C'est ce préfixe qui permet ensuite de trier ou de compter par fichier, mais il casse les traitements qui attendaient la ligne brute.

grep "MOTIF" <fichier1> <fichier2> ...      # formule
grep "server" *.conf                        # exemple

• * : joker shell pour cibler plusieurs fichiers

Les pièges à éviter

Huit erreurs reviennent constamment avec grep. Pour chacune : la commande piégée, le symptôme, la cause et la correction.

Motif sans guillemets

grep *.log fichier.txt   # INCORRECT : le shell interprète le * avant grep

Symptôme : erreur ou résultats inattendus. Cause : le shell interprète les caractères spéciaux (*, ?, |) avant que grep ne les voie.

grep "*.log" fichier.txt   # CORRECT : le motif est protégé

Oubli de -i pour la casse

grep "error" fichier.log   # INCORRECT : ne trouve pas "ERROR" ni "Error"

Symptôme : des lignes manquent dans les résultats. Cause : par défaut, grep est sensible à la casse.

grep -i "error" fichier.log   # CORRECT : casse ignorée

grep se trouve lui-même

ps aux | grep nginx   # INCORRECT : affiche aussi la ligne du processus "grep nginx"

Symptôme : une ligne parasite contenant grep dans les résultats. Cause : le processus grep apparaît lui-même dans la liste de ps.

ps aux | grep nginx | grep -v grep   # CORRECT : on exclut la ligne du grep

Regex basique contre étendue

grep "ERROR|WARNING" fichier.log   # INCORRECT : cherche le texte littéral "ERROR|WARNING"

Symptôme : aucun résultat. Cause : en regex basique, le | n'est pas l'alternance, il faut l'échapper ou utiliser -E.

grep -E "ERROR|WARNING" fichier.log   # CORRECT : regex étendue

Caractères spéciaux non échappés

grep "prix: 10$" fichier.txt   # INCORRECT : le $ est interprété comme « fin de ligne »

Symptôme : résultats inattendus. Cause : $ est un métacaractère de regex.

grep -F "prix: 10$" fichier.txt   # CORRECT : -F traite le motif comme du texte littéral

-c compte les lignes, pas les occurrences

grep -c "mot" fichier.txt   # INCORRECT : renvoie 2 même si "mot" apparaît 5 fois sur 2 lignes

Symptôme : un compte inférieur au nombre réel d'occurrences. Cause : -c compte les lignes contenant le motif, pas le nombre total de correspondances.

grep -o "mot" fichier.txt | wc -l   # CORRECT : compte les occurrences réelles

Fichiers binaires ignorés

grep "motif" fichier.bin   # INCORRECT : affiche "Binary file matches" au lieu du contenu

Symptôme : un message au lieu du résultat. Cause : grep détecte un fichier binaire et n'en affiche pas le contenu.

grep -a "motif" fichier.bin   # CORRECT : -a force le traitement comme du texte

Correspondance partielle indésirable

grep "port" config.conf   # INCORRECT : trouve aussi "import", "export", "support"

Symptôme : trop de résultats non pertinents. Cause : grep cherche la sous-chaîne, pas le mot entier.

grep -w "port" config.conf   # CORRECT : -w impose le mot entier

Travaux pratiques

Rien ne remplace la pratique. Créez l'environnement de test ci-dessous, puis déroulez les douze étapes. À la fin, nettoyez avec rm -rf ~/grep-lab.

Préparer le terrain

Ce script crée quatre fichiers de test dans ~/grep-lab : un log applicatif, un fichier de configuration, du code source Python et une liste de contacts.

# Créer le lab
mkdir -p ~/grep-lab
cd ~/grep-lab

# Fichier de log applicatif
cat > application.log << 'EOF'
2025-01-15 08:00:01 INFO  Application démarrée
2025-01-15 08:00:02 DEBUG Connexion base de données établie
2025-01-15 08:01:15 INFO  Utilisateur alice connecté
2025-01-15 08:02:30 WARNING Mémoire utilisée: 75%
2025-01-15 08:03:45 ERROR Timeout lors de la requête API
2025-01-15 08:03:46 DEBUG Retry 1/3 en cours...
2025-01-15 08:03:48 ERROR Timeout lors de la requête API
2025-01-15 08:03:49 DEBUG Retry 2/3 en cours...
2025-01-15 08:03:51 INFO  Requête réussie après retry
2025-01-15 08:05:00 INFO  Utilisateur bob connecté
2025-01-15 08:10:00 WARNING Disque utilisé: 85%
2025-01-15 08:15:00 ERROR Permission denied: /var/data/secret.txt
2025-01-15 08:20:00 INFO  Batch job terminé avec succès
EOF

# Fichier de configuration
cat > config.conf << 'EOF'
# Configuration serveur
server.host=localhost
server.port=8080
server.ssl.enabled=true
# Base de données
database.host=db.example.com
database.port=5432
database.name=production
database.user=admin
# Cache
cache.enabled=true
cache.ttl=3600
# Logging
log.level=INFO
log.file=/var/log/app.log
EOF

# Code source Python
cat > app.py << 'EOF'
#!/usr/bin/env python3
"""Application principale"""
import os
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def connect_database(host, port):
    logger.info(f"Connexion à {host}:{port}")
    # TODO: implémenter la connexion réelle
    return True

def process_data(data):
    # FIXME: gérer les erreurs
    if not data:
        raise ValueError("Data is empty")
    return data.upper()

if __name__ == "__main__":
    connect_database("localhost", 5432)
    # TODO: ajouter la logique métier
EOF

# Fichier avec adresses email
cat > contacts.txt << 'EOF'
alice@example.com - Alice Martin
bob.smith@company.org - Bob Smith
charlie@test.co.uk - Charlie Brown
invalid-email - Non valide
ADMIN@EXAMPLE.COM - Administrateur
support@help-desk.net - Support technique
EOF

echo "Correct : Lab créé dans ~/grep-lab"
ls -la ~/grep-lab

Les douze étapes

Déroulez-les dans l'ordre : chaque étape réutilise une notion de la précédente, et les quatre dernières combinent plusieurs options. Après chaque commande, comparez ce que vous obtenez à la ligne d'explication : si le nombre de lignes affichées diffère, c'est presque toujours le motif qui est en cause, pas la commande. Les fichiers du lab sont volontairement courts pour que vous puissiez vérifier le résultat à l'oeil.

1. Recherche simple. Trouvez toutes les lignes contenant ERROR dans application.log.

   grep "ERROR" ~/grep-lab/application.log

   grep affiche toutes les lignes contenant le motif, ici, trois lignes.

2. Ignorer la casse. Trouvez toutes les variantes de error, quelle que soit la casse.

   grep -i "error" ~/grep-lab/application.log

   -i rend la recherche insensible à la casse.

3. Numéros de lignes. Affichez les erreurs avec leur numéro de ligne.

   grep -n "ERROR" ~/grep-lab/application.log

   -n préfixe chaque résultat par son numéro de ligne dans le fichier.

4. Inverser la recherche. Affichez toutes les lignes sauf celles contenant DEBUG.

   grep -v "DEBUG" ~/grep-lab/application.log

   -v inverse le filtre : il garde les lignes qui ne correspondent pas.

5. Compter les occurrences. Comptez le nombre de lignes contenant INFO.

   grep -c "INFO" ~/grep-lab/application.log

   -c renvoie le nombre de lignes correspondantes, pas les lignes elles-mêmes.

6. Contexte après. Affichez chaque ERROR suivi des 2 lignes qui suivent.

   grep -A 2 "ERROR" ~/grep-lab/application.log

   -A N ajoute N lignes de contexte après chaque correspondance. Pour du contexte avant et après : grep -C 1 "ERROR" ~/grep-lab/application.log.

7. Mot entier. Trouvez INFO sans capturer un éventuel INFORMATION.

   grep -w "INFO" ~/grep-lab/application.log

   -w impose une frontière de mot autour du motif.

8. Expressions régulières basiques. Trouvez les lignes commençant par une date (2025-).

   grep "^2025-" ~/grep-lab/application.log

   ^ représente le début de ligne en regex.

9. Regex étendues avec alternance. Trouvez les lignes contenant ERROR ou WARNING.

   grep -E "ERROR|WARNING" ~/grep-lab/application.log

   -E active les regex étendues, où | signifie « ou ».

10. Exclure les commentaires. Affichez les lignes de config.conf qui ne sont pas des commentaires.

    grep -v "^#" ~/grep-lab/config.conf

    ^# cible les lignes commençant par # ; -v les exclut.

11. Pipeline avec grep. Listez les processus Python en cours.

    ps aux | grep python | grep -v grep

    grep filtre la sortie de ps ; le second grep -v grep retire la ligne du grep lui-même.

12. Recherche récursive. Trouvez tous les TODO dans les fichiers du lab.

    grep -r "TODO" ~/grep-lab/

    -r parcourt récursivement tous les fichiers du dossier, les TODO sont dans app.py.

Exercices progressifs

Dix exercices pour valider votre maîtrise. Tous se traitent sur les fichiers du lab ~/grep-lab. Cherchez d'abord par vous-même, puis dépliez la solution pour vous corriger.

Niveau fondations

Ces quatre exercices ne mobilisent qu'une seule option à la fois. Traitez-les sans consulter les tableaux plus haut : l'objectif est de mémoriser la lettre associée à chaque effet, -i, -v et -c, parce que ce sont celles que vous taperez le plus souvent en production.

Exercice 1, Trouver les erreurs. Affichez toutes les lignes contenant ERROR dans application.log. Indice : syntaxe simple grep "motif" fichier.

Voir la solution

grep "ERROR" ~/grep-lab/application.log

grep affiche les lignes contenant le motif spécifié.

Exercice 2, Ignorer la casse. Trouvez toutes les variantes de warning (warning, WARNING, Warning…). Indice : -i pour insensible à la casse.

Voir la solution

grep -i "warning" ~/grep-lab/application.log

-i rend la recherche insensible à la casse.

Exercice 3, Lignes sans DEBUG. Affichez toutes les lignes sauf celles contenant DEBUG. Indice : -v inverse la sélection.

Voir la solution

grep -v "DEBUG" ~/grep-lab/application.log

-v affiche les lignes qui ne correspondent pas au motif.

Exercice 4, Compter les erreurs. Comptez le nombre de lignes contenant ERROR. Indice : -c pour count.

Voir la solution

grep -c "ERROR" ~/grep-lab/application.log

-c renvoie uniquement le nombre de lignes correspondantes.

Niveau composition

On monte d'un cran : ces cinq exercices demandent de choisir la bonne option parmi plusieurs candidates plausibles. L'exercice 6 est le plus instructif, puisque la version naïve sans -w renvoie un résultat, mais le mauvais. Un résultat non vide n'est jamais une preuve que le motif était correct.

Exercice 5, Contexte d'erreur. Affichez chaque ligne ERROR avec les 2 lignes suivantes. Indice : -A pour after.

Voir la solution

grep -A 2 "ERROR" ~/grep-lab/application.log

-A N affiche N lignes après chaque correspondance.

Exercice 6, Mot entier. Trouvez port dans config.conf sans capturer import ou export. Indice : -w pour word.

Voir la solution

grep -w "port" ~/grep-lab/config.conf

-w garantit que le motif est un mot entier, pas une sous-chaîne.

Exercice 7, Regex avec alternance. Trouvez les lignes contenant ERROR ou WARNING. Indice : -E pour les regex étendues, | pour le OU.

Voir la solution

grep -E "ERROR|WARNING" ~/grep-lab/application.log

-E active les regex étendues, où | signifie « ou ».

Exercice 8, Exclure les commentaires. Affichez les lignes de config.conf sans les commentaires (#). Indice : ^# cible le début de ligne, -v inverse.

Voir la solution

grep -v "^#" ~/grep-lab/config.conf

^# cible les lignes commençant par # ; -v les exclut.

Exercice 9, Recherche récursive. Trouvez tous les TODO dans les fichiers du lab. Indice : -r pour récursif.

Voir la solution

grep -r "TODO" ~/grep-lab/

-r parcourt récursivement tous les sous-dossiers.

Niveau industrialisation

Dernier exercice, et le seul qui ne porte pas sur un fichier mais sur la sortie d'une autre commande. C'est le cas d'usage le plus fréquent de grep en administration, et celui où le piège de l'auto-correspondance se déclenche systématiquement : le processus grep que vous venez de lancer figure lui-même dans la liste renvoyée par ps.

Exercice 10, Filtrer un processus. Listez les processus contenant ssh sans afficher la ligne du grep lui-même. Indice : un second grep -v grep.

Voir la solution

ps aux | grep ssh | grep -v grep

Le second grep -v grep exclut la ligne du processus grep de la sortie.

Dépannage

Quand grep ne renvoie pas ce qu'on attend, le problème vient presque toujours du motif (casse, regex, échappement). Voici comment diagnostiquer.

Méthodes de diagnostic

La démarche consiste à réduire le problème : au lieu de chercher pourquoi le motif échoue sur un fichier de dix mille lignes, testez-le sur une ligne que vous fabriquez avec echo. Si le motif fonctionne là et pas sur le fichier, le motif est bon et c'est le contenu qui diffère de ce que vous imaginez : espaces insécables, retours chariot Windows, caractères invisibles. C'est ce que cat -A révèle, en affichant ^M$ en fin de ligne pour un fichier au format DOS.

# Tester le motif sur une ligne simple
echo "test ERROR test" | grep "ERROR"

# Afficher les caractères non imprimables du fichier
cat -A fichier.log | head

# Valider une expression régulière isolément
echo "test123" | grep -E "[0-9]+"

# Voir combien de lignes correspondent avant de filtrer
grep -c "MOTIF" fichier.log

Erreurs fréquentes

Contrairement aux pièges précédents, ces trois cas produisent un message explicite sur la sortie d'erreur. C'est une bonne nouvelle : la cause est identifiée par grep lui-même. Lisez toujours le message en entier, il contient le chemin ou la portion de motif fautive, ce qui vous évite de chercher au mauvais endroit.

Message d'erreur	Cause probable	Solution
grep: <fichier>: No such file or directory	Fichier inexistant ou mauvais chemin	Vérifier avec ls, contrôler chemin relatif/absolu
grep: Invalid regular expression	Syntaxe regex incorrecte (parenthèse/crochet non fermé)	Corriger la regex, ou -F pour une recherche littérale
Binary file <fichier> matches	Le fichier est détecté comme binaire	Forcer le mode texte avec grep -a

Glissez pour voir

Aide-mémoire grep

Les deux tableaux ci-dessous condensent tout le guide sur un écran. Le premier regroupe les options de la commande, le second les métacaractères du motif. La distinction compte : une option se place avant le motif et modifie le comportement de grep, un métacaractère vit à l'intérieur du motif et doit être protégé par des guillemets pour que le shell n'y touche pas.

Syntaxe et options

Prenez ce tableau comme une liste de départ, pas comme une référence complète. Les quatre premières lignes couvrent l'essentiel du quotidien ; les options de contexte -A, -B et -C deviennent indispensables dès qu'on lit des traces d'erreur, où la ligne du message ne suffit jamais à comprendre l'enchaînement.

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

Glissez pour voir

Expressions régulières

Une seule ligne de ce tableau dépend d'une option : l'alternance a|b n'a de sens qu'avec -E. Toutes les autres fonctionnent en BRE, donc sans option. Si vous ne deviez retenir que deux entrées, prenez les ancres ^ et $ : ce sont elles qui transforment une recherche approximative en filtre précis, par exemple pour ne garder que les lignes de commentaire d'un fichier de configuration.

Motif	Rôle	Exemple
^motif	Début de ligne	grep "^#" config
motif$	Fin de ligne	grep "done$" log
.	Un caractère quelconque	grep "err.r"
*	Zéro occurrence ou plus du précédent	grep "ab*c"
[abc]	Un caractère parmi la liste	grep "[aeiou]"
[^abc]	Tout sauf ces caractères	grep "[^0-9]"
a|b	a OU b (avec -E)	grep -E "cat|dog"
\<mot\>	Mot entier (regex basique)	grep "\<port\>"

Glissez pour voir

Checklist de maîtrise

Vous maîtrisez grep lorsque vous pouvez cocher chacun de ces points :

• Je sais faire une recherche simple avec grep
• Je sais ignorer la casse avec -i
• Je sais inverser la recherche avec -v
• Je sais compter les lignes avec -c
• Je sais afficher le contexte avec -A, -B, -C
• Je sais chercher un mot entier avec -w
• Je sais utiliser les regex étendues avec -E
• Je sais faire une recherche récursive avec -r
• Je sais combiner grep dans un pipeline

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

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% 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

×

📖 Voir la documentation →