Technique

La commande grep sous Linux : le guide complet avec exemples

4 juillet 2026 · par Romain RICHER

grep est l’outil de recherche de texte par excellence sous Unix/Linux. Son rôle : parcourir un ou plusieurs fichiers (ou un flux de données) et afficher les lignes qui contiennent un motif donné. Que vous cherchiez une erreur dans un fichier de log, une fonction dans du code, ou une valeur dans un gros fichier de données, grep est presque toujours la réponse.

Son nom vient de Global Regular Expression Print, ce qui résume bien son fonctionnement : chercher un motif (éventuellement une expression régulière) et afficher les lignes correspondantes. Ce guide couvre grep de façon progressive : la recherche de base, les options les plus utiles au quotidien, les expressions régulières, les combinaisons avec find et les pipes, ainsi que les pièges classiques. Tous les exemples sont neutres et réutilisables tels quels.

La syntaxe de base

La structure d’une commande grep est simple :

grep "motif" fichier

grep affiche alors chaque ligne du fichier qui contient le motif. Par exemple, pour trouver toutes les lignes contenant « erreur » dans un fichier de log :

grep "erreur" journal.log

On entoure le motif de guillemets par précaution : cela évite que le shell n’interprète d’éventuels caractères spéciaux, et c’est indispensable dès que le motif contient un espace.

grep peut aussi lire depuis un tube (pipe), ce qui est extrêmement courant pour filtrer la sortie d’une autre commande :

cat journal.log | grep "erreur"

Ignorer la casse

Par défaut, grep distingue majuscules et minuscules : « Erreur » et « erreur » sont considérés comme différents. L’option -i (pour ignore case) supprime cette distinction :

grep -i "erreur" journal.log

Cette commande trouve « erreur », « Erreur », « ERREUR » et toutes les variantes. C’est l’une des options les plus utilisées.

Rechercher de façon récursive

Pour chercher dans tous les fichiers d’un dossier et de ses sous-dossiers, l’option -r (pour recursive) est indispensable. Elle évite d’avoir à lister les fichiers un par un.

grep -r "motif" /chemin/du/dossier

grep affiche alors, pour chaque correspondance, le nom du fichier suivi de la ligne trouvée. C’est la manière classique de retrouver où une chaîne apparaît dans une arborescence de code ou de configuration.

Une variante, -R, suit en plus les liens symboliques, ce qui est utile dans certaines arborescences.

Afficher le numéro des lignes

L’option -n (pour number) ajoute le numéro de chaque ligne trouvée. Indispensable pour localiser précisément une occurrence, surtout dans un gros fichier :

grep -n "motif" fichier.txt

Combinée à la recherche récursive, elle donne le fichier et le numéro de ligne — parfait pour aller droit au but :

grep -rn "motif" /chemin/du/dossier

Compter les occurrences

Parfois, on ne veut pas voir les lignes mais simplement savoir combien il y en a. L’option -c (pour count) renvoie le nombre de lignes correspondantes :

grep -c "erreur" journal.log

Attention à une subtilité : -c compte le nombre de lignes contenant le motif, pas le nombre total d’occurrences (une ligne avec deux fois le mot ne compte que pour une).

N’afficher que les noms de fichiers

Lorsqu’on cherche dans de nombreux fichiers, on veut souvent juste savoir lesquels contiennent le motif, sans afficher les lignes. L’option -l (pour files with matches) ne renvoie que les noms de fichiers :

grep -rl "motif" /chemin/du/dossier

À l’inverse, -L affiche les fichiers qui ne contiennent pas le motif — pratique pour repérer, par exemple, les fichiers auxquels il manque une déclaration.

Inverser la recherche

L’option -v (pour invert) affiche toutes les lignes qui ne contiennent pas le motif. Très utile pour filtrer du bruit. Par exemple, afficher toutes les lignes d’un fichier sauf les commentaires (lignes commençant par #) :

grep -v "^#" fichier.conf

On peut enchaîner les filtres. Pour lister les processus liés à un service tout en excluant la ligne du grep lui-même :

ps aux | grep "service" | grep -v "grep"

Rechercher un mot entier

Par défaut, grep trouve le motif même à l’intérieur d’un autre mot : chercher « log » remonte aussi « catalogue » et « logique ». L’option -w (pour word) impose de ne trouver que le mot entier :

grep -w "log" fichier.txt

Ici, seules les occurrences de « log » isolé sont retenues.

Afficher le contexte autour des correspondances

Quand une ligne trouvée n’a de sens qu’avec ce qui l’entoure (typiquement dans un log), trois options affichent le contexte :

-A n (after) : n lignes après la correspondance ;
-B n (before) : n lignes avant ;
-C n (context) : n lignes avant et après.

Pour voir une erreur avec les trois lignes qui la suivent :

grep -A 3 "erreur fatale" journal.log

Pour voir deux lignes de part et d’autre de chaque correspondance :

grep -C 2 "timeout" journal.log

C’est un réflexe précieux pour comprendre le contexte d’un problème dans un fichier volumineux.

Utiliser les expressions régulières

grep ne se limite pas à chercher un texte fixe : il interprète des expressions régulières, qui décrivent des motifs. Quelques symboles de base :

^ : début de ligne ;
$ : fin de ligne ;
. : n’importe quel caractère ;
* : zéro ou plusieurs fois le caractère précédent.

Pour trouver les lignes qui commencent par « Attention » :

grep "^Attention" fichier.txt

Pour trouver les lignes qui finissent par un point-virgule :

grep ";$" fichier.txt

Pour les expressions régulières étendues (avec +, ?, les alternatives | et les groupes), l’option -E active le mode étendu. Par exemple, trouver « erreur » ou « alerte » en une seule commande :

grep -E "erreur|alerte" journal.log

Sans -E, il faudrait échapper la barre verticale, ce qui est moins lisible.

Rechercher un texte fixe avec -F

Paradoxalement, on veut parfois que grep n’interprète pas les caractères spéciaux et cherche le texte exactement tel quel. L’option -F (pour fixed strings) traite le motif comme une chaîne littérale. C’est utile quand le motif contient des points, des parenthèses ou d’autres caractères qui seraient sinon interprétés :

grep -F "192.168.1.1" fichier.txt

Ici, les points sont traités comme de vrais points et non comme « n’importe quel caractère ».

Pièges et erreurs fréquentes

Quelques écueils classiques avec grep :

Oublier les guillemets. Sans guillemets, un motif contenant un espace ou un caractère spécial sera mal interprété par le shell. Prenez l’habitude de toujours entourer le motif de guillemets.

Chercher des caractères spéciaux sans les échapper. Un point, une parenthèse ou une étoile ont une signification en expression régulière. Si vous cherchez ces caractères littéralement, utilisez -F ou échappez-les avec un antislash.

Confondre -c et le nombre d’occurrences. -c compte les lignes correspondantes, pas les occurrences. Une ligne contenant deux fois le motif compte pour une seule.

Oublier -r pour une recherche dans un dossier. Sans -r, grep s’attend à un fichier, pas à un dossier, et renvoie une erreur ou ne cherche pas en profondeur.

La ligne du grep qui apparaît dans les résultats. Quand on filtre la sortie de ps avec grep, la commande grep elle-même apparaît souvent dans les résultats. On l’exclut avec un second grep -v "grep".

Combiner grep avec find et les pipes

grep prend toute sa puissance en le chaînant avec d’autres outils.

find + grep : chercher dans une sélection de fichiers

Quand on veut chercher un motif uniquement dans certains types de fichiers, on combine find (qui sélectionne) et grep (qui cherche). Le tandem -print0 / xargs -0 gère correctement les noms de fichiers contenant des espaces :

find . -type f -name "*.py" -print0 | xargs -0 grep "import"

Cette approche est plus souple que le -r de grep seul, car elle permet de filtrer précisément les fichiers avec toute la puissance de find.

grep dans une chaîne de pipes

grep est le filtre universel en fin de tube. On l’utilise pour affiner la sortie de n’importe quelle commande. Par exemple, lister les fichiers d’un dossier et ne garder que ceux modifiés en janvier :

ls -l | grep "janv"

Ou enchaîner plusieurs grep pour affiner progressivement une recherche, chacun filtrant un peu plus le résultat du précédent :

grep "erreur" journal.log | grep -i "connexion" | grep -v "test"

Ce type d’enchaînement — filtrer, puis affiner, puis exclure — est au cœur du travail quotidien en ligne de commande.

En résumé

grep repose sur quelques options qu’il suffit de bien connaître :

la recherche de base, avec -i (ignorer la casse) et -w (mot entier) ;
la recherche récursive (-r, -R) dans une arborescence ;
l’affichage : numéros de ligne (-n), comptage (-c), noms de fichiers seuls (-l, -L), contexte (-A, -B, -C) ;
l’inversion (-v) pour exclure ;
les expressions régulières, avec le mode étendu (-E) et la recherche littérale (-F) ;
les combinaisons avec find et les pipes, qui en font le filtre universel du terminal.

Comme pour la plupart des outils en ligne de commande, la maîtrise vient avec la pratique : commencez par une recherche simple, puis ajoutez les options une à une selon le besoin. Très vite, grep devient un réflexe qu’on utilise des dizaines de fois par jour.

Vous avez une combinaison grep dont vous ne pourriez plus vous passer ? Associé à find et sed, il forme le trio incontournable du traitement de texte sous Unix — un socle qui sert au quotidien.