> Maîtriser grep sous Linux : syntaxe, options essentielles (-i, -r, -n, -v, -E, -l, -c), expressions régulières et combinaison avec des pipes. Exemples concrets sur des logs et du code. *Source : https://coder-studio.com/outils/grep-commande/* --- [// Linux & terminal](https://coder-studio.com/outils/) # La commande grep : rechercher dans les fichiers sous Linux Par **Kévin Papot** · publié le 28 novembre 2025 `grep` est l’un des outils les plus utilisés au quotidien sous Linux et macOS. Son rôle : **chercher des lignes qui correspondent à un motif** dans un ou plusieurs fichiers, ou dans un flux. Que ce soit pour retrouver une erreur dans des logs, localiser un appel de fonction dans un projet, ou filtrer la sortie d’une autre commande, `grep` est le couteau suisse de la recherche en ligne de commande. Ce mémo couvre sa syntaxe, ses options clés et les combinaisons qui font gagner du temps. ## Syntaxe de base La forme générale est simple : un motif, puis un ou plusieurs fichiers. ``` grep "motif" fichier.txt ``` `grep` affiche chaque ligne du fichier qui **contient** le motif. Le motif peut être un simple mot ou une expression régulière (voir plus bas). Les guillemets ne sont pas toujours obligatoires, mais on les met par sécurité dès que le motif contient des espaces ou des caractères spéciaux. ``` # Chercher "erreur" dans un fichier de log grep "erreur" application.log # Chercher dans plusieurs fichiers grep "TODO" fichier1.js fichier2.js # Chercher dans tous les fichiers .js du dossier courant grep "console.log" *.js ``` ## Les options essentielles Quelques options couvrent 90 % des usages. Elles se combinent librement. ### \-i : ignorer la casse Par défaut, `grep` distingue majuscules et minuscules. `-i` rend la recherche insensible à la casse. ``` grep -i "error" application.log # Trouve "error", "Error", "ERROR"... ``` ### \-r : recherche récursive `-r` (récursif) parcourt un dossier entier et tous ses sous-dossiers. Indispensable pour fouiller un projet. ``` # Chercher "apiKey" dans tout le projet grep -r "apiKey" . ``` Le `.` désigne le dossier courant. La variante `-R` suit en plus les liens symboliques. ### \-n : afficher le numéro de ligne `-n` préfixe chaque résultat par son numéro de ligne. Précieux pour aller droit au bon endroit dans un fichier. ``` grep -n "function" script.js # 12:function init() { # 47:function render() { ``` ### \-v : inverser la sélection `-v` affiche les lignes qui **ne contiennent pas** le motif. Parfait pour exclure du bruit. ``` # Toutes les lignes du log SAUF celles qui mentionnent "DEBUG" grep -v "DEBUG" application.log ``` ### \-l : lister seulement les fichiers `-l` (L minuscule) n’affiche pas les lignes, mais **les noms des fichiers** qui contiennent au moins une correspondance. ``` # Quels fichiers utilisent "deprecated" ? grep -rl "deprecated" . ``` À l’inverse, `-L` (L majuscule) liste les fichiers qui **ne contiennent pas** le motif. ### \-c : compter les occurrences `-c` (_count_) renvoie le **nombre de lignes** correspondantes, par fichier. ``` # Combien de lignes contiennent "erreur" ? grep -c "erreur" application.log ``` Attention : `-c` compte les _lignes_ correspondantes, pas les occurrences totales. Une ligne avec deux fois le motif ne compte que pour une. ### \-E : les expressions régulières étendues `-E` active les regex **étendues**, qui autorisent `+`, `?`, `|`, `()` sans les échapper. On peut aussi utiliser `egrep`, son alias historique. ``` # Chercher "erreur" OU "warning" grep -E "erreur|warning" application.log # Chercher un code HTTP 4xx ou 5xx grep -E "HTTP (4|5)[0-9][0-9]" access.log ``` ## Les expressions régulières avec grep `grep` interprète le motif comme une **expression régulière**. Quelques métacaractères de base : - `^` : début de ligne - `$` : fin de ligne - `.` : n’importe quel caractère - `[abc]` : un caractère parmi a, b ou c - `[0-9]` : un chiffre - `*` : zéro ou plusieurs répétitions du motif précédent ``` # Lignes commençant par "GET" grep "^GET" access.log # Lignes se terminant par un point-virgule grep ";$" script.js # Adresses IP approximatives (regex étendue) grep -E "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" access.log ``` En regex **de base** (sans `-E`), certains caractères comme `{`, `}`, `+`, `?` doivent être échappés avec `\`. C’est justement pour éviter cette gymnastique qu’on préfère souvent `-E`. ## Combiner grep avec un pipe La vraie puissance de `grep` apparaît quand on le branche derrière une autre commande via un **pipe** (`|`). `grep` filtre alors le flux de sortie, ligne par ligne. ``` # Filtrer la liste des processus pour trouver "nginx" ps aux | grep nginx # Voir en temps réel les erreurs dans un log qui grandit tail -f application.log | grep -i "error" # Lister les fichiers du dossier et ne garder que les .pdf ls -l | grep "\.pdf$" ``` On peut même **chaîner plusieurs grep** pour affiner progressivement : ``` # Les requêtes POST vers /api qui ont échoué (code 500) grep "POST" access.log | grep "/api" | grep "500" ``` Chaque `grep` réduit un peu plus le résultat. C’est souvent plus lisible qu’une regex unique et complexe. Pour aller plus loin dans l’assemblage de commandes, notre [mémo des commandes Git essentielles](https://coder-studio.com/outils/commandes-git-essentielles/) montre d’autres réflexes de terminal complémentaires. ## Exemples concrets **Retrouver une erreur avec son contexte** — les options `-A` (_after_) et `-B` (_before_) affichent les lignes autour de la correspondance : ``` # 3 lignes après chaque "Exception" grep -A 3 "Exception" application.log # 2 lignes avant et après grep -C 2 "timeout" application.log ``` **Chercher un mot exact** — `-w` évite les correspondances partielles (`cat` ne matchera pas `category`) : ``` grep -w "cat" fichier.txt ``` **Compter les erreurs par type dans un projet** : ``` grep -rn "throw new Error" ./src ``` **Exclure les dossiers lourds** lors d’une recherche récursive : ``` grep -r "TODO" . --exclude-dir=node_modules ``` ## En résumé `grep` se résume à une idée : filtrer des lignes selon un motif. Retenez le petit noyau d’options — `-i` pour ignorer la casse, `-r` pour la récursivité, `-n` pour les numéros de ligne, `-v` pour exclure, `-l` pour lister les fichiers, `-c` pour compter et `-E` pour les regex étendues. Combinez le tout avec un pipe et vous disposez d’un outil de recherche redoutable, sans quitter le terminal. Sur les projets modernes, des alternatives comme `ripgrep` (`rg`) sont plus rapides, mais elles reprennent la même logique : maîtriser `grep`, c’est comprendre toutes les autres. ## À lire ensuite - [Git : les commandes essentielles (mémo)](https://coder-studio.com/outils/commandes-git-essentielles/) - [Débuter sous Linux quand on est développeur](https://coder-studio.com/tutoriels/debuter-linux-developpeur/) - [Les scripts Bash pour automatiser vos tâches](https://coder-studio.com/outils/scripts-bash-automatisation/)