Recherche et filtres

Linux offre un ensemble de commandes conçues pour chercher, filtrer, compter, trier et enchaîner des opérations sur du texte. Ces commandes sont les outils quotidiens de quiconque travaille avec un serveur, un terminal ou un pipeline de déploiement.

---

Commande grep : Chercher du texte dans les fichiers

grep est l’outil de recherche de texte le plus utilisé en Linux. Son nom vient de Global Regular Expression Print. Il parcourt un fichier ligne par ligne et affiche uniquement les lignes qui contiennent le motif recherché.

Usage de base

grep "motif" fichier

Par exemple, pour trouver toutes les erreurs dans un log :

grep "ERROR" /var/log/serveur.log
# [2026-05-07 10:40:22] ERROR  Timeout de la base de données
# [2026-05-07 11:05:12] ERROR  Timeout de la base de données

grep n’affiche que les lignes correspondantes. Tout le reste du fichier est ignoré.

Options courantes

Option	Effet	Exemple
-n	Affiche le numéro de ligne	grep -n "ERROR" log.txt
-i	Insensible à la casse (majuscules/minuscules)	grep -i "error" log.txt
-c	Compte le nombre de lignes correspondantes	grep -c "404" acces.log
-r	Cherche récursivement dans un dossier	grep -r "TODO" src/
-v	Inverse le filtre (lignes qui ne contiennent PAS le motif)	grep -v "INFO" erreurs.log
--include	Limite la recherche à certains types de fichiers	grep -r --include="*.js" "console.log" .

grep -v : le filtre inversé

L’option -v est souvent sous-estimée. Elle est très utile pour exclure du bruit. Par exemple, grep -v "INFO" retire les lignes informatives d’un log pour ne garder que les avertissements et les erreurs. C’est généralement ce qui t’intéresse quand tu débogues.

Chercher récursivement dans un projet

Quand tu travailles sur un projet web, tes fichiers sont répartis dans plusieurs dossiers. L’option -r permet à grep de parcourir toute l’arborescence :

Chercher “console.log” dans tous les fichiers JavaScript du projet

grep -rn --include="*.js" "console.log" .
# ./src/app.js:12:  console.log("Serveur démarré");
# ./src/api/routes.js:45:  console.log("Requête reçue:", req.url);

Chercher les FIXME dans tout le projet

grep -rn "FIXME" .

Équivalent Windows

PowerShell offre Select-String qui joue le même rôle : Select-String -Path *.js -Pattern "TODO". Le principe est identique : filtrer des lignes de texte par motif.

---

Commande find : Chercher des fichiers

grep cherche du texte dans les fichiers. find cherche les fichiers eux-mêmes en utilisant un critère: nom, type, taille ou date.

Usage de base

find chemin -critère valeur

Trouver tous les fichiers CSS dans le projet

find . -name "*.css"

Résultat de l’exécution (possible)

./css/style.css
./css/navigation.css

Trouver tous les fichiers JavaScript

./js/app.js

find . -name "*.js"
# ./js/validation.js

Résultat de l’exécution (possible)

./js/app.js
./js/validation.js

Pourquoi le `.` au début?

Le . au début signifie « à partir du dossier courant ». Tu peux remplacer par n’importe quel chemin : find /var/log -name "*.log".

Critères courants

Critère	Effet	Exemple
-name "motif"	Cherche par nom (sensible à la casse)	find . -name "*.html"
-iname "motif"	Cherche par nom, insensible à la casse	find . -iname "readme*"
-type f	Seulement les fichiers	find . -type f
-type d	Seulement les dossiers	find . -type d
-maxdepth N	Limite la profondeur de recherche	find . -maxdepth 1 -name "*.html"

Lister tous les dossiers du projet

find . -type d

Résultat de l’exécution (possible)

.
./css
./js
./img
./pages

Trouver les fichiers HTML seulement à la racine (pas dans les sous-dossiers)

find . -maxdepth 1 -name "*.html"

Résultat de l’exécution (possible)

./index.html

Trouver les fichiers de configuration (.env, .conf, .cfg)

find /etc -name "*.conf" -type f

Exécuter une commande sur les résultats

find peut appeler une commande sur chaque fichier trouvé avec l’option -exec :

Compter les lignes de chaque fichier CSS

find . -name "*.css" -exec wc -l {} +

Résultat de l’exécution (possible)

26 ./css/navigation.css
63 ./css/style.css
126 total

Afficher les permissions de chaque script

find . -name "*.sh" -exec ls -l {} +

La syntaxe est particulière :

• {} est remplacé par le nom du fichier trouvé
• + (ou \;) termine la commande.

Syntaxe de -exec

find . -name "*.css" -exec wc -l {} + — les espaces autour de {} et le + final sont obligatoires. C’est une des syntaxes les moins intuitives de bash, mais elle est extrêmement puissante.

---

Commande wc : Compter les lignes, les mots et les caractères

wc (word count) est un outil de comptage simple mais essentiel. Il compte les lignes, les mots et les caractères d’un fichier ou d’une entrée.

wc fichier.txt
#   42  186  1205 fichier.txt
# lignes mots caractères

Options

Option	Compte	Exemple
-l	Lignes seulement	wc -l acces.log
-w	Mots seulement	wc -w article.txt
-c	Caractères (octets) seulement	wc -c style.css

Combien de requêtes dans le log d’accès? (1 ligne = 1 requête)

wc -l acces.log

Résultat de l’exécution (possible)

26 acces.log

Combien de lignes dans tous les fichiers CSS?

wc -l css/*.css

26 css/navigation.css
63 css/style.css
37 css/typo.css
126 total

Stocker le résultat dans une variable

NB_LIGNES=$(cat acces.log | wc -l)
echo "Nombre de requêtes : $NB_LIGNES"

wc -l avec plusieurs fichiers

Quand tu passes plusieurs fichiers à wc -l, il affiche le compte pour chaque fichier et un total à la fin. C’est un moyen rapide de comparer la taille de plusieurs fichiers.

---

Trier les lignes avec sort

sort prend un fichier (ou une entrée) et trie ses lignes par ordre alphabétique par défaut.

Fichier non trié

cat fruits.txt

Résultat de l’exécution (possible)

banane
cerise
abricot
datte

sort fruits.txt

Résultat de l’exécution (possible)

abricot
banane
cerise
datte

Options courantes

Option	Effet	Exemple
-r	Tri inversé (Z → A)	sort -r fichier.txt
-n	Tri numérique (1, 2, 10 au lieu de 1, 10, 2)	sort -n nombres.txt
-u	Retire les doublons en triant	sort -u fichier.txt
-k N	Trie selon la N-ième colonne	sort -k 2 fichier.txt

Trier un log d’accès par code de réponse HTTP (8e colonne)

sort -k 8 acces.log

Trier des tailles de fichiers par ordre numérique décroissant

du -sh * | sort -rn

Résultat de l’exécution (possible)

12M  node_modules/
 2M  images/
45K  index.html
 8K  style.css

sort -n vs sort

Sans -n, sort trie comme un dictionnaire : 1, 10, 100, 2, 20, 3. Avec -n, il trie comme des nombres : 1, 2, 3, 10, 20, 100. Pour des tailles, des compteurs ou des PID, utilise toujours -n.

---

Commande uniq : Éliminer les doublons

uniq supprime les lignes consécutives identiques. Il est presque toujours utilisé après sort, car les doublons doivent être adjacents pour être détectés.

Sans sort, uniq ne voit que les doublons adjacents

cat visites.txt

Résultat de l’exécution (possible)

/index.html
/produits
/index.html     ← pas adjacent au premier, uniq ne le verra pas
/contact

Avec sort + uniq : doublons éliminés

sort visites.txt | uniq

/contact
/index.html
/produits

Options utiles

Option	Effet	Exemple
-c	Compte les occurrences de chaque ligne	sort fichier | uniq -c
-d	Affiche seulement les doublons	sort fichier | uniq -d

Quelles pages sont les plus visitées? Extraire les URLs, trier, compter

cat acces.log | awk '{print $6}' | sort | uniq -c | sort -rn

Résultat de l’exécution (possible)

#    5 /api/produits
#    3 /index.html
#    2 /api/commande
#    1 /contact
#    1 /apropos

• awk '{print $6}' extrait la 6e colonne de chaque ligne (ici, l’URL).
• Tu n’as pas besoin de maîtriser awk. Retiens juste que awk '{print $N}' extrait la N-ième colonne d’un texte.

Cet enchaînement est un classique de l’analyse de logs. On y reviendra dans la section sur les pipes.

---

Redirections : Sauvegarder la sortie

Par défaut, chaque commande affiche son résultat à l’écran (la sortie standard, appelée stdout). Les redirections permettent d’envoyer ce résultat ailleurs — typiquement dans un fichier.

Les trois flux

Chaque commande Linux a trois flux de données :

Flux	Numéro	Nom	Rôle
stdin	0	Entrée standard	Ce que la commande lit (par défaut : le clavier)
stdout	1	Sortie standard	Ce que la commande affiche (par défaut : l’écran)
stderr	2	Sortie d’erreur	Les messages d’erreur (par défaut : l’écran aussi)

La sortie normale et les erreurs sont deux flux séparés, même si les deux s’affichent à l’écran. Les redirections te permettent de les diriger indépendamment.

Rediriger la sortie vers un fichier

> écrit dans un fichier (ÉCRASE le contenu s’il existe)

echo "Bonjour" > message.txt
cat message.txt
# Bonjour

>> AJOUTE à la fin du fichier (sans écraser)

echo "Au revoir" >> message.txt
cat message.txt
# Bonjour
# Au revoir

> vs >>

C’est le piège le plus courant avec les redirections.

• > écrase tout le contenu du fichier.
• >> ajoute à la fin.

Exemples concrets

# Sauvegarder les erreurs d'un log dans un fichier séparé
grep "ERROR" /var/log/serveur.log > erreurs-du-jour.txt

# Construire un rapport ligne par ligne
echo "Rapport du $(date +%Y-%m-%d)" > rapport.txt
echo "=============================" >> rapport.txt
echo "" >> rapport.txt
echo "Erreurs trouvées :" >> rapport.txt
grep "ERROR" serveur.log >> rapport.txt
echo "" >> rapport.txt
echo "Nombre total : $(grep -c "ERROR" serveur.log)" >> rapport.txt

---

Pipes : Enchaîner les commandes

Le pipe (|) est l’outil le plus puissant du terminal. Il prend la sortie d’une commande et l’envoie comme entrée à la commande suivante — comme un tuyau qui connecte deux machines.

commande1 | commande2 | commande3

La sortie de commande1 devient l’entrée de commande2, dont la sortie devient l’entrée de commande3. Chaque commande agit comme un filtre qui transforme les données en transit.

Premiers exemples

Compter le nombre de fichiers dans un dossier

ls | wc -l

Chercher un processus par nom

ps aux | grep "node"

Afficher les 5 dernières lignes d’un log

cat serveur.log | tail -5

Comment ça fonctionne

Prenons grep "ERROR" serveur.log | wc -l :

1. grep "ERROR" serveur.log lit le fichier et affiche les lignes contenant ERROR
2. Le pipe | intercepte cette sortie (au lieu de l’afficher à l’écran)
3. wc -l reçoit ces lignes et compte combien il y en a
4. Le résultat final (un nombre) s’affiche à l’écran

Chaque commande ne connaît que son entrée et sa sortie — elle ne sait pas ce qu’il y a avant ou après dans la chaîne.

Analogie

Imagine une chaîne de montage dans une usine. Chaque poste de travail reçoit une pièce, la transforme, et la passe au poste suivant. Aucun poste ne connaît le produit final — il fait juste son opération.

Le pipe fonctionne exactement comme ça : chaque commande reçoit du texte, le transforme, et le passe à la suivante.

Exemples progressifs

Assumons un fichier access.log avec le contenu suivant:

127.0.0.1 - - [13/May/2026] "GET /index.html HTTP/1.1" 200 532
127.0.0.2 - - [13/May/2026] "GET /about.html HTTP/1.1" 404 210
127.0.0.3 - - [13/May/2026] "GET /products HTTP/1.1" 200 888
127.0.0.4 - - [13/May/2026] "GET /products/43 HTTP/1.1" 404 220
127.0.0.5 - - [13/May/2026] "POST /login HTTP/1.1" 200 1200
127.0.0.6 - - [13/May/2026] "GET /index.html HTTP/1.1" 200 532
127.0.0.7 - - [13/May/2026] "GET /products HTTP/1.1" 500 100
127.0.0.8 - - [13/May/2026] "GET /index.html HTTP/1.1" 200 532
127.0.0.9 - - [13/May/2026] "GET /contact HTTP/1.1" 200 300
127.0.0.10 - - [13/May/2026] "POST /contact HTTP/1.1" 500 100
127.0.0.11 - - [13/May/2026] "POST /login HTTP/1.1" 200 1200
127.0.0.12 - - [13/May/2026] "GET /products HTTP/1.1" 200 888
127.0.0.13 - - [13/May/2026] "GET /acceuil.html HTTP/1.1" 404 220
127.0.0.14 - - [13/May/2026] "POST /login HTTP/1.1" 400 220
127.0.0.15 - - [13/May/2026] "POST /signup HTTP/1.1" 201 100

Niveau 1 : deux commandes

Combien de fichiers JavaScript dans le projet?

find . -name "*.js" | wc -l
# 3

Chercher les erreurs 404, afficher seulement le nombre

grep "404" acces.log | wc -l
# 4

Niveau 2 : trois commandes

Les 3 pages les plus visitées

grep "200" acces.log | awk '{print $6}' | sort | uniq -c | sort -rn | head -3

1. grep "200" acces.log: Trouver toutes les lignes contenant 200

   127.0.0.1 - - [13/May/2026] "GET /index.html HTTP/1.1" 200 532
   127.0.0.3 - - [13/May/2026] "GET /products HTTP/1.1" 200 888
   127.0.0.4 - - [13/May/2026] "POST /login HTTP/1.1" 200 1200
   127.0.0.5 - - [13/May/2026] "GET /index.html HTTP/1.1" 200 532
   127.0.0.7 - - [13/May/2026] "GET /index.html HTTP/1.1" 200 532
   127.0.0.8 - - [13/May/2026] "GET /contact HTTP/1.1" 200 300
   127.0.0.9 - - [13/May/2026] "POST /login HTTP/1.1" 200 1200
   127.0.0.10 - - [13/May/2026] "GET /products HTTP/1.1" 200 888

2. awk '{print $6}': Conserver le 6e champ de chaque ligne

   1	2	3	4	5	6	7…
   127.0.0.1	-	-	[13/May/2026]	"GET	/index.html	…
   127.0.0.3	-	-	[13/May/2026]	"GET	/products	…
   127.0.0.4	-	-	[13/May/2026]	"POST	/login	…

   /index.html
   /products
   /login
   /index.html
   /index.html
   /contact
   /login
   /products

3. sort: Trier par ordre alphabétique (important pour le décompte avec uniq)

   /contact
   /index.html
   /index.html
   /index.html
   /login
   /login
   /products
   /products

4. uniq -c: Compter les doublons (consécutifs)

   1 /contact
   3 /index.html
   2 /login
   2 /products

5. sort -rn: Trier par ordre numérique décroissant (reverse)

   3 /index.html
   2 /products
   2 /login
   1 /contact

6. head -3: Conserver les trois premières lignes

   3 /index.html
   2 /products
   2 /login

Les adresses IP qui génèrent des erreurs 403

grep "403" acces.log | awk '{print $1}' | sort -u
# 172.16.0.3

Niveau 3 : résoudre un vrai problème

”Quelles adresses IP ont provoqué des erreurs 500 aujourd’hui?”

grep "500" acces.log | awk '{print $1}' | sort | uniq -c | sort -rn
#    2 10.0.0.5

---

---

Synthèse

Chercher

grep cherche du texte dans les fichiers. find cherche les fichiers eux-mêmes.
L’option -r de grep et -exec de find étendent leur portée à tout un projet (dossier).

Compter et trier

wc -l compte les lignes. sort trie. uniq -c compte les occurrences.
Ensemble, sort | uniq -c | sort -rn produit un classement par fréquence.

Rediriger

> écrit dans un fichier (écrase). >> ajoute à la fin.
2> redirige les erreurs. 2> /dev/null les ignore.

Enchaîner

Le pipe | connecte la sortie d’une commande à l’entrée de la suivante.
Chaque commande est un filtre dans une chaîne de traitement.