La commande find sous Linux : le guide complet avec exemples

La commande find est l’un des outils les plus puissants du terminal Unix/Linux. Elle permet de rechercher des fichiers et des dossiers selon une multitude de critères — nom, type, taille, date, permissions — et d’agir directement sur les résultats. Bien maîtrisée, elle remplace des dizaines de manipulations manuelles.

Ce guide couvre find de façon progressive : la syntaxe de base, chaque grande famille d’options avec des exemples concrets, les actions à exécuter sur les fichiers trouvés, les pièges les plus fréquents, et enfin les combinaisons avec grep, xargs et sed qui décuplent sa puissance. Tous les exemples sont neutres et réutilisables tels quels.

La syntaxe de base

La structure d’une commande find est toujours la même :

find [chemin] [critères] [action]

• le chemin : où chercher (. pour le répertoire courant, / pour tout le système, ou un dossier précis) ;
• les critères : quoi chercher (par nom, taille, date…) ;
• l’action : que faire des résultats (les afficher, les supprimer, exécuter une commande…). Par défaut, find affiche simplement les chemins trouvés.

L’exemple le plus simple, qui liste tout ce qui se trouve dans le répertoire courant et ses sous-dossiers :

find .

Rechercher par nom

C’est l’usage le plus courant. L’option -name recherche par nom de fichier, en tenant compte de la casse.

find . -name "rapport.txt"

Pour utiliser des jokers, entourez toujours le motif de guillemets afin que ce soit find (et non le shell) qui les interprète. Pour trouver tous les fichiers .log :

find . -name "*.log"

Si vous voulez ignorer la casse (trouver Rapport.TXT comme rapport.txt), utilisez -iname :

find . -iname "*.pdf"

Rechercher par type

L’option -type filtre selon la nature de l’élément. Les valeurs les plus utiles :

• f : fichier ordinaire ;
• d : répertoire (directory) ;
• l : lien symbolique.

Pour ne lister que les répertoires :

find . -type d

Pour ne trouver que les fichiers (et exclure les dossiers) portant un certain nom :

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

Rechercher par taille

L’option -size filtre par taille de fichier. L’unité se précise par une lettre : k (kilo-octets), M (méga-octets), G (giga-octets). Le préfixe + signifie « plus grand que » et - « plus petit que ».

Trouver les fichiers de plus de 100 Mo :

find . -type f -size +100M

Trouver les fichiers de moins de 10 Ko (utile pour repérer des fichiers vides ou quasi vides) :

find . -type f -size -10k

Pour combiner et cibler une fourchette, par exemple entre 1 et 5 Mo :

find . -type f -size +1M -size -5M

Rechercher par date de modification

Les options -mtime (jours) et -mmin (minutes) filtrent selon la date de dernière modification. Là encore, + signifie « il y a plus de » et - « il y a moins de ».

Trouver les fichiers modifiés il y a moins de 7 jours :

find . -type f -mtime -7

Trouver les fichiers modifiés il y a plus de 30 jours (candidats à l’archivage ou au nettoyage) :

find . -type f -mtime +30

Pour une granularité fine, par exemple les fichiers modifiés dans les 15 dernières minutes :

find . -type f -mmin -15

Il existe aussi -atime (dernier accès) et -ctime (dernier changement de métadonnées), qui suivent la même logique.

Rechercher par permissions et par propriétaire

Pour trouver des fichiers selon leurs droits, -perm est précieux — notamment pour repérer des fichiers trop permissifs. Par exemple, les fichiers accessibles en écriture par tout le monde :

find . -type f -perm -o+w

Pour chercher les fichiers appartenant à un utilisateur donné, utilisez -user :

find . -type f -user nom_utilisateur

Et par groupe, -group :

find . -type f -group nom_groupe

Contrôler la profondeur de recherche

Par défaut, find descend dans toute l’arborescence. On peut limiter cette descente.

-maxdepth limite la profondeur. Pour ne chercher que dans le répertoire courant, sans descendre dans les sous-dossiers :

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

-mindepth fait l’inverse : il ignore les premiers niveaux. Pour ne chercher qu’à partir du deuxième niveau :

find . -mindepth 2 -name "*.txt"

Placer ces options avant les autres critères améliore aussi les performances sur de grosses arborescences.

Combiner plusieurs critères

Les critères s’enchaînent naturellement : par défaut, find applique un ET logique. Cette commande trouve les fichiers .log de plus de 50 Mo modifiés il y a plus de 7 jours :

find . -type f -name "*.log" -size +50M -mtime +7

Pour un OU logique, on utilise -o en encadrant les critères par des parenthèses échappées. Trouver les fichiers .jpg ou .png :

find . -type f \( -name "*.jpg" -o -name "*.png" \)

Enfin, -not (ou !) inverse un critère. Trouver tous les fichiers sauf les .tmp :

find . -type f -not -name "*.tmp"

Agir sur les fichiers trouvés

C’est là que find devient vraiment puissant : au lieu de simplement lister, il peut exécuter une action sur chaque résultat.

Exécuter une commande avec -exec

-exec lance une commande sur chaque fichier trouvé. Le {} représente le fichier courant, et la commande se termine par \;. Par exemple, afficher les détails de chaque fichier .sh :

find . -type f -name "*.sh" -exec ls -lh {} \;

Pour copier tous les fichiers .conf trouvés vers un dossier de sauvegarde :

find . -type f -name "*.conf" -exec cp {} /chemin/sauvegarde/ \;

Supprimer des fichiers

Deux approches. La plus explicite, via -exec rm :

find . -type f -name "*.tmp" -exec rm {} \;

Ou l’option dédiée -delete, plus concise :

find . -type f -name "*.tmp" -delete

Une règle d’or avant toute suppression : lancez d’abord la commande sans l’action de suppression pour vérifier la liste des fichiers concernés. Mieux vaut voir ce qu’on s’apprête à effacer.

Optimiser avec + au lieu de \;

Avec \;, la commande est relancée une fois par fichier. En remplaçant \; par +, find regroupe plusieurs fichiers en un seul appel, ce qui est bien plus rapide sur de nombreux résultats :

find . -type f -name "*.log" -exec gzip {} +

Pièges et erreurs fréquentes

Quelques écueils classiques qui font perdre du temps :

Oublier les guillemets autour des jokers. Sans guillemets, c’est le shell qui interprète *.log avant find, ce qui donne des résultats imprévisibles. Écrivez toujours -name "*.log".

Confondre l’ordre des options. Les options de filtrage de l’arborescence comme -maxdepth doivent être placées avant les critères de test, sinon find émet un avertissement.

Se tromper de signe avec les dates et tailles. -mtime +7 signifie « il y a plus de 7 jours », pas « dans les 7 derniers jours » (qui serait -mtime -7). L’inversion est une source d’erreur très courante — un test à blanc évite les mauvaises surprises.

Lancer un -delete sans vérification. L’action -delete est irréversible. Testez toujours la sélection d’abord en affichant simplement les résultats.

Chercher sur / sans restriction. Lancer find / sur tout le système peut être très lent et générer beaucoup d’erreurs de permission. Ciblez un dossier précis ou combinez avec -maxdepth et une redirection des erreurs (2>/dev/null) pour un résultat lisible.

Combiner find avec grep, xargs et sed

La vraie puissance de find se révèle quand on le chaîne avec d’autres outils.

find + grep : chercher dans le contenu

find trouve les fichiers, grep cherche à l’intérieur. La combinaison via -exec permet de chercher un mot dans tous les fichiers d’un type donné :

find . -type f -name "*.py" -exec grep -l "import os" {} \;

L’option -l de grep n’affiche que le nom des fichiers contenant le motif.

find + xargs : traiter efficacement de gros volumes

xargs est souvent plus rapide que -exec pour appliquer une commande à de nombreux fichiers. Le tandem -print0 / -0 gère correctement les noms contenant des espaces :

find . -type f -name "*.txt" -print0 | xargs -0 grep "recherche"

C’est le pattern recommandé pour chercher un texte dans une grande arborescence sans se soucier des noms de fichiers exotiques.

find + sed : modifier en masse

En chaînant find et sed, on modifie le contenu de plusieurs fichiers d’un coup. Par exemple, remplacer un mot dans tous les fichiers .conf :

find . -type f -name "*.conf" -exec sed -i 's/ancien/nouveau/g' {} +

Ici, sed -i modifie les fichiers sur place, et le + final regroupe les fichiers pour limiter le nombre d’appels. Attention toutefois : une modification en masse est difficile à annuler, mieux vaut disposer d’une sauvegarde avant de lancer ce type de commande.

En résumé

find est un outil qu’on n’a jamais fini d’explorer, mais l’essentiel tient dans quelques réflexes :

• rechercher par nom (-name, -iname), type (-type), taille (-size), date (-mtime, -mmin) ;
• contrôler la profondeur (-maxdepth, -mindepth) ;
• combiner les critères avec le ET implicite, le OU (-o) et la négation (-not) ;
• agir sur les résultats avec -exec, -delete, et optimiser avec + ;
• chaîner avec grep, xargs et sed pour aller plus loin.

Le meilleur moyen de progresser est de toujours tester une recherche en mode « affichage » avant d’y ajouter une action destructrice. Une fois ce réflexe acquis, find devient un allié quotidien qui fait gagner un temps précieux.

Vous avez une utilisation de find qui vous sauve régulièrement la mise ? Les combinaisons possibles sont quasi infinies — c’est ce qui fait tout l’intérêt de cette commande.