Comment parcourir les noms de fichiers renvoyés par find?

x=$(find . -name "*.txt")
echo $x

si j'exécute le morceau de code ci-dessus dans le shell Bash, ce que j'obtiens est une chaîne contenant plusieurs noms de fichiers séparés par des blancs, pas une liste.

Bien sûr, je peux les séparer davantage en blanc pour obtenir une liste, mais je suis sûr qu'il existe une meilleure façon de le faire.

Alors, quelle est la meilleure façon de parcourir les résultats d'une findcommande?

TL; DR: Si vous êtes juste ici pour la réponse la plus correcte, vous voulez probablement ma préférence personnelle find . -name '*.txt' -exec process {} \;(voir le bas de cet article). Si vous avez le temps, lisez le reste pour voir plusieurs façons différentes et les problèmes avec la plupart d'entre elles.

La réponse complète:

La meilleure façon dépend de ce que vous voulez faire, mais voici quelques options. Tant qu'aucun fichier ou dossier dans la sous-arborescence n'a d'espace dans son nom, vous pouvez simplement parcourir les fichiers:

for i in $x; do # Not recommended, will break on whitespace
    process "$i"
done

Un peu mieux, supprimez la variable temporaire x:

for i in $(find -name \*.txt); do # Not recommended, will break on whitespace
    process "$i"
done

Il est beaucoup mieux glob quand vous le pouvez. Sécuritaire pour les espaces blancs, pour les fichiers du répertoire courant:

for i in *.txt; do # Whitespace-safe but not recursive.
    process "$i"
done

En activant l' globstaroption, vous pouvez glober tous les fichiers correspondants dans ce répertoire et tous les sous-répertoires:

# Make sure globstar is enabled
shopt -s globstar
for i in **/*.txt; do # Whitespace-safe and recursive
    process "$i"
done

Dans certains cas, par exemple si les noms de fichiers sont déjà dans un fichier, vous devrez peut-être utiliser read:

# IFS= makes sure it doesn't trim leading and trailing whitespace
# -r prevents interpretation of \ escapes.
while IFS= read -r line; do # Whitespace-safe EXCEPT newlines
    process "$line"
done < filename

readpeut être utilisé en toute sécurité en combinaison avec finden définissant le délimiteur de manière appropriée:

find . -name '*.txt' -print0 | 
    while IFS= read -r -d '' line; do 
        process "$line"
    done

Pour des recherches plus complexes, vous voudrez probablement utiliser find, soit avec son -execoption, soit avec -print0 | xargs -0:

# execute `process` once for each file
find . -name \*.txt -exec process {} \;

# execute `process` once with all the files as arguments*:
find . -name \*.txt -exec process {} +

# using xargs*
find . -name \*.txt -print0 | xargs -0 process

# using xargs with arguments after each filename (implies one run per filename)
find . -name \*.txt -print0 | xargs -0 -I{} process {} argument

findpeut également se placer dans le répertoire de chaque fichier avant d'exécuter une commande en utilisant -execdirau lieu de -exec, et peut être rendu interactif (demander avant d'exécuter la commande pour chaque fichier) en utilisant -okau lieu de -exec(ou -okdirau lieu de -execdir).

*: Techniquement, les deux findet xargs(par défaut) exécuteront la commande avec autant d'arguments qu'ils peuvent tenir sur la ligne de commande, autant de fois qu'il faut pour parcourir tous les fichiers. En pratique, à moins que vous n'ayez un très grand nombre de fichiers, cela n'aura pas d'importance, et si vous dépassez la longueur mais que vous en avez tous besoin sur la même ligne de commande, vous êtes SOL trouver une manière différente.

Quoi que vous fassiez, n'utilisez pas de forboucle :

# Don't do this
for file in $(find . -name "*.txt")
do
    …code using "$file"
done

Trois raisons:

• Pour que la boucle for démarre même, l' findexécution doit se terminer.
• Si un nom de fichier contient un espace (y compris un espace, une tabulation ou une nouvelle ligne), il sera traité comme deux noms distincts.
• Bien que cela soit désormais peu probable, vous pouvez saturer votre mémoire tampon de ligne de commande. Imaginez si votre tampon de ligne de commande contient 32 Ko et que votre forboucle retourne 40 Ko de texte. Ces 8 derniers Ko seront supprimés de votre forboucle et vous ne le saurez jamais.

Utilisez toujours une while readconstruction:

find . -name "*.txt" -print0 | while read -d $'\0' file
do
    …code using "$file"
done

La boucle s'exécutera pendant l'exécution de la findcommande. De plus, cette commande fonctionnera même si un nom de fichier est retourné avec des espaces. Et, vous ne dépasserez pas votre mémoire tampon de ligne de commande.

Le -print0va utiliser le NULL comme séparateur de fichier au lieu d'une nouvelle ligne et le -d $'\0'va utiliser NULL comme séparateur lors de la lecture.

find . -name "*.txt"|while read fname; do
  echo "$fname"
done

Remarque: cette méthode et la (seconde) méthode montrées par bmargulies sont sûres à utiliser avec des espaces blancs dans les noms de fichiers / dossiers.

Afin de couvrir également le cas - quelque peu exotique - de nouvelles lignes dans les noms de fichiers / dossiers, vous devrez recourir au -execprédicat findcomme ceci:

find . -name '*.txt' -exec echo "{}" \;

L' {}est l'espace réservé pour l'élément trouvé et l' \;est utilisé pour mettre fin à la-exec prédicat.

Et par souci d'exhaustivité, permettez-moi d'ajouter une autre variante - vous devez aimer les façons * nix pour leur polyvalence:

find . -name '*.txt' -print0|xargs -0 -n 1 echo

Cela séparerait les éléments imprimés avec un \0caractère qui n'est autorisé dans aucun des systèmes de fichiers dans les noms de fichiers ou de dossiers, à ma connaissance, et devrait donc couvrir toutes les bases. xargsles ramasse un par un puis ...

Les noms de fichiers peuvent inclure des espaces et même des caractères de contrôle. Les espaces sont (par défaut) des délimiteurs pour l'expansion du shell dans bash et à la suite de cela x=$(find . -name "*.txt")de la question n'est pas recommandé du tout. Si find obtient un nom de fichier avec des espaces, par exemple, "the file.txt"vous obtiendrez 2 chaînes séparées pour le traitement, si vous traitez xen boucle. Vous pouvez améliorer cela en changeant le délimiteur ( IFSvariable bash ) par exemple en \r\n, mais les noms de fichiers peuvent inclure des caractères de contrôle - ce n'est donc pas une méthode (complètement) sûre.

De mon point de vue, il existe 2 modèles recommandés (et sûrs) pour le traitement des fichiers:

1. Utilisez pour l'extension de boucle et de nom de fichier:

for file in ./*.txt; do
    [[ ! -e $file ]] && continue  # continue, if file does not exist
    # single filename is in $file
    echo "$file"
    # your code here
done

2. Utilisez la recherche par lecture et la substitution de processus

while IFS= read -r -d '' file; do
    # single filename is in $file
    echo "$file"
    # your code here
done < <(find . -name "*.txt" -print0)

Remarques

sur le motif 1:

1. bash renvoie le modèle de recherche ("* .txt") si aucun fichier correspondant n'est trouvé - donc la ligne supplémentaire "continuer, si le fichier n'existe pas" est nécessaire. voir Bash Manual, Filename Expansion
2. L'option shell nullglobpeut être utilisée pour éviter cette ligne supplémentaire.
3. "Si l' failgloboption shell est définie et qu'aucune correspondance n'est trouvée, un message d'erreur est imprimé et la commande n'est pas exécutée." (extrait du manuel Bash ci-dessus)
4. option shell globstar: "S'il est défini, le modèle '**' utilisé dans un contexte d'extension de nom de fichier correspondra à tous les fichiers et à zéro ou plusieurs répertoires et sous-répertoires. Si le modèle est suivi d'un '/', seuls les répertoires et sous-répertoires correspondent." voir Bash Manual, Shopt Builtin
5. d' autres options pour l' expansion du nom de fichier: extglob, nocaseglob,dotglob & variable shellGLOBIGNORE

sur le motif 2:

1. les noms de fichiers peuvent contenir des blancs, des tabulations, des espaces, des retours à la ligne, ... pour traiter les noms de fichiers de manière sûre, findavec -print0est utilisé: le nom de fichier est imprimé avec tous les caractères de contrôle et terminé avec NUL. voir aussi la page de manuel de Gnu Findutils, la gestion non sécurisée des noms de fichiers , la gestion sûre des noms de fichiers , les caractères inhabituels dans les noms de fichiers . Voir David A. Wheeler ci-dessous pour une discussion détaillée de ce sujet.

2. Il existe certains modèles possibles pour traiter les résultats de la recherche dans une boucle while. D'autres (kevin, David W.) ont montré comment faire cela en utilisant des tuyaux:

   files_found=1 find . -name "*.txt" -print0 | while IFS= read -r -d '' file; do # single filename in $file echo "$file" files_found=0 # not working example # your code here done [[ $files_found -eq 0 ]] && echo "files found" || echo "no files found"

   Lorsque vous essayez ce morceau de code, vous verrez qu'il ne fonctionne pas: files_foundest toujours "vrai" et le code fera toujours écho "aucun fichier trouvé". La raison est: chaque commande d'un pipeline est exécutée dans un sous-shell séparé, donc la variable modifiée à l'intérieur de la boucle (sous-shell séparé) ne change pas la variable dans le script shell principal. C'est pourquoi je recommande d'utiliser la substitution de processus comme modèle "meilleur", plus utile et plus général.
   Voir Je place des variables dans une boucle qui est dans un pipeline. Pourquoi disparaissent-ils ... (de la FAQ de Greg's Bash) pour une discussion détaillée sur ce sujet.

Références et sources supplémentaires:

• Manuel Gnu Bash, Correspondance de motifs

• Noms de fichiers et chemins d'accès dans Shell: comment le faire correctement, David A. Wheeler

• Pourquoi vous ne lisez pas les lignes avec "pour", le wiki de Greg

• Pourquoi vous ne devriez pas analyser la sortie de ls (1), le wiki de Greg

• Manuel Gnu Bash, Substitution de processus

(Mis à jour pour inclure l'amélioration de la vitesse de l'excellent @ Socowi)

Avec tous ceux $SHELLqui le supportent (dash / zsh / bash ...):

find . -name "*.txt" -exec $SHELL -c '
    for i in "$@" ; do
        echo "$i"
    done
' {} +

Terminé.

Réponse originale (plus courte mais plus lente):

find . -name "*.txt" -exec $SHELL -c '
    echo "$0"
' {} \;

# Doesn't handle whitespace
for x in `find . -name "*.txt" -print`; do
  process_one $x
done

or

# Handles whitespace and newlines
find . -name "*.txt" -print0 | xargs -0 -n 1 process_one

Vous pouvez stocker votre findsortie dans un tableau si vous souhaitez utiliser la sortie ultérieurement comme:

array=($(find . -name "*.txt"))

Maintenant, pour imprimer chaque élément dans une nouvelle ligne, vous pouvez soit utiliser l' foritération en boucle pour tous les éléments du tableau, soit utiliser l'instruction printf.

for i in ${array[@]};do echo $i; done

ou

printf '%s\n' "${array[@]}"

Vous pouvez aussi utiliser:

for file in "`find . -name "*.txt"`"; do echo "$file"; done

Cela affichera chaque nom de fichier en nouvelle ligne

Pour imprimer uniquement la findsortie sous forme de liste, vous pouvez utiliser l'une des méthodes suivantes:

find . -name "*.txt" -print 2>/dev/null

ou

find . -name "*.txt" -print | grep -v 'Permission denied'

Cela supprimera les messages d'erreur et ne donnera que le nom de fichier en sortie dans la nouvelle ligne.

Si vous souhaitez faire quelque chose avec les noms de fichiers, le stocker dans un tableau est bon, sinon il n'est pas nécessaire de consommer cet espace et vous pouvez directement imprimer la sortie à partir de find .

Si vous pouvez supposer que les noms de fichiers ne contiennent pas de retours à la ligne, vous pouvez lire la sortie de finddans un tableau Bash à l'aide de la commande suivante:

readarray -t x < <(find . -name '*.txt')

Remarque:

• -tprovoque la readarraysuppression des sauts de ligne.
• Cela ne fonctionnera pas si readarrayest dans un tube, d'où la substitution de processus.
• readarray est disponible depuis Bash 4.

Bash 4.4 et versions ultérieures prennent également en charge le -dparamètre de spécification du délimiteur. L'utilisation du caractère nul, au lieu de la nouvelle ligne, pour délimiter les noms de fichiers fonctionne également dans les rares cas où les noms de fichiers contiennent des nouvelles lignes:

readarray -d '' x < <(find . -name '*.txt' -print0)

readarraypeut également être invoqué comme mapfileavec les mêmes options.

Référence: https://mywiki.wooledge.org/BashFAQ/005#Loading_lines_from_a_file_or_stream

J'aime utiliser find qui est d'abord affecté à une variable et IFS est passé à une nouvelle ligne comme suit:

FilesFound=$(find . -name "*.txt")

IFSbkp="$IFS"
IFS=$'\n'
counter=1;
for file in $FilesFound; do
    echo "${counter}: ${file}"
    let counter++;
done
IFS="$IFSbkp"

Juste au cas où vous voudriez répéter plus d'actions sur le même ensemble de DONNÉES et trouver est très lent sur votre serveur (utilisation I / 0 élevée)

Vous pouvez mettre les noms de fichiers renvoyés par finddans un tableau comme celui-ci:

array=()
while IFS=  read -r -d ''; do
    array+=("$REPLY")
done < <(find . -name '*.txt' -print0)

Maintenant, vous pouvez simplement parcourir le tableau pour accéder aux éléments individuels et faire ce que vous voulez avec eux.

Remarque: Il est sûr pour les espaces blancs.

basé sur d'autres réponses et commentaires de @phk, en utilisant fd # 3:
(qui permet toujours d'utiliser stdin à l'intérieur de la boucle)

while IFS= read -r f <&3; do
    echo "$f"

done 3< <(find . -iname "*filename*")

find <path> -xdev -type f -name *.txt -exec ls -l {} \;

Cela répertorie les fichiers et donne des détails sur les attributs.

Et si vous utilisiez grep au lieu de trouver?

ls | grep .txt$ > out.txt

Vous pouvez maintenant lire ce fichier et les noms de fichiers se présentent sous la forme d'une liste.