Rechercher des fichiers et du texte : `find` (bases), `grep` (bases)

Apprenez à rechercher efficacement des fichiers avec `find` et du texte dans des fichiers avec `grep` sous Linux. Découvrez les options de base de ces outils de recherche puissants.

Localiser l'information : l'art de la recherche en ligne de commande

Dans un système de fichiers qui peut contenir des milliers, voire des millions de fichiers, savoir comment localiser rapidement un fichier spécifique ou une information textuelle précise est une compétence cruciale. Linux offre des outils en ligne de commande extrêmement puissants pour ces tâches. Ce sous-chapitre vous introduit aux bases de deux des commandes de recherche les plus emblématiques : `find`, pour rechercher des fichiers et des répertoires en fonction de divers critères (nom, taille, type, date de modification, etc.), et `grep` (Global Regular Expression Print), pour rechercher des motifs textuels à l'intérieur des fichiers ou dans la sortie d'autres commandes.

Bien que `find` et `grep` possèdent une multitude d'options et puissent être utilisés pour des recherches très complexes, nous nous concentrerons ici sur leurs fonctionnalités fondamentales pour vous permettre de démarrer efficacement.

`find` : le détective du système de fichiers

La commande `find` parcourt une arborescence de répertoires à la recherche de fichiers et/ou de répertoires qui correspondent à des critères que vous spécifiez. Sa syntaxe générale est :

find [chemin_de_départ...] [expression_de_recherche]

`[chemin_de_départ...]` : Un ou plusieurs répertoires à partir desquels la recherche doit commencer. Si omis, `find` commence la recherche dans le répertoire courant (`.`).
`[expression_de_recherche]` : Une combinaison d'options, de tests et d'actions.

Rechercher par nom (`-name`, `-iname`) :
L'option `-name motif` recherche les fichiers dont le nom correspond exactement au `motif` (sensible à la casse). L'option `-iname motif` fait la même chose mais ignore la casse.

Exemples :

Trouver tous les fichiers nommés `config.txt` dans le répertoire courant et ses sous-répertoires :
```
find . -name "config.txt"
```
Trouver tous les fichiers dont le nom commence par `log` (par exemple, `log.txt`, `logfile.old`) dans `/var` (ignorer la casse) :
```
sudo find /var -iname "log*"
```
(`sudo` peut être nécessaire pour parcourir `/var` sans erreurs de permission. Les guillemets autour de `log*` empêchent le shell d'interpréter le `*` avant `find`).

Rechercher par type (`-type`) :
L'option `-type type_de_fichier` permet de spécifier le type d'élément à rechercher. Les types courants sont :

`f` : fichier ordinaire
`d` : répertoire
`l` : lien symbolique

Exemples :

Trouver tous les répertoires nommés `backup` dans `/home` :
```
find /home -type d -name "backup"
```
Trouver tous les fichiers (pas les répertoires) modifiés récemment (voir `-mtime` ci-dessous) :
```
find . -type f -mtime -7
```

Rechercher par date de modification (`-mtime`, `-mmin`) :
Ces options permettent de trouver des fichiers basés sur leur dernière date de modification.

`-mtime n` : Fichiers modifiés il y a exactement `n`*24 heures.
`-mtime +n` : Fichiers modifiés il y a plus de `n`*24 heures.
`-mtime -n` : Fichiers modifiés il y a moins de `n`*24 heures (dans les `n` derniers jours).
`-mmin n`, `-mmin +n`, `-mmin -n` : Similaire à `-mtime`, mais en minutes au lieu de jours.

Exemple :

Trouver tous les fichiers `.log` dans `/var/log` modifiés dans les dernières 24 heures :
```
sudo find /var/log -type f -name "*.log" -mtime -1
```

Rechercher par taille (`-size`) :
L'option `-size n[cwbkMG]` recherche les fichiers d'une taille spécifique. Le suffixe indique l'unité : `c` (octets), `k` (kibioctets), `M` (mébioctets), `G` (gibioctets). On peut utiliser `+n` pour plus grand que `n` et `-n` pour plus petit que `n`.

Exemple :

Trouver tous les fichiers de plus de 100 Mébioctets dans le répertoire personnel :
```
find ~ -type f -size +100M
```

Exécuter une commande sur les fichiers trouvés (`-exec`, `-delete`) :
`find` peut faire plus que simplement lister les fichiers.

`-exec commande {} \;` : Exécute `commande` sur chaque fichier trouvé. `{}` est remplacé par le nom du fichier trouvé. `\;` termine la commande.
`-delete` : Supprime les fichiers trouvés (à utiliser avec une extrême prudence !).

Exemples :

Changer les permissions de tous les fichiers `.sh` dans le répertoire courant pour les rendre exécutables par leur propriétaire :
```
find . -type f -name "*.sh" -exec chmod u+x {} \;
```

Attention : Supprimer tous les fichiers `.tmp` dans `/tmp` (vérifiez bien avant !) :

# D'abord, listez-les pour vérifier :
sudo find /tmp -type f -name "*.tmp"
# Puis, si vous êtes sûr :
sudo find /tmp -type f -name "*.tmp" -delete

`find` est un outil très flexible. Pour des recherches plus complexes, on peut combiner les tests avec les opérateurs logiques `-and` (implicite si plusieurs tests sont listés), `-or`, et `-not` (ou `!`).

`grep` : le chasseur de motifs textuels

La commande `grep` (Global Regular Expression Print) recherche des lignes contenant un motif spécifié dans un ou plusieurs fichiers, ou dans l'entrée standard (par exemple, la sortie d'une autre commande redirigée avec un tube `|`). Sa syntaxe de base est :

grep [options] motif [fichier...]

`[options]` : Modifient le comportement de `grep`.
`motif` : La chaîne de caractères ou l'expression régulière à rechercher.
`[fichier...]` : Un ou plusieurs fichiers dans lesquels rechercher. Si omis, `grep` lit l'entrée standard.

Recherche simple dans un fichier :
Pour trouver toutes les lignes contenant le mot "error" dans le fichier `system.log` :

grep "error" system.log

Si le motif contient des espaces ou des caractères spéciaux pour le shell, il est préférable de le mettre entre guillemets.Options courantes de `grep` :

`-i` (ignore case) : Ignore la casse lors de la recherche (trouve "error", "Error", "ERROR", etc.).
```
grep -i "error" system.log
```
`-v` (invert match) : Affiche toutes les lignes qui ne correspondent PAS au motif.
```
grep -v "DEBUG" application.log # Exclure les lignes de débogage
```
`-r` ou `-R` (recursive) : Recherche récursivement dans tous les fichiers d'un répertoire.
```
grep -r "API_KEY" ~/projects/
```
`-l` (files with matches) : Affiche uniquement les noms des fichiers contenant le motif, pas les lignes elles-mêmes.
```
grep -l "TODO" *.py
```
`-n` (line number) : Affiche le numéro de la ligne avant chaque ligne correspondante.
```
grep -n "function setup" script.js
```
`-c` (count) : Affiche uniquement le nombre de lignes correspondantes, pas les lignes elles-mêmes.
```
grep -c "failed login" auth.log
```
`-w` (word regexp) : Recherche le motif comme un mot entier (par exemple, `grep -w "is"` ne trouvera pas "this").
`-E` (extended regexp) : Interprète le motif comme une expression régulière étendue (plus puissante). `-F` (fixed strings) interprète le motif littéralement, sans expressions régulières.

Utiliser `grep` avec des tubes (`|`) :
`grep` est très souvent utilisé pour filtrer la sortie d'autres commandes. C'est l'une de ses utilisations les plus puissantes.

Exemples :

Afficher les processus `firefox` en cours :
```
ps aux | grep firefox
```
Lister les fichiers du répertoire courant contenant le mot "rapport" (ignorer la casse) :
```
ls -l | grep -i "rapport"
```
(Note : pour rechercher dans le contenu des fichiers, `grep -i "rapport" *` serait plus direct si vous êtes dans le bon répertoire).
Trouver les lignes dans l'historique des commandes qui contiennent `apt install` :
```
history | grep "apt install"
```

`grep` supporte les expressions régulières, ce qui lui confère une capacité de recherche de motifs très sophistiquée. Apprendre les bases des expressions régulières (comme `.` pour n'importe quel caractère, `*` pour zéro ou plus occurrences du précédent, `^` pour le début de ligne, `$` pour la fin de ligne) décuple la puissance de `grep`.

En combinant `find` et `grep` (par exemple, en utilisant `find` pour localiser des fichiers puis `-exec grep ... {} \;` pour chercher du texte à l'intérieur), vous disposez d'un arsenal complet pour toutes vos tâches de recherche sous Linux. La maîtrise de leurs options de base est un investissement très rentable en temps et en efficacité.

◄ Précédent Suivant ►

く