Débutant : Utiliser find pour rechercher des fichiers par nom, taille et date avec des exemples pratiques

La commande find est l’un des outils les plus utiles de la ligne de commande Linux. Elle permet d’explorer une arborescence de dossiers et de rechercher des fichiers ou des répertoires selon de nombreux critères : nom, type, taille, date de modification, propriétaire, permissions, et bien plus encore.

Pour un débutant, find peut sembler impressionnante, car sa syntaxe est plus riche que celle d’autres commandes courantes. Pourtant, dès que l’on comprend son fonctionnement de base, elle devient un réflexe très pratique pour retrouver rapidement un fichier perdu, lister des fichiers volumineux, repérer des éléments récents, ou préparer un nettoyage ciblé.

Dans ce tutoriel, nous allons nous concentrer sur trois usages fondamentaux et très utiles : rechercher par nom, par taille et par date. Chaque partie contient des explications progressives et des exemples pratiques que vous pourrez adapter à votre propre système.

L’objectif n’est pas seulement de copier des commandes, mais de comprendre la logique de find : où elle cherche, sur quoi elle filtre, et comment combiner plusieurs critères pour obtenir des résultats précis.

Prérequis

Disposer d’un système Linux ou d’un environnement compatible avec la commande find.
Savoir ouvrir un terminal.
Connaître les notions de base suivantes : fichier, dossier, chemin absolu, chemin relatif.
Avoir des droits de lecture suffisants sur les dossiers que vous souhaitez parcourir.

Aucune connaissance avancée n’est nécessaire. Les exemples commencent par les cas les plus simples avant d’aller vers des recherches combinées.

Matériel nécessaire

Un ordinateur avec Linux ou un terminal disposant de la commande find
Un répertoire de test avec quelques fichiers et sous-dossiers
Des droits d’accès en lecture sur les dossiers à analyser

Étapes

Comprendre le rôle général de find
La commande find parcourt un ou plusieurs répertoires et affiche les éléments qui correspondent à des critères. Sa structure la plus simple ressemble à ceci :
```
find chemin critère
```
Le chemin indique à partir de quel dossier la recherche commence. Le critère précise ce que vous cherchez.
Exemple minimal :
```
find .
```
Cette commande parcourt le répertoire courant, représenté par ., et affiche tout ce qu’elle rencontre : dossiers, sous-dossiers et fichiers.
Dans la pratique, on utilise rarement find sans filtre, car le résultat peut être très long. L’intérêt réel apparaît lorsqu’on ajoute des tests comme -name, -size ou -mtime.
Un point important à retenir : find travaille de manière récursive. Cela signifie qu’elle descend automatiquement dans les sous-répertoires du chemin indiqué. Si vous lancez une recherche depuis votre dossier personnel, elle peut examiner un grand nombre d’éléments.
Voici un exemple simple pour chercher dans votre dossier personnel :
```
find ~ -name "notes.txt"
```
Cette commande demande à find d’explorer votre répertoire personnel et d’afficher les fichiers ou dossiers dont le nom est exactement notes.txt.
Dans tout le reste du tutoriel, gardez cette logique en tête :
- on choisit un point de départ ;
- on ajoute un ou plusieurs critères ;
- find retourne les éléments correspondants.
Préparer un répertoire de test pour s’exercer en toute sécurité
Avant de faire des recherches sur tout votre système, il est souvent plus confortable de créer un petit espace de test. Cela permet de comprendre le comportement de find sans être noyé dans des centaines de résultats.
Vous pouvez par exemple créer une structure simple dans votre dossier personnel :
```
mkdir -p ~/test-find/documents
mkdir -p ~/test-find/images
mkdir -p ~/test-find/archives
```
Ajoutez ensuite quelques fichiers vides pour vos essais :
```
touch ~/test-find/documents/rapport.txt
touch ~/test-find/documents/notes.txt
touch ~/test-find/images/photo.jpg
touch ~/test-find/images/logo.png
touch ~/test-find/archives/sauvegarde.tar.gz
```
À partir de là, vous disposez d’une petite arborescence sur laquelle tester des commandes sans risque.
Vous pouvez vérifier son contenu avec :
```
find ~/test-find
```
Le résultat affichera le dossier principal, ses sous-dossiers et les fichiers créés.
Cette étape n’est pas obligatoire, mais elle est très utile pour débuter. Quand une commande ne donne pas le résultat attendu, il est beaucoup plus simple de corriger le tir sur un exemple réduit que sur un répertoire système complexe.
Rechercher un fichier par nom avec -name
Le critère le plus fréquent est la recherche par nom. Pour cela, on utilise -name.
Exemple :
```
find ~/test-find -name "rapport.txt"
```
Cette commande affiche les chemins des éléments dont le nom exact est rapport.txt.
Si le fichier existe dans l’arborescence, vous obtiendrez un résultat du type :
```
/home/utilisateur/test-find/documents/rapport.txt
```
Point important : avec -name, la casse compte. Autrement dit, rapport.txt et Rapport.txt ne sont pas considérés comme identiques.
Si vous ne connaissez pas exactement le nom complet, vous pouvez utiliser des caractères génériques entre guillemets. Par exemple, pour chercher tous les fichiers se terminant par .txt :
```
find ~/test-find -name "*.txt"
```
Cette recherche peut retourner plusieurs résultats, par exemple :
```
/home/utilisateur/test-find/documents/rapport.txt
/home/utilisateur/test-find/documents/notes.txt
```
On peut aussi rechercher un motif partiel. Par exemple, tous les noms contenant note :
```
find ~/test-find -name "*note*"
```
Les guillemets sont importants. Ils évitent que le shell interprète lui-même l’astérisque avant que find ne reçoive l’expression.
Quelques motifs pratiques :
- "*.log" pour tous les fichiers finissant par .log;
- "image*" pour tous les noms commençant par image;
- "*2024*" pour tous les noms contenant 2024.
Pour un débutant, c’est souvent la première forme de recherche vraiment utile au quotidien.
Ignorer les majuscules et minuscules avec -iname
Si vous n’êtes pas certain de la casse exacte du fichier, utilisez -iname au lieu de -name. Cette variante effectue une comparaison insensible aux majuscules et minuscules.
Exemple :
```
find ~/test-find -iname "rapport.txt"
```
La commande pourra correspondre à rapport.txt, Rapport.txt ou RAPPORT.TXT.
C’est très pratique lorsque des fichiers ont été créés ou renommés depuis différents outils ou systèmes, ou lorsque vous ne vous souvenez plus de la casse exacte.
Autre exemple avec un motif :
```
find ~/test-find -iname "*.jpg"
```
Cette commande peut retrouver aussi bien photo.jpg que PHOTO.JPG.
En pratique, -iname est souvent plus confortable pour les recherches exploratoires, tandis que -name est utile lorsque l’on veut une correspondance stricte.
Limiter la recherche aux fichiers ou aux dossiers avec -type
Lorsque vous recherchez par nom, vous pouvez obtenir des fichiers et des répertoires. Pour préciser le type d’élément recherché, utilisez -type.
Les deux cas les plus utiles au quotidien sont :
- -type f pour les fichiers ;
- -type d pour les répertoires.
Exemple : chercher uniquement les fichiers .txt :
```
find ~/test-find -type f -name "*.txt"
```
Exemple : chercher uniquement les dossiers nommés images :
```
find ~/test-find -type d -name "images"
```
Cette précision est très utile. Sans -type, un nom pourrait correspondre à un fichier dans certains cas et à un dossier dans d’autres.
Quand on débute, il est recommandé d’ajouter souvent -type f pour éviter les ambiguïtés, surtout lors des recherches de documents, d’images, d’archives ou de journaux.
Rechercher des fichiers par taille avec -size
La commande find permet aussi de filtrer par taille avec l’option -size. C’est très utile pour repérer des fichiers volumineux, identifier des archives encombrantes ou retrouver un fichier dont vous connaissez seulement l’ordre de grandeur.
Exemple simple :
```
find ~/test-find -type f -size 1M
```
Cette commande recherche les fichiers dont la taille correspond à 1M selon l’unité indiquée.
Pour les usages débutants, il est surtout utile de retenir le principe suivant :
- une valeur simple cible une taille correspondant à l’unité choisie ;
- un préfixe + signifie strictement plus que ;
- un préfixe - signifie strictement moins que.
Exemples concrets :
```
find ~/test-find -type f -size +10M
```
Recherche les fichiers de plus de 10 M.
```
find ~/test-find -type f -size -1M
```
Recherche les fichiers de moins de 1 M.
```
find ~/test-find -type f -size +100M
```
Très pratique pour repérer les gros fichiers occupant de l’espace disque.
Dans un contexte courant, vous pouvez utiliser cette commande pour lister les vidéos, archives ou sauvegardes les plus lourdes dans votre dossier personnel :
```
find ~ -type f -size +500M
```
Si vous lancez cette commande dans un grand répertoire, le résultat peut être long. C’est normal : find parcourt récursivement toute l’arborescence.
Exemples pratiques de recherche par taille
Voyons maintenant plusieurs cas réalistes.
1. Trouver les grosses archives
```
find ~/test-find -type f -name "*.tar.gz" -size +10M
```
Cette commande recherche des fichiers d’archive compressés de plus de 10 M.
2. Lister les petites notes texte
```
find ~/test-find -type f -name "*.txt" -size -100k
```
Pratique pour repérer des petits fichiers texte.
3. Repérer de gros médias dans le dossier personnel
```
find ~ -type f -size +200M
```
Cette recherche est souvent utilisée quand on manque d’espace disque.
4. Combiner nom et taille
```
find ~/test-find -type f -name "*.jpg" -size +5M
```
Ici, on cherche des images JPEG de plus de 5 M.
Ce qu’il faut retenir, c’est que find devient particulièrement puissante quand on combine plusieurs critères simples. Vous n’avez pas besoin d’apprendre toute sa syntaxe d’un coup : savoir mélanger -type, -name et -size suffit déjà pour résoudre beaucoup de situations concrètes.
Rechercher par date avec -mtime
Un autre besoin fréquent consiste à retrouver des fichiers récents, anciens, ou modifiés dans une période approximative. Pour cela, find propose notamment -mtime, qui permet de filtrer selon l’ancienneté de la date de modification.
Exemple :
```
find ~/test-find -type f -mtime 0
```
Cette commande recherche les fichiers modifiés récemment selon le critère fourni par -mtime.
Comme pour -size, les préfixes sont importants :
- -mtime -7 signifie : modifiés il y a moins de 7 jours ;
- -mtime +7 signifie : modifiés il y a plus de 7 jours ;
- -mtime 7 cible une ancienneté correspondant à la valeur indiquée.
Exemples pratiques :
```
find ~/test-find -type f -mtime -7
```
Affiche les fichiers modifiés au cours des derniers jours correspondant à ce critère.
```
find ~/test-find -type f -mtime +30
```
Affiche les fichiers modifiés depuis plus de 30 jours. Très utile pour identifier de vieux fichiers.
```
find ~/test-find -type f -name "*.log" -mtime -1
```
Recherche les fichiers .log récents.
Dans la vie réelle, ce filtre est précieux pour :
- retrouver un document modifié récemment ;
- repérer d’anciens fichiers à archiver ;
- trouver les journaux ou exports créés récemment.
Il faut garder à l’esprit que l’on parle ici de date de modification du contenu ou des métadonnées associées, telle qu’exploitée par ce test.
Cas pratiques de recherche par date
Voici plusieurs exemples concrets d’utilisation de -mtime.
1. Retrouver les fichiers texte modifiés récemment
```
find ~/test-find -type f -name "*.txt" -mtime -3
```
Pratique si vous avez travaillé sur des notes ou rapports récemment.
2. Repérer les anciens fichiers d’archive
```
find ~/test-find -type f -name "*.tar.gz" -mtime +30
```
Très utile avant un nettoyage ou un déplacement vers un support d’archivage.
3. Lister les images modifiées récemment
```
find ~/test-find -type f -iname "*.jpg" -mtime -7
```
Permet d’identifier des photos importées ou retravaillées dans la semaine récente.
4. Détecter de vieux fichiers volumineux
```
find ~ -type f -size +100M -mtime +90
```
Cette combinaison est particulièrement intéressante pour repérer de gros fichiers anciens qui prennent de la place sans avoir été modifiés depuis longtemps.
Ce type de commande est souvent plus utile qu’une simple recherche par nom, car il permet de filtrer selon votre activité récente ou vos habitudes de stockage.
Combiner plusieurs critères dans une seule commande
L’une des grandes forces de find est la possibilité de combiner plusieurs critères dans une seule recherche. Dans beaucoup de cas, cela évite de trier manuellement une longue liste de résultats.
Exemple classique : chercher des fichiers texte modifiés récemment :
```
find ~/test-find -type f -name "*.txt" -mtime -7
```
Ici, tous les critères doivent être satisfaits :
- être un fichier ;
- avoir un nom finissant par .txt ;
- avoir été modifié récemment selon la valeur donnée.
Autre exemple : chercher de grosses archives anciennes :
```
find ~/test-find -type f -name "*.tar.gz" -size +100M -mtime +30
```
Cette commande est très réaliste pour un dossier de sauvegardes ou d’exports.
Encore un exemple pratique : rechercher les grosses images récemment modifiées :
```
find ~/test-find -type f -iname "*.jpg" -size +5M -mtime -14
```
Quand vous combinez les critères, pensez toujours à formuler votre besoin comme une phrase simple :
Je cherche des fichiers JPEG, de plus de 5 M, modifiés il y a moins de 14 jours.
Ensuite, traduisez chaque morceau en option find. Cette méthode aide beaucoup à construire des commandes correctes, même quand on débute.
Choisir le bon point de départ pour éviter des recherches trop larges
Une erreur fréquente consiste à lancer find depuis un emplacement trop large, par exemple tout le système, alors qu’une recherche ciblée suffirait.
Comparez :
```
find / -name "*.log"
```
et :
```
find ~/test-find -name "*.log"
```
Dans le premier cas, la commande part de la racine / et tente de parcourir l’ensemble du système de fichiers accessible. Cela peut produire beaucoup de résultats, prendre plus de temps, et générer des messages d’erreur liés aux permissions.
Dans le second cas, la recherche est limitée à un répertoire précis, donc plus rapide et plus lisible.
Bonnes pratiques pour le point de départ :
- si vous cherchez dans vos documents, partez de ~/Documents ou d’un sous-dossier pertinent ;
- si vous cherchez une image importée, partez de votre dossier d’images ;
- si vous cherchez un journal d’application, partez du répertoire concerné si vous le connaissez.
Exemples :
```
find ~/Documents -type f -name "*.pdf"
```
```
find ~/Images -type f -size +10M
```
```
find ~/test-find/documents -type f -mtime -2
```
Plus le point de départ est précis, plus la commande est efficace et facile à interpréter.
Lire et interpréter les résultats renvoyés par find
Par défaut, find affiche les chemins des éléments correspondants, un par ligne. Il est important de bien comprendre ce que vous lisez.
Par exemple :
```
find ~/test-find -type f -name "*.txt"
```
Peut produire quelque chose comme :
```
/home/utilisateur/test-find/documents/rapport.txt
/home/utilisateur/test-find/documents/notes.txt
```
Chaque ligne représente un chemin complet depuis le point de départ ou un chemin résolu par le système selon l’environnement utilisé.
Ce résultat vous donne immédiatement plusieurs informations :
- le dossier où se trouve le fichier ;
- le nom exact du fichier ;
- la présence éventuelle de plusieurs fichiers portant un nom similaire dans des dossiers différents.
Si aucun résultat ne s’affiche, cela signifie simplement qu’aucun élément ne correspond aux critères donnés, ou que le chemin de départ ne contient pas ce que vous cherchez.
Lorsque des messages d’erreur apparaissent en plus des résultats, ils concernent souvent les permissions de certains dossiers. Nous reviendrons sur ce point dans la section dédiée aux erreurs courantes.
Exemples pratiques du quotidien
Cette section regroupe des recettes simples que vous pouvez réutiliser immédiatement.
Retrouver un fichier dont vous connaissez le nom approximatif
```
find ~ -type f -iname "*facture*"
```
Utile pour retrouver un document administratif ou une pièce jointe téléchargée.
Trouver tous les fichiers PDF dans vos documents
```
find ~/Documents -type f -name "*.pdf"
```
Repérer les gros fichiers qui encombrent votre dossier personnel
```
find ~ -type f -size +500M
```
Retrouver les fichiers modifiés dans la semaine
```
find ~ -type f -mtime -7
```
Chercher les archives anciennes
```
find ~ -type f -name "*.zip" -mtime +60
```
Combiner nom, taille et date
```
find ~ -type f -name "*.log" -size +10M -mtime -2
```
Cette commande permet par exemple d’identifier de gros fichiers journaux récents.
Rechercher un dossier précis
```
find ~ -type d -name "projets"
```
Cette fois, on cible explicitement un répertoire plutôt qu’un fichier.
L’idée n’est pas de mémoriser toutes les commandes, mais de reconnaître les blocs réutilisables :
- -type f pour les fichiers ;
- -type d pour les dossiers ;
- -name ou -iname pour le nom ;
- -size pour la taille ;
- -mtime pour la date de modification.
Adopter une méthode simple pour construire vos commandes
Quand on débute, le plus difficile n’est pas d’exécuter une commande déjà prête, mais d’en écrire une nouvelle à partir d’un besoin personnel. Pour y arriver sans se tromper, utilisez cette méthode en quatre étapes.
1. Définir le point de départ
Où la recherche doit-elle commencer ?
```
find ~/Documents
```
2. Définir le type d’élément
Cherchez-vous des fichiers ou des dossiers ?
```
find ~/Documents -type f
```
3. Ajouter le critère principal
Nom, taille ou date ?
```
find ~/Documents -type f -name "*.pdf"
```
4. Ajouter des filtres complémentaires si nécessaire
```
find ~/Documents -type f -name "*.pdf" -mtime -30
```
En procédant ainsi, vous avancez par couches successives. Si la commande ne renvoie rien, vous pouvez retirer un critère pour voir lequel est trop restrictif.
Par exemple, si ceci ne donne aucun résultat :
```
find ~/Documents -type f -name "*.pdf" -size +20M -mtime -7
```
testez d’abord :
```
find ~/Documents -type f -name "*.pdf"
```
Puis ajoutez la taille, puis la date. Cette démarche rend l’apprentissage beaucoup plus naturel.

Erreurs fréquentes & dépannage

Erreurs et difficultés courantes

1. Oublier les guillemets autour des motifs

Évitez d’écrire :

find ~/test-find -name *.txt

Préférez :

find ~/test-find -name "*.txt"

Les guillemets empêchent l’expansion prématurée du motif par le shell.

2. Confondre fichier et dossier

Si vous cherchez un fichier, ajoutez -type f. Si vous cherchez un répertoire, utilisez -type d.

3. Chercher depuis un répertoire trop large

Une recherche depuis / peut être lente et produire des erreurs de permissions. Ciblez un dossier plus précis si possible.

4. Ne pas tenir compte de la casse

Avec -name, Photo.jpg et photo.jpg sont différents. Si vous avez un doute, utilisez -iname.

5. Mal interpréter + et - pour la taille ou la date

+valeur signifie plus que, -valeur signifie moins que. Une valeur sans signe correspond à une recherche stricte selon le test utilisé.

6. Voir des messages “Permission denied”

Cela signifie que certains répertoires ne sont pas lisibles par votre utilisateur. Ce n’est pas forcément un problème si la recherche utile porte surtout sur vos propres dossiers.

7. Ne rien obtenir en résultat

Vérifiez successivement : le chemin de départ, le nom recherché, la casse, le type d’élément et les filtres de taille ou de date. Souvent, un seul critère est trop restrictif.

Astuces & pour aller plus loin

Astuces pratiques

Commencez simple : testez d’abord -name seul, puis ajoutez -type, ensuite -size ou -mtime.
Travaillez dans un dossier de test : c’est idéal pour apprendre sans confusion.
Utilisez -iname si vous hésitez sur la casse : cela évite beaucoup d’échecs inutiles.
Formulez votre besoin en français avant d’écrire la commande : “je cherche des fichiers PDF de plus de 10 M modifiés récemment”. Ensuite, traduisez chaque morceau.
Réduisez la zone de recherche : cela rend les résultats plus rapides et plus pertinents.
Gardez quelques modèles sous la main : par exemple une commande pour les gros fichiers, une pour les fichiers récents, une pour les fichiers par extension.
Ajoutez progressivement les critères : si une commande ne retourne rien, retirez un filtre pour comprendre lequel bloque.

Questions fréquentes

Quelle est la différence entre -name et -iname ?

-name effectue une recherche sensible à la casse, tandis que -iname ignore les différences entre majuscules et minuscules.

Pourquoi faut-il mettre des guillemets autour de *.txt ?

Les guillemets évitent que le shell développe le motif avant l’exécution de find. Cela permet à find de traiter correctement l’expression telle que vous l’avez écrite.

Comment chercher uniquement des fichiers et pas des dossiers ?

Ajoutez le filtre -type f. Pour ne rechercher que des répertoires, utilisez -type d.

Comment trouver les fichiers de plus de 100M ?

Utilisez par exemple find ~ -type f -size +100M.

Comment retrouver les fichiers modifiés récemment ?

Vous pouvez utiliser un critère comme -mtime -7 pour cibler les fichiers modifiés il y a moins de quelques jours selon la valeur fournie.

Pourquoi find affiche-t-elle des erreurs de permission ?

Parce que certains dossiers ne sont pas lisibles par votre utilisateur. Cela arrive souvent lorsqu’on lance une recherche dans des zones système ou dans des répertoires appartenant à d’autres utilisateurs.

Peut-on combiner nom, taille et date ?

Oui. C’est même l’un des usages les plus utiles de find. Par exemple : find ~ -type f -name "*.log" -size +10M -mtime -2.

Conclusion

Vous avez maintenant une base solide pour utiliser find dans les cas les plus utiles du quotidien. En pratique, trois familles de filtres couvrent déjà beaucoup de besoins : -name ou -iname pour le nom, -size pour la taille et -mtime pour la date de modification.

La clé est de raisonner simplement : choisissez un point de départ pertinent, précisez si vous cherchez des fichiers ou des dossiers, puis ajoutez les critères qui correspondent à votre besoin réel.

Avec l’habitude, vous pourrez construire très vite des commandes comme : retrouver un document précis, lister les gros fichiers qui prennent de la place, ou identifier les fichiers récents dans une arborescence. Même en restant sur ces usages débutants, find devient rapidement un outil indispensable de la ligne de commande Linux.

Le plus efficace pour progresser est maintenant de pratiquer sur un petit répertoire de test, puis d’adapter les exemples à vos propres dossiers.