find : rechercher des fichiers efficacement

Quand on administre des serveurs ou des environnements de dev avec des arborescences profondes, on doit souvent retrouver vite un log énorme, un script perdu ou un répertoire précis. find parcourt le système de fichiers en temps réel et permet de sélectionner des fichiers (nom, type, taille, date, permissions) puis d'agir dessus (afficher, auditer, exécuter une commande, nettoyer).

Ce que vous allez apprendre

• Cibler des fichiers par nom, type, taille, date, permissions
• Combiner des critères (AND/OR/NOT, parenthèses)
• Appliquer une action en sécurité (-print → puis -exec/-delete)

La commande find dans l'écosystème Linux

find fait partie des commandes de recherche et de traitement de fichiers sous Linux. Chaque outil a sa spécialité :

Commande	Spécialité	Quand l'utiliser
find	Rechercher des fichiers par attributs	Trouver par nom, taille, date, permissions
locate	Recherche ultra-rapide par nom	Quand la vitesse prime (base indexée)
grep	Rechercher dans le contenu	Trouver une chaîne dans des fichiers
which / whereis	Localiser des exécutables	Trouver où est installé un programme
xargs	Exécuter des commandes en masse	Passer les résultats de find à une commande
awk	Traiter des données tabulaires	Extraire/transformer des colonnes
sed	Éditer des fichiers en flux	Remplacer du texte, supprimer des lignes
cut	Extraire des colonnes	Découper par délimiteur ou position

Glissez pour voir

Combinaisons fréquentes :

# find + grep : chercher un motif dans certains fichiers
find /var/log -name '*.log' -exec grep -l "error" {} +

# find + xargs : traitement en masse (robuste avec espaces)
find . -name '*.tmp' -print0 | xargs -0 rm -f

# locate + grep : filtrer les résultats de locate
locate '*.conf' | grep nginx

Comprendre la commande find en 2 min

🧠 Modèle mental — Comment fonctionne find

find = Où chercher → Quoi garder → Quoi faire

Points clés

• find parcourt un dossier et tous ses sous-dossiers
• Il garde les fichiers qui matchent tes critères (nom, type, date, taille)
• Plusieurs critères = ET (les deux doivent matcher)
• Si tu utilises OU (-o), pense aux parenthèses
• Tu peux exécuter une commande sur les fichiers trouvés (-exec)
• Tu peux supprimer des fichiers (-delete) MAIS toujours vérifier avant avec -print

Règles d'or

1

Toujours tester avant d'utiliser des commandes destructrices Commence par -print, puis seulement ensuite -delete.

2

Gérer les noms "bizarres" Utilise les wildcards entre quote ou sans mais avec échappement. ex : '*.log' ou \*.log

Vocabulaire essentiel

-name '*.log'

Fichiers dont le nom correspond au motif

-type f / -type d

Fichier (f) ou dossier (d)

-mtime +7

Modifié il y a plus de 7 jours

-size +100M

Taille supérieure à 100 Mo

-maxdepth 2

Ne pas descendre plus de 2 niveaux

-print / -delete

Afficher les résultats / Supprimer

📚 Pour aller plus loin — 12 options avancées

-iname

Comme -name mais insensible à la casse

-path / -ipath

Pattern sur le chemin complet

-mmin -60

Modifié il y a moins de 60 minutes

-perm 644

Permissions exactes

-user / -group

Par propriétaire ou groupe

-prune

Exclure un sous-arbre

-xdev

Ne pas traverser les points de montage

-exec cmd {} \;

Exécuter pour chaque fichier

-exec cmd {} +

Exécuter en batch (plus rapide)

-ok cmd {} \;

Comme -exec avec confirmation

-printf FORMAT

Sortie formatée personnalisée

-quit

Arrêter au premier résultat

Contrairement à locate (index pré-calculé), find ne dépend pas d'une base : le résultat reflète l'état actuel du disque.

Syntaxe minimale

find [CHEMIN...] [FILTRES...] [ACTIONS...]

Les 3 parties d'une commande find

La commande find suit toujours la même logique en trois étapes :

Étape	Question	Exemples	Obligatoire ?
Où chercher	Dans quel dossier démarrer ?	/var/log, ., /home	⚠️ Implicite (défaut : .)
Quels résultats garder	Quels fichiers correspondent à mes critères ?	-name '*.log', -type f, -size +100M	❌ Non (par défaut : tout)
Quoi faire	Quelle action effectuer sur les résultats ?	-print, -delete, -exec rm {} +	❌ Non (par défaut : -print)

Glissez pour voir

Où chercher (optionnel) — C'est le point de départ. find va parcourir ce dossier et tous ses sous-dossiers récursivement. Si vous n'indiquez pas de chemin, c'est . qui sera utilisé (le répertoire courant).

Quels résultats garder (optionnel) — Ce sont les filtres. Si vous n'en mettez pas, find retourne tout. Vous pouvez combiner plusieurs critères : par défaut ils sont liés par ET (tous doivent correspondre).

Quoi faire (optionnel) — C'est l'action finale. Sans action explicite, find affiche simplement les chemins (-print). Pour des actions destructrices (-delete, -exec rm), testez toujours avec -print d'abord.

Les filtres : cibler précisément vos fichiers

Les filtres permettent de réduire les résultats aux fichiers qui vous intéressent. Voici les plus utilisés :

Filtre	Ce qu'il teste	Exemple
-name 'motif'	Nom du fichier (sensible à la casse)	-name '*.log'
-iname 'motif'	Nom du fichier (insensible à la casse)	-iname '*.LOG'

Glissez pour voir

⚠️ Toujours mettre le motif entre quotes : -name '*.log'. Sinon le shell interprète * avant find et vous obtenez des résultats inattendus.

Filtre	Ce qu'il teste	Exemple
-type f	Fichiers uniquement	-type f
-type d	Dossiers uniquement	-type d
-size +100M	Taille supérieure à 100 Mo	-size +100M
-size -1k	Taille inférieure à 1 Ko	-size -1k
-mtime -7	Modifié il y a moins de 7 jours	-mtime -7
-mtime +30	Modifié il y a plus de 30 jours	-mtime +30
-user alice	Appartient à l'utilisateur alice	-user alice
-perm 644	Permissions exactement 644	-perm 644
-perm -644	Au moins ces bits (lecture/écriture)	-perm -644
-perm /222	Au moins un bit d'écriture	-perm /222

Glissez pour voir

Note sur les tailles : k, M, G sont pratiques mais l'interprétation peut varier selon les implémentations de find. En cas de doute, testez.

Combiner les filtres — ET / OU / NON :

Par défaut, les filtres sont combinés avec ET (tous doivent correspondre) :

# Fichiers .log ET de plus de 10 Mo (les deux conditions)
find /var/log -type f -name '*.log' -size +10M

Astuce : ajoutez -type f pour ne matcher que les fichiers (évite le bruit des répertoires).

Pour utiliser OU, ajoutez -o et des parenthèses (échappées) :

# Fichiers .log OU .txt
find /var/log -type f \( -name '*.log' -o -name '*.txt' \)

Pourquoi \( et \) ? Le shell interprète les parenthèses nues. On les échappe (\( \)) ou on les met entre quotes ('(' ')').

Pour exclure par nom, utilisez ! ou -not :

# Tous les fichiers SAUF ceux commençant par .git
find . -type f ! -name '.git*'

⚠️ Attention : ceci n'exclut PAS le dossier .git/ du parcours ! Pour vraiment ignorer un dossier, utilisez -prune :

# Exclure le dossier .git de la recherche (correct)
find . -name .git -prune -o -type f -print

Les actions : que faire des fichiers trouvés ?

Une fois les fichiers filtrés, vous pouvez agir dessus :

Action	Ce qu'elle fait	Exemple
-print	Affiche le chemin (par défaut)	-print
-ls	Affiche en format ls -l	-ls
-delete	Supprime le fichier	-delete
-exec cmd {} \;	Exécute cmd sur chaque fichier	-exec chmod 644 {} \;
-exec cmd {} +	Exécute cmd avec tous les fichiers	-exec rm {} +

Glissez pour voir

Règle d'or : toujours prévisualiser avant de détruire

# ❌ DANGEREUX : supprime directement
find /tmp -name '*.tmp' -delete

# ✅ SÛR : prévisualiser d'abord
find /tmp -name '*.tmp' -print
# Vérifier la liste, puis seulement :
find /tmp -name '*.tmp' -delete

Alternative robuste (gère les espaces et caractères spéciaux dans les noms) :

find . -type f -name '*.tmp' -print0 | xargs -0 rm -f

-exec {} \; vs -exec {} + — La différence est importante :

• \; : lance une commande par fichier (lent si beaucoup de fichiers)
• + : regroupe les fichiers et lance une seule commande (rapide, recommandé)

# Lent : 1000 fichiers = 1000 appels à chmod
find . -type f -exec chmod 644 {} \;

# Rapide : 1000 fichiers = quelques appels à chmod
find . -type f -exec chmod 644 {} +

Contrôler le parcours : -depth et -prune

Par défaut, find parcourt l'arborescence de haut en bas. Deux options modifient ce comportement :

-depth — Traite le contenu d'un dossier avant le dossier lui-même :

# Sans -depth : /tmp est listé AVANT son contenu
find /tmp -type d

# Avec -depth : /tmp est listé APRÈS son contenu
find /tmp -depth -type d

C'est automatique avec -delete pour éviter de supprimer un dossier avant son contenu.

-prune — Stoppe la descente dans un dossier (utile pour exclure des répertoires) :

# Exclure le dossier node_modules de la recherche
find . -name 'node_modules' -prune -o -name '*.js' -print

# Exclure plusieurs dossiers
find . \( -name 'node_modules' -o -name '.git' \) -prune -o -type f -print

Comment lire -prune : "Si tu trouves ce dossier, ne descends pas dedans (-prune), sinon (-o) applique le reste."

Option	Effet	Cas d'usage
-depth	Traite enfants avant parents	Suppression récursive
-prune	N'entre pas dans le dossier	Exclure node_modules, .git
-maxdepth N	Limite la profondeur	find . -maxdepth 1 (niveau courant)
-mindepth N	Ignore les N premiers niveaux	find . -mindepth 2 (sous-dossiers)

Glissez pour voir

Exemples pratiques :

# Lister uniquement le contenu immédiat (pas de récursion)
find /var/log -maxdepth 1 -type f -name '*.log'

# Chercher à partir du 2e niveau (ignorer le dossier racine)
find . -mindepth 2 -type f -name '*.conf'

# Combiner les deux : chercher entre le niveau 2 et 4
find /home -mindepth 2 -maxdepth 4 -type d -name '.ssh'

# Supprimer des dossiers vides (depth nécessaire pour traiter enfants d'abord)
find /tmp -depth -type d -empty -delete

# Lister les fichiers du niveau courant uniquement (équivalent de ls)
find . -maxdepth 1 -type f

Erreurs typiques (et solutions)

Erreur	Cause	Solution
find -name *.log ne trouve rien	Le shell a interprété * avant find	Mettre entre quotes : -name '*.log'
-o ne fonctionne pas comme prévu	Priorité des opérateurs	Ajouter des parenthèses : \( ... -o ... \)
"J'ai exclu .git mais find cherche dedans"	! -name n'empêche pas la descente	Utiliser -prune : -name .git -prune -o ...
Résultats incluent des répertoires	Pas de filtre -type	Ajouter -type f pour les fichiers uniquement

Glissez pour voir

Les modèles de recherche courants

Maintenant que vous comprenez la logique de find, voici dix modèles prêts à l'emploi. Chacun donne sa formule générale et un exemple concret.

Recherche par nom exact

Trouver un fichier dont on connaît le nom précis.

find <chemin> -name "<nom>"       # formule
find /var/log -name "syslog"      # exemple

• chemin : point de départ de la recherche (défaut : .)
• nom : nom exact ou motif glob

Recherche par motif (glob)

Trouver des fichiers par extension ou motif.

find <chemin> -name "*.ext"   # formule
find . -name "*.log"          # exemple

• * : joker — n'importe quels caractères
• toujours entre guillemets, sinon le shell interprète le *

Filtrer par type

Restreindre aux fichiers, dossiers ou liens.

find <chemin> -type <f|d|l>          # formule
find /etc -type d -name "*.d"        # exemple

• f : fichier régulier — d : dossier — l : lien symbolique

Filtrer par taille

Trouver les gros fichiers ou les fichiers minuscules.

find <chemin> -type f -size <+|->N<c|k|M|G>   # formule
find /var/log -type f -size +100M             # exemple

• +/- : plus grand / plus petit que
• unités : c octets, k Ko, M Mo, G Go

Filtrer par date de modification

Trouver les fichiers récents ou anciens.

find <chemin> -mtime <+|->N         # formule
find /tmp -type f -mtime +30        # exemple

• +N : modifié il y a plus de N jours
• -N : modifié il y a moins de N jours

Exécuter une commande (-exec)

Lancer une commande pour chaque fichier trouvé.

find <chemin> <tests> -exec <cmd> {} \;     # formule
find . -name "*.bak" -exec rm {} \;         # exemple

• {} : remplacé par le nom du fichier
• \; : termine la commande (échappé)

Exécuter en lot (-exec +)

Passer plusieurs fichiers à une seule invocation de la commande — bien plus rapide.

find <chemin> <tests> -exec <cmd> {} +      # formule
find . -name "*.txt" -exec wc -l {} +       # exemple

• + : agrège les fichiers (comme xargs)

Pipeline sécurisé avec xargs -0

Traiter sans risque les noms contenant des espaces ou des caractères spéciaux.

find <chemin> <tests> -print0 | xargs -0 <cmd>            # formule
find . -name "*.pdf" -print0 | xargs -0 mv -t ~/backup/   # exemple

• -print0 : sépare les résultats par un caractère nul
• xargs -0 : lit ce même séparateur nul

Suppression sécurisée

Supprimer des fichiers seulement après avoir vérifié la liste.

find <chemin> <tests> -print          # étape 1 : visualiser
find <chemin> <tests> -delete         # étape 2 : supprimer

• Jamais -delete sans avoir lancé -print d'abord.

Exclure un dossier (-prune)

Ignorer certains sous-dossiers pendant la recherche.

find <chemin> -path "*/<dossier>" -prune -o <tests> -print          # formule
find . -path "./node_modules" -prune -o -name "*.js" -print         # exemple

• -prune : arrête la descente dans le dossier ciblé
• -o : applique les tests au reste de l'arborescence

Les pièges à éviter

Six erreurs reviennent constamment avec find. Certaines sont destructrices — -delete ne pardonne pas.

Recherche sensible à la casse

find . -name "Report.txt"   # ❌ ne trouve pas "report.txt"

Symptôme : la recherche ne renvoie rien alors que le fichier existe. Cause : -name distingue les majuscules des minuscules.

find . -iname "report.txt"   # ✅ -iname ignore la casse

Noms de fichiers avec espaces

find . -name "*.txt" | xargs rm   # ❌ casse sur "mon fichier.txt"

Symptôme : erreur No such file ou suppression des mauvais fichiers. Cause : xargs découpe sur les espaces.

find . -name "*.txt" -print0 | xargs -0 rm   # ✅ séparateur nul

OU sans parenthèses

find . -name "*.log" -o -name "*.txt" -mtime +7   # ❌ -mtime ne s'applique qu'aux .txt

Symptôme : -mtime ne filtre qu'une partie des résultats. Cause : la précédence des opérateurs groupe -mtime avec le second -name.

find . \( -name "*.log" -o -name "*.txt" \) -mtime +7   # ✅ parenthèses échappées

-delete sans vérification

find /var -name "*.tmp" -delete   # ❌ exécuté directement, sans contrôle

Symptôme : des fichiers importants supprimés par erreur. Cause : un motif trop large appliqué sans prévisualisation.

find /var -name "*.tmp" -print   # ✅ vérifier d'abord, puis remplacer -print par -delete

Confusion mtime / ctime / atime

find . -mtime -1   # ❌ ne reflète pas la « date de création »

Symptôme : des fichiers copiés apparaissent comme anciens. Cause : mtime est la date de modification du contenu — Linux n'a pas de « date de création ».

# ✅ -mtime = contenu, -ctime = métadonnées, -atime = dernier accès
find . -ctime -1

Regex au lieu de glob

find . -name ".*\.log$"   # ❌ ne renvoie rien

Symptôme : aucun résultat. Cause : -name utilise des globs (*, ?), pas des expressions régulières.

find . -regex ".*\.log$"   # ✅ -regex pour une vraie regex (ou simplement -name "*.log")

Travaux pratiques

Rien ne remplace la pratique. Créez l'environnement de test ci-dessous, puis déroulez les huit étapes. À la fin, nettoyez avec rm -rf ~/find-lab.

Préparer le terrain

Ce script crée une arborescence dans ~/find-lab avec des fichiers de tailles, dates et permissions variées — y compris des noms contenant des espaces.

# Créer le lab
mkdir -p ~/find-lab/{logs,config,data,backup}
cd ~/find-lab

# Fichiers logs de différentes tailles
dd if=/dev/zero of=logs/app.log bs=1M count=5 2>/dev/null
dd if=/dev/zero of=logs/error.log bs=1K count=100 2>/dev/null
dd if=/dev/zero of=logs/debug.log bs=1M count=20 2>/dev/null

# Fichiers config
echo "port=8080" > config/app.conf
echo "debug=true" > config/debug.conf

# Fichiers avec espaces dans le nom
touch "data/mon fichier.txt"
touch "data/rapport 2024.pdf"

# Fichiers avec des dates différentes
touch -d "30 days ago" backup/old-backup.tar
touch -d "7 days ago" backup/weekly.tar
touch backup/daily.tar

# Permissions variées
chmod 777 logs/debug.log
chmod 644 config/app.conf

echo "✅ Lab créé dans ~/find-lab"
ls -laR ~/find-lab

Les huit étapes

1. Trouver tous les fichiers .log. Listez tous les fichiers d'extension .log du lab.

   find ~/find-lab -name "*.log"

   -name utilise un motif glob ; * reconnaît n'importe quels caractères. Pour ignorer la casse : find ~/find-lab -iname "*.LOG".

2. Filtrer par taille. Trouvez les fichiers de plus de 1 Mo.

   find ~/find-lab -type f -size +1M

   +1M signifie « plus de 1 mégaoctet » — le + indique « supérieur à ».

3. Fichiers anciens. Trouvez les fichiers modifiés il y a plus de 7 jours.

   find ~/find-lab -type f -mtime +7

   +7 signifie « modifié il y a plus de 7 jours » ; -7 serait « moins de 7 jours ».

4. Combiner taille ET date. Trouvez les fichiers de plus de 1 Mo modifiés il y a moins de 1 jour.

   find ~/find-lab -type f -size +1M -mtime -1

   Par défaut, les critères se combinent en ET — inutile d'écrire -a.

5. Fichiers .log OU .conf. Trouvez les fichiers .log ou .conf.

   find ~/find-lab \( -name "*.log" -o -name "*.conf" \)

   -o est le OU ; les parenthèses échappées (\( \)) groupent les conditions.

6. Exécuter une commande sur chaque fichier. Affichez la taille lisible de chaque .log.

   find ~/find-lab -name "*.log" -exec ls -lh {} \;

   {} est remplacé par le nom du fichier ; \; termine la commande. Version plus rapide : -exec ls -lh {} +.

7. Gérer les noms avec espaces. Listez en détail les fichiers du dossier data/.

   find ~/find-lab/data -type f -print0 | xargs -0 ls -la

   -print0 et xargs -0 utilisent le caractère nul : mon fichier.txt reste un seul argument.

8. Supprimer en sécurité. Supprimez les .tar de plus de 7 jours — visualisez d'abord, supprimez ensuite.

   # Étape 1 : visualiser
   find ~/find-lab/backup -name "*.tar" -mtime +7 -print
   # Étape 2 : une fois la liste vérifiée
   find ~/find-lab/backup -name "*.tar" -mtime +7 -delete

   Ne mettez jamais -delete sans avoir contrôlé la liste avec -print.

Exercices progressifs

Huit exercices pour valider votre maîtrise. Cherchez d'abord par vous-même, puis dépliez la solution pour vous corriger.

Niveau fondations

Exercice 1 — Trouver les fichiers .conf. Listez les fichiers .conf directement dans /etc, sans descendre dans les sous-dossiers. Indice : -maxdepth 1 limite la profondeur.

Voir la solution

find /etc -maxdepth 1 -name "*.conf"

-maxdepth 1 restreint la recherche au dossier de départ, sans récursion.

Exercice 2 — Fichiers vides. Trouvez tous les fichiers vides (0 octet) dans /tmp. Indice : il existe une option dédiée aux fichiers vides.

Voir la solution

find /tmp -type f -empty

-empty est plus lisible que -size 0 et fonctionne aussi pour les dossiers vides.

Exercice 3 — Fichiers récents. Trouvez les fichiers de votre dossier personnel modifiés dans les dernières 24 heures. Indice : -mtime avec un nombre négatif.

Voir la solution

find ~ -type f -mtime -1

-mtime -1 signifie « modifié il y a moins de 1 jour ».

Niveau composition

Exercice 4 — Taille et extension. Trouvez les fichiers .log de plus de 10 Mo dans /var/log. Indice : combinez -name et -size.

Voir la solution

find /var/log -type f -name "*.log" -size +10M

Les critères se combinent en ET par défaut — inutile d'écrire -a.

Exercice 5 — OU logique. Trouvez les fichiers .jpg ou .png dans ~/Images. Indice : -o avec des parenthèses échappées.

Voir la solution

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

Les parenthèses groupent le OU ; sans elles, la logique serait incorrecte.

Niveau industrialisation

Exercice 6 — Exécuter ls -lh sur les résultats. Affichez la taille lisible de chaque fichier de plus de 100 Mo dans /var. Indice : -exec avec ls -lh.

Voir la solution

find /var -type f -size +100M -exec ls -lh {} \;

{} est remplacé par chaque fichier trouvé ; \; termine la commande.

Exercice 7 — Pipeline xargs sécurisé. Comptez le nombre total de lignes de tous les fichiers .py d'un projet, même avec des espaces dans les noms. Indice : -print0 puis xargs -0.

Voir la solution

find . -name "*.py" -print0 | xargs -0 wc -l

-print0 et xargs -0 gèrent les noms avec espaces sans risque.

Niveau sécurité

Exercice 8 — Nettoyage sécurisé. Supprimez les fichiers .tmp de plus de 7 jours dans /tmp, en montrant d'abord ce qui sera supprimé. Indice : deux commandes — -print puis -delete.

Voir la solution

# Étape 1 : prévisualiser
find /tmp -name "*.tmp" -mtime +7 -print
# Étape 2 : une fois la liste vérifiée
find /tmp -name "*.tmp" -mtime +7 -delete

Toujours prévisualiser avec -print avant d'utiliser -delete.

Dépannage

Quand find ne renvoie pas ce qu'on attend, le problème vient le plus souvent du quoting ou des permissions. Voici comment diagnostiquer.

Méthodes de diagnostic

# Retirer les filtres un par un pour isoler le problème
find /chemin

# Ajouter -print explicite pour voir ce qui est traité
find /chemin -name "*.log" -print

# Vérifier le quoting (le shell peut interpréter * avant find)
find /chemin -name "*.log"

# Repérer les dossiers où find n'a pas les droits
find /chemin 2>&1 | grep -i permission

Erreurs fréquentes

Message d'erreur	Cause probable	Solution
find: '/root': Permission denied	Pas de droit de lecture sur le dossier	Utiliser sudo, ou masquer les erreurs : find /chemin 2>/dev/null
find: '/chemin': No such file or directory	Le chemin de départ n'existe pas	Vérifier le chemin avec ls, contrôler l'orthographe
find: missing argument to '-exec'	\; ou + oublié en fin de -exec	Terminer la commande : -exec ls -l {} \;

Glissez pour voir

Aide-mémoire find

Options de parcours

Option	Rôle	Exemple
-maxdepth N	Limite la profondeur de recherche	find . -maxdepth 2 -name "*.txt"
-mindepth N	Ignore les N premiers niveaux	find . -mindepth 1 -type d
-L	Suit les liens symboliques	find -L /opt -name "*.conf"
-xdev	Reste sur le même système de fichiers	find / -xdev -size +100M

Glissez pour voir

Filtres

Filtre	Rôle	Exemple
-name "*.ext"	Nom avec glob (sensible à la casse)	-name "*.log"
-iname "*.ext"	Nom avec glob (insensible à la casse)	-iname "*.JPG"
-type f / -type d	Fichiers / dossiers uniquement	-type f
-path "*pattern*"	Motif sur le chemin complet	-path "*/test/*"
-size +100M / -size -1k	Plus grand / plus petit que	-size +1G
-empty	Fichiers ou dossiers vides	-type f -empty
-mtime +7 / -mtime -1	Modifié il y a plus / moins de N jours	-mtime +30
-newer fichier	Plus récent qu'un fichier de référence	-newer ref.txt
-perm 644	Permissions exactes	-perm 755
-user bob	Appartient à un utilisateur	-user root

Glissez pour voir

Actions

Action	Rôle	Exemple
-print	Affiche le chemin (défaut)	-print
-print0	Affiche séparé par un caractère nul	-print0 | xargs -0
-exec cmd {} \;	Exécute la commande pour chaque fichier	-exec rm {} \;
-exec cmd {} +	Exécute la commande en lot	-exec ls {} +
-delete	Supprime les fichiers trouvés	-mtime +30 -delete

Glissez pour voir

Composition

Opérateur	Rôle	Exemple
-a	ET (implicite entre deux critères)	-name "*.log" -a -size +1M
-o	OU	-name "*.jpg" -o -name "*.png"
\( … \)	Groupement de conditions	\( -name "*.jpg" -o -name "*.png" \)
-prune	Exclut un sous-arbre du parcours	-path "./vendor" -prune

Glissez pour voir

Checklist de maîtrise

Vous maîtrisez find lorsque vous pouvez cocher chacun de ces points :

• Je sais utiliser -name et -iname
• Je sais filtrer par -type (f, d, l)
• Je sais utiliser -size avec +/- et les unités
• Je sais utiliser -mtime, -ctime, -atime
• Je sais combiner des critères avec -o et des parenthèses
• Je sais utiliser -exec {} \; et -exec {} +
• Je sais sécuriser un pipeline avec -print0 \| xargs -0
• Je sais sécuriser -delete en lançant -print d'abord
• Je sais exclure un dossier avec -prune
• Je sais diagnostiquer une recherche qui ne renvoie rien

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 find est un outil essentiel pour quiconque travaille régulièrement en ligne de commande. Grâce à sa souplesse et à sa richesse fonctionnelle, elle permet de retrouver, filtrer et manipuler efficacement des fichiers dans n’importe quelle arborescence. Que ce soit pour une recherche rapide, un nettoyage automatisé ou un audit de permissions, la maîtrise de find fait gagner un temps précieux et renforce la qualité de vos scripts et interventions système.

Articles qui pourraient vous intéresser

• grep : rechercher un motif dans le contenu des fichiers
• xargs : agir en masse sur les fichiers trouvés par find
• tar : archiver une sélection de fichiers
• Cron et Crontab : planifier un nettoyage automatique
• sudo et le principe de moindre privilège

FAQ - Questions Fréquemment Posées

Qu'est-ce que la commande find sous Linux ?

La commande find est un outil puissant permettant de rechercher des fichiers et des répertoires en temps réel sur un système Linux, selon des critères variés comme le nom, la taille, la date ou les permissions.

Quelle est la différence entre find et locate ?

La commande find recherche en temps réel dans le système de fichiers, tandis que locate utilise une base de données mise à jour périodiquement, ce qui le rend plus rapide mais moins précis pour des fichiers récents.

Quelle est la syntaxe générale de la commande find ?

La syntaxe générale est : find [chemin] [conditions] [actions]. Elle permet de spécifier le point de départ, les critères de recherche et les actions à exécuter.

Comment rechercher des fichiers par nom avec find ?

On utilise l'option -name pour rechercher par nom exact ou -iname pour ignorer la casse. Des jokers comme * ou ? permettent d'élargir la recherche.

Comment rechercher des fichiers par type avec find ?

L'option -type permet de filtrer selon le type de fichier : f pour les fichiers, d pour les répertoires, l pour les liens symboliques, entre autres.

Comment rechercher des fichiers par taille avec find ?

L'option -size permet de spécifier la taille avec des suffixes comme c (octets), k (Ko), M (Mo). On peut rechercher des fichiers plus grands (+) ou plus petits (-) qu'une certaine taille.

Quelles options permettent de rechercher par date avec find ?

Les options -mtime, -atime et -ctime permettent de rechercher selon la date de dernière modification, d'accès ou de changement de statut, exprimée en jours.

Comment rechercher par permissions avec find ?

L'option -perm permet de filtrer les fichiers selon leurs permissions Unix, en notation octale ou symbolique, avec des opérateurs pour indiquer des conditions strictes ou larges.

Comment rechercher par propriétaire ou groupe avec find ?

Les options -user et -group permettent de cibler les fichiers appartenant à un utilisateur ou un groupe spécifique.

Comment exécuter une commande sur les résultats de find ?

On utilise l'option -exec suivie de la commande et des accolades {}, terminée par \;. Cela permet d'exécuter automatiquement une action sur chaque fichier trouvé.

Que fait l'option -ok avec find ?

L'option -ok fonctionne comme -exec mais demande une confirmation utilisateur avant d'exécuter chaque commande, ce qui ajoute une sécurité supplémentaire.

Comment optimiser les recherches avec find ?

Des options comme -maxdepth, -mindepth et -prune permettent de limiter la profondeur de recherche ou d'exclure certains répertoires, améliorant ainsi la performance.

Pourquoi utiliser xargs avec find ?

xargs permet de traiter en bloc les résultats de find, ce qui est plus efficace que d'exécuter une commande pour chaque fichier individuellement.

Quelles sont les bonnes pratiques pour utiliser find en production ?

Il est recommandé de rediriger les erreurs, tester avec -print avant d'agir, protéger les motifs avec des guillemets, et préférer -ok ou xargs pour plus de sécurité et robustesse.

Quels types d'audits peut-on faire avec find ?

Find permet d'auditer des fichiers volumineux, des permissions trop permissives, des fichiers anciens ou non utilisés, et des fichiers sensibles comme ceux avec le bit SUID ou SGID.

×

📖 Voir la documentation →