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	✅ 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 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.

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.

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.

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.

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.

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.

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.

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.

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.

<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.

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   # ❌ 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   # ✅ le motif est protégé

Oubli de -i pour la casse

grep "error" fichier.log   # ❌ 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   # ✅ casse ignorée

grep se trouve lui-même

ps aux | grep nginx   # ❌ 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   # ✅ on exclut la ligne du grep

Regex basique contre étendue

grep "ERROR|WARNING" fichier.log   # ❌ 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   # ✅ regex étendue

Caractères spéciaux non échappés

grep "prix: 10$" fichier.txt   # ❌ 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   # ✅ -F traite le motif comme du texte littéral

-c compte les lignes, pas les occurrences

grep -c "mot" fichier.txt   # ❌ 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   # ✅ compte les occurrences réelles

Fichiers binaires ignorés

grep "motif" fichier.bin   # ❌ 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   # ✅ -a force le traitement comme du texte

Correspondance partielle indésirable

grep "port" config.conf   # ❌ 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   # ✅ -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 "✅ Lab créé dans ~/grep-lab"
ls -la ~/grep-lab

Les douze étapes

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

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

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

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

# 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

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

Syntaxe et options

É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

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

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 →