Linux commande find

Linux commande find

Notes

Rechercher

Exemple rechercher borg*.sh (borg1.sh, borg-hhhh.sh, etc…) dans tous les fichiers .md

Pour chercher dans tous les fichiers .md les occurrences de noms comme borg1.sh, borg-hhhh.sh ou borg_backup.sh, utilisez :

1
grep -rn --include='*.md' 'borg[^/[:space:]]*\.sh' .

Ici, --include='*.md' est un joker de nom de fichier ; le motif 'borg[^/[:space:]]*\.sh' est une expression régulière recherchée dans le contenu.[tutorialspoint][codemia]

Explication du motif

1
borg[^/[:space:]]*\.sh
  • borg : texte littéral borg.
  • [^/[:space:]]* : zéro ou plusieurs caractères qui ne sont ni / ni un espace ; cela couvre 1, -hhhh, _backup, etc.
  • \. : un point littéral, car . seul correspond à n’importe quel caractère en regex.[developers.redhat][d3s.mff.cuni]
  • sh : littéral sh.

Cela trouvera par exemple :

1
2
3
4
borg1.sh
borg-hhhh.sh
borg_backup.sh
./scripts/borg2.sh

Variantes utiles

Afficher seulement les fichiers .md concernés :

1
grep -rl --include='*.md' 'borg[^/[:space:]]*\.sh' .

Afficher fichier et numéro de ligne, sans recherche récursive dans .git :

1
grep -rn --include='*.md' --exclude-dir='.git' 'borg[^/[:space:]]*\.sh' .

Recherche stricte : borg, puis éventuellement un tiret, chiffre ou lettre, puis .sh :

1
grep -rnE --include='*.md' 'borg[-[:alnum:]]*\.sh' .

Avec -E, +, ?, | et {} s’utilisent sans antislash ; le point doit néanmoins rester échappé en \. pour désigner un point réel. [d3s.mff.cuni][github]

Avec find

Équivalent, pratique si vous voulez d’abord filtrer précisément les fichiers Markdown :

1
find . -type f -name '*.md' -print0 | xargs -0 grep -nE 'borg[-[:alnum:]]*\.sh'

find sélectionne les fichiers par leur nom avec le joker *.md, puis grep cherche dans leur contenu.[codemia][yuseokkang]

Attention : n’écrivez pas grep 'borg*.sh' si vous voulez une recherche fiable dans le contenu. En regex, * répète le caractère précédent ; il faut donc écrire .* pour « n’importe quels caractères », et échapper le point : borg.*\.sh.[d3s.mff.cuni][learn.microsoft]

Command find avec jokers *,``?, etc…

Avec find, les jokers (*, ?, []) s’utilisent surtout avec -name, -iname ou -path. Mettez toujours le motif entre guillemets pour éviter que le shell ne le développe avant l’exécution de find.[manpages.debian][blog.stephane-robert]

Syntaxe de base

1
find chemin -name "motif"

Exemples :

1
2
3
4
5
6
find . -name "*.log"          # tous les fichiers .log
find . -name "rapport*"       # commence par rapport
find . -name "*2026*"         # contient 2026
find . -name "fichier?.txt"   # fichier1.txt, fichierA.txt, etc.
find . -name "fichier[0-9].txt"
find . -iname "*.JPG"         # insensible à la casse
  • * : zéro, un ou plusieurs caractères.
  • ? : exactement un caractère.
  • [abc] : un seul caractère parmi a, b ou c.
  • [0-9] : un chiffre.
  • [!abc] ou [^abc] : un caractère qui n’est pas a, b ni c.

Ces motifs sont des globs du shell, pas des expressions régulières.[blog.stephane-robert][petermartin]

Casse et chemins

1
2
3
find . -iname "readme*"       # README.md, readme.txt, Readme...
find /var/log -name "*.log"
find . -path "*/src/*.c"      # motif appliqué au chemin complet

-name teste uniquement le nom de l’entrée, tandis que -path teste le chemin. Dans -path, / et . ne sont pas des métacaractères spéciaux.[manpages.debian][linux]

Échapper les jokers

Si vous n’utilisez pas de guillemets, le shell peut remplacer * par les fichiers du répertoire courant. Vous pouvez aussi l’échapper :

1
2
3
find . -name '*.c'
find . -name "*.c"
find . -name \*.c

Les trois formes passent bien *.c à find.[manpages.debian][linuxfr]

Combiner avec d’autres critères

1
2
3
4
5
6
7
8
9
10
11
12
# Fichiers .log modifiés depuis moins de 7 jours
find . -type f -name "*.log" -mtime -7

# Répertoires commençant par test
find . -type d -name "test*"

# Fichiers .tmp de plus de 100 Mo
find . -type f -name "*.tmp" -size +100M

# Supprimer les fichiers .bak (à vérifier avant !)
find . -type f -name "*.bak" -print
find . -type f -name "*.bak" -delete

-type f cible les fichiers ordinaires et -type d les répertoires.[blog.stephane-robert][blog.crea-troyes]

Pièges fréquents

  • find . -name *log peut échouer ou donner un résultat inattendu si le shell développe *log ; préférez find . -name "*log".[linuxfr]
  • -name "*.log" trouve aussi les fichiers cachés comme .secret.log, contrairement au comportement habituel de certains shells.[blog.stephane-robert][linux]
  • Pour une recherche par expression régulière, utilisez plutôt -regex ou -iregex, pas -name.[learning.lpi]

Syntaxe si la recherche se fait à l’intérieur des fichiers

Pour chercher dans le contenu des fichiers, utilisez grep, pas -name. La syntaxe générale est :

1
grep [options] "motif" fichiers_ou_dossier

grep recherche le motif dans chaque fichier indiqué et affiche les lignes correspondantes.[man.archlinux][man7]

Dans le répertoire courant

1
2
3
grep "erreur" *.log
grep -n "TODO" *.py
grep -i "warning" *.txt
  • *.log, *.py, etc. : jokers appliqués aux noms de fichiers par le shell.
  • -i : ignore la casse.
  • -n : affiche le numéro de ligne.
  • -l : affiche seulement les noms des fichiers contenant le motif.[tuteurs.ens][alexhost]

Récursivement dans un dossier

1
2
3
grep -r "motif" .
grep -rn "function" src/
grep -rli "mot de passe" .
  • -r : recherche dans le dossier et tous ses sous-dossiers.
  • -n : numéro de ligne.
  • -l : liste des fichiers concernés.[man7][gnu]

Limiter aux types de fichiers

Utilisez --include avec un motif de nom de fichier :

1
2
3
grep -r --include="*.py" "import" .
grep -r --include="*.log" --include="*.txt" "erreur" .
grep -r --exclude="*.min.js" "console.log" .

--include="*.py" restreint la recherche aux fichiers dont le nom correspond au glob ; --exclude fait l’inverse.[man.archlinux][man7][gnu]

Avec find puis grep

Utile quand vous voulez filtrer par nom, taille, date, etc., puis chercher dans le contenu :

1
find . -type f -name "*.log" -exec grep -n "erreur" {} +

Ou, variante robuste pour les noms contenant espaces ou caractères spéciaux :

1
find . -type f -name "*.log" -print0 | xargs -0 grep -n "erreur"

find sélectionne les fichiers ; grep effectue la recherche dans leur contenu.[math.u-bordeaux][alexhost]

Jokers : où les placer ?

Objectif Commande Les jokers concernent
Fichiers du répertoire courant grep "motif" *.log Noms de fichiers, développés par le shell
Arborescence entière grep -r --include="*.py" "motif" . Noms de fichiers, interprétés par grep
Sélection fine puis contenu find . -name "*.log" -exec grep "motif" {} + Noms de fichiers, interprétés par find
Motif texte lui-même grep "err.*2026" fichier.log Expression régulière dans le contenu

Pour un motif de contenu, * signifie « zéro ou plusieurs occurrences du caractère précédent » en expression régulière : par exemple "err.*2026" cherche err, puis n’importe quoi, puis 2026.[gnu]

Chercher une chaine complexe

find chercher une chaine complexe(séquence échappement) dans les fichiers d'un dossier avec récursivité, exclusion dossier et fichier
1
2
3
4
5
find /chemin/dossier \
  -type f \
  ! -path '/chemin/dossier/dossier_exclu/*' \
  ! -name 'fichier_exclu.ext' \
  -exec sh -c 'grep -nH --binary-files=without-match -- "SEQUENCE" "$@"' _ {} +

Remplace :

  • /chemin/dossier par ton dossier de départ
  • dossier_exclu par le (ou les) dossier(s) à exclure
  • fichier_exclu.ext par le (ou les) fichier(s) à exclure
  • SEQUENCE par ta chaîne

Exclure plusieurs dossiers :

1
2
3
4
find /chemin/dossier -type f \
  ! -path '/chemin/dossier/dossier1/*' \
  ! -path '/chemin/dossier/dossier2/*' \
  -exec sh -c 'grep -nH --binary-files=without-match -- "SEQUENCE" "$@"' _ {} +

Remplacer une chaîne par une autre

linux cli find comment remplacer la chaine ![]/images/ par ![](/images/%20et%20la%20chaine%20) par ) dans tous fichiers de type mdou txt à l’intérieur d’un dossier

Commande à exécuter sur Linux

1
Linux pc1 7.0.12-arch1-1 #1 SMP PREEMPT_DYNAMIC Wed, 10 Jun 2026 08:58:02 +0000 x86_64 GNU/Linux

Remplace /CHEMIN/DU/DOSSIER par le dossier cible

1
2
3
4
5
DOSSIER='/CHEMIN/DU/DOSSIER'
find $DOSSIER -type f \( -name '*.md' -o -name '*.txt' \) -print0 |
xargs -0 sed -i \
  -e 's/!\[\[/![]\/images\//g' \
  -e 's/\]\]/)/g'

Cette commande est récursive , dossier et sous- dossier
find /CHEMIN/DU/DOSSIER ... descend récursivement dans tous les sous-dossiers, et -type f ne traite que les fichiers réguliers .md et .txt

Exemple:

1
2
3
4
5
DOSSIER='/home/yann/media/Notes'
find $DOSSIER -type f \( -name '*.md' -o -name '*.txt' \) -print0 |
xargs -0 sed -i \
  -e 's/!\[\[/![]\/images\//g' \
  -e 's/\]\]/)/g'
linux find , chercher les derniers fichiers modifiés récursivement en excluant certains répertoires

Pour exclure tous les répertoires cachés (commençant par un .), pas seulement des noms spécifiques :

Solution avec -name ".*"

1
2
3
4
find /chemin/racine \
  -type d -name ".*" -prune -o \
  -type f -printf '%T@ %p\n' \
  | sort -rn | head -20

Explication :

  • -type d -name ".*" -prune : coupe la descente dans tout répertoire dont le nom commence par un point (.git, .cache, .config, etc.)
  • Le reste fonctionne comme avant : liste les fichiers avec leur timestamp, trie par date décroissante, garde les 20 plus récents

Combiner avec d’autres exclusions (ex: node_modules)

1
2
3
4
find /chemin/racine \
  \( -type d -name ".*" -o -type d -name "node_modules" \) -prune -o \
  -type f -printf '%T@ %p\n' \
  | sort -rn | head -20

Version lisible (date + heure)

1
2
3
4
find /chemin/racine \
  -type d -name ".*" -prune -o \
  -type f -printf '%TY-%Tm-%Td %TH:%TM %p\n' \
  | sort -r | head -20

Attention au dossier racine lui-même

Si /chemin/racine commence lui-même par un point (par exemple tu lances la commande depuis ~/.config), cette règle l’exclurait aussi. Dans ce cas, précise le chemin absolu du dossier de départ plutôt que de faire find . depuis l’intérieur d’un dossier caché — ou utilise -mindepth 1 pour ne pas évaluer le point de départ :

1
2
3
4
find /chemin/racine -mindepth 1 \
  -type d -name ".*" -prune -o \
  -type f -printf '%T@ %p\n' \
  | sort -rn | head -20

Cette dernière version est la plus sûre en général.

avec fichier exclude.txt

Pour lire la liste des répertoires à exclure depuis un fichier exclude.txt (un motif par ligne, ex: node_modules, .git, vendor) :

Méthode 1 : construire dynamiquement les -name/-prune

1
2
3
4
5
find /chemin/racine \
  \( -type d -name ".*" \) -o \
  \( $(while read -r pattern; do printf '-name "%s" -o ' "$pattern"; done < exclude.txt | sed 's/ -o $//') \) -prune -o \
  -type f -printf '%T@ %p\n' \
  | sort -rn | head -20

C’est fragile (echappement, espaces). Plus robuste : script shell explicite.

Méthode 2 (recommandée) : construire un tableau d’arguments

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/bin/bash

EXCLUDE_ARGS=()
first=1
while IFS= read -r pattern; do
  [ -z "$pattern" ] && continue
  if [ $first -eq 1 ]; then
    EXCLUDE_ARGS+=(-name "$pattern")
    first=0
  else
    EXCLUDE_ARGS+=(-o -name "$pattern")
  fi
done < exclude.txt

find /chemin/racine \
  \( -type d \( "${EXCLUDE_ARGS[@]}" -o -name ".*" \) -prune \) -o \
  -type f -printf '%T@ %p\n' \
  | sort -rn | head -20

Contenu type de exclude.txt :

1
2
3
4
5
node_modules
vendor
target
build
dist

(pas besoin d’y mettre les dossiers cachés puisqu’ils sont déjà exclus via -name ".*")

Méthode 3 : plus simple avec grep -vFf en filtrant après coup

Si tu préfères filtrer les chemins après la recherche plutôt que de bidouiller -prune :

1
2
3
4
find /chemin/racine -type f -printf '%T@ %p\n' \
  | grep -vFf <(sed 's|^|/|' exclude.txt) \
  | grep -v '/\.[^/]*/' \
  | sort -rn | head -20

Ici exclude.txt contient des fragments de chemin (ex: /node_modules/, /vendor/), et grep -vFf élimine toute ligne contenant un de ces motifs. C’est moins performant (parcourt tout l’arbre avant de filtrer) mais beaucoup plus simple à écrire et maintenir.

Recommandation

Si exclude.txt est amené à évoluer souvent et que la liste est courte, je te conseille la méthode 3 (simple, lisible, facile à déboguer). Si tu veux de la performance sur un très gros arbre de fichiers (éviter de descendre dans les dossiers exclus), pars sur la méthode 2.

Veux-tu que je t’écrive un petit script complet et testable, avec gestion des espaces dans les noms de fichiers (-print0 / sort -z) ?