Wie durchlaufe ich die von find zurückgegebenen Dateinamen?

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

Wenn ich den obigen Code in der Bash-Shell ausführe, erhalte ich eine Zeichenfolge, die mehrere durch Leerzeichen getrennte Dateinamen enthält, keine Liste.

Natürlich kann ich sie weiter durch Leerzeichen trennen, um eine Liste zu erhalten, aber ich bin mir sicher, dass es einen besseren Weg gibt, dies zu tun.

Was ist der beste Weg, um die Ergebnisse eines findBefehls zu durchlaufen ?

TL; DR: Wenn Sie nur hier sind, um die richtigste Antwort zu erhalten, möchten Sie wahrscheinlich meine persönliche Präferenz find . -name '*.txt' -exec process {} \;(siehe unten in diesem Beitrag). Wenn Sie Zeit haben, lesen Sie den Rest durch, um verschiedene Möglichkeiten und die Probleme mit den meisten von ihnen zu sehen.

Die vollständige Antwort:

Der beste Weg hängt davon ab, was Sie tun möchten, aber hier sind einige Optionen. Solange keine Datei oder kein Ordner im Teilbaum Leerzeichen enthält, können Sie die Dateien einfach durchlaufen:

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

Etwas besser, schneiden Sie die temporäre Variable aus x:

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

Es ist viel besser zu globieren, wenn du kannst. White-Space-Safe für Dateien im aktuellen Verzeichnis:

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

Durch Aktivieren der globstarOption können Sie alle übereinstimmenden Dateien in diesem Verzeichnis und in allen Unterverzeichnissen globalisieren:

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

In einigen Fällen, z. B. wenn sich die Dateinamen bereits in einer Datei befinden, müssen Sie möglicherweise Folgendes verwenden 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

readkann sicher in Kombination mit verwendet findwerden, indem das Trennzeichen entsprechend eingestellt wird:

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

Für komplexere Suchvorgänge möchten Sie wahrscheinlich findentweder die -execOption oder Folgendes verwenden -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

findkann auch in das Verzeichnis jeder Datei kopiert werden, bevor ein Befehl mit -execdiranstelle von ausgeführt wird -exec, und kann interaktiv (Eingabeaufforderung vor Ausführung des Befehls für jede Datei) mit -okanstelle von -exec(oder -okdiranstelle von -execdir) erstellt werden.

*: Technisch gesehen führen beide findund xargs(standardmäßig) den Befehl mit so vielen Argumenten aus, wie sie in die Befehlszeile passen, so oft, bis alle Dateien durchlaufen sind. In der Praxis spielt es keine Rolle, ob Sie über eine sehr große Anzahl von Dateien verfügen. Wenn Sie die Länge überschreiten, diese jedoch alle in derselben Befehlszeile benötigen, finden Sie bei SOL einen anderen Weg.

Was auch immer Sie tun, verwenden Sie keine forSchleife :

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

Drei Gründe:

• Damit die for-Schleife überhaupt startet, findmuss sie vollständig ausgeführt werden.
• Wenn ein Dateiname ein Leerzeichen (einschließlich Leerzeichen, Tabulator oder Zeilenumbruch) enthält, wird er als zwei separate Namen behandelt.
• Obwohl dies jetzt unwahrscheinlich ist, können Sie Ihren Befehlszeilenpuffer überlaufen. Stellen Sie sich vor, Ihr Befehlszeilenpuffer enthält for32 KB und Ihre Schleife gibt 40 KB Text zurück. Die letzten 8 KB werden direkt von Ihrer forSchleife entfernt und Sie werden es nie erfahren.

Verwenden Sie immer ein while readKonstrukt:

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

Die Schleife wird ausgeführt, während der findBefehl ausgeführt wird. Außerdem funktioniert dieser Befehl auch dann, wenn ein Dateiname mit Leerzeichen zurückgegeben wird. Und Sie werden Ihren Befehlszeilenpuffer nicht überlaufen lassen.

Der -print0verwendet NULL als Dateitrennzeichen anstelle eines Zeilenumbruchs und -d $'\0'verwendet beim Lesen NULL als Trennzeichen.

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

Hinweis: Diese Methode und die (zweite) Methode von bmargulies können sicher mit Leerzeichen in den Datei- / Ordnernamen verwendet werden.

Um auch den - etwas exotischen - Fall von Zeilenumbrüchen in den behandelten Datei- / Ordnernamen zu haben, müssen Sie auf das -execPrädikat findwie folgt zurückgreifen :

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

Das {}ist der Platzhalter für das gefundene Objekt und \;wird zum Beenden des verwendet-exec Prädikats verwendet.

Und der Vollständigkeit halber möchte ich noch eine Variante hinzufügen - Sie müssen die * nix-Methoden wegen ihrer Vielseitigkeit lieben:

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

Dies würde die gedruckten Elemente mit einem \0Zeichen trennen , das meines Wissens in keinem der Dateisysteme in Datei- oder Ordnernamen zulässig ist, und sollte daher alle Grundlagen abdecken. xargsholt sie dann eins nach dem anderen ab ...

Dateinamen können Leerzeichen und sogar Steuerzeichen enthalten. Leerzeichen sind (Standard-) Trennzeichen für die Shell-Erweiterung in Bash und werden daher x=$(find . -name "*.txt")aus der Frage überhaupt nicht empfohlen. Wenn find einen Dateinamen mit Leerzeichen "the file.txt"erhält, erhalten Sie z. B. 2 getrennte Zeichenfolgen zur Verarbeitung, wenn Sie xin einer Schleife verarbeiten. Sie können dies verbessern, indem Sie das Trennzeichen (Bash- IFSVariable) ändern, z. B. in \r\n, Dateinamen können jedoch Steuerzeichen enthalten. Dies ist also keine (vollständig) sichere Methode.

Aus meiner Sicht gibt es zwei empfohlene (und sichere) Muster für die Verarbeitung von Dateien:

1. Verwenden Sie für die Erweiterung von Schleife und Dateinamen:

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. Verwenden Sie find-read-while & process substitution

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

Bemerkungen

zu Muster 1:

1. bash gibt das Suchmuster ("* .txt") zurück, wenn keine übereinstimmende Datei gefunden wird. Daher wird die zusätzliche Zeile "Weiter, wenn keine Datei vorhanden ist" benötigt. Siehe Bash-Handbuch, Dateinamenerweiterung
2. Die Shell-Option nullglobkann verwendet werden, um diese zusätzliche Zeile zu vermeiden.
3. "Wenn die failglobShell-Option festgelegt ist und keine Übereinstimmungen gefunden werden, wird eine Fehlermeldung gedruckt und der Befehl nicht ausgeführt." (aus dem obigen Bash-Handbuch)
4. Shell-Option globstar: "Wenn festgelegt, stimmt das in einem Dateinamenerweiterungskontext verwendete Muster '**' mit allen Dateien und null oder mehr Verzeichnissen und Unterverzeichnissen überein. Wenn dem Muster ein '/' folgt, stimmen nur Verzeichnisse und Unterverzeichnisse überein." sehen Bash Manual, Shopt Builtin
5. andere Optionen für die Dateinamen - Erweiterung: extglob, nocaseglob, dotglob& Shell - VariableGLOBIGNORE

zu Muster 2:

1. Dateinamen können Rohlingen, Tabulatoren, Leerzeichen, Zeilenumbrüche, ... zu verarbeiten Dateinamen in einer sicheren Art und Weise enthalten, findmit -print0verwendet wird: Dateiname wird mit allen Steuerzeichen gedruckt und mit NUL beendet. Siehe auch Gnu Findutils Manpage, Unsichere Behandlung von Dateinamen , sichere Behandlung von Dateinamen , ungewöhnliche Zeichen in Dateinamen . Siehe David A. Wheeler unten für eine detaillierte Diskussion dieses Themas.

2. Es gibt einige mögliche Muster, um Suchergebnisse in einer while-Schleife zu verarbeiten. Andere (Kevin, David W.) haben gezeigt, wie man das mit Rohren macht:

   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"

   Wenn Sie diesen Code ausprobieren, werden Sie files_foundfeststellen , dass er nicht funktioniert: ist immer "wahr" und der Code gibt immer "keine Dateien gefunden" aus. Grund ist: Jeder Befehl einer Pipeline wird in einer separaten Subshell ausgeführt, sodass die geänderte Variable in der Schleife (separate Subshell) die Variable im Haupt-Shell-Skript nicht ändert. Aus diesem Grund empfehle ich die Verwendung der Prozesssubstitution als "besseres", nützlicheres und allgemeineres Muster.
   Siehe Ich setze Variablen in einer Schleife, die sich in einer Pipeline befindet. Warum verschwinden sie ... (aus Gregs Bash-FAQ) für eine ausführliche Diskussion zu diesem Thema.

Zusätzliche Referenzen und Quellen:

• Gnu Bash Manual, Pattern Matching

• Dateinamen und Pfadnamen in Shell: Wie es richtig gemacht wird, David A. Wheeler

• Warum liest du keine Zeilen mit "für", Gregs Wiki?

• Warum sollten Sie die Ausgabe von ls (1), Gregs Wiki, nicht analysieren?

• Gnu Bash Manual, Prozessersetzung

(Aktualisiert, um @ Socowis hervorragende Geschwindigkeitsverbesserung einzuschließen)

Mit allen $SHELL, die es unterstützen (dash / zsh / bash ...):

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

Getan.

Ursprüngliche Antwort (kürzer, aber langsamer):

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

Sie können Ihre findAusgabe im Array speichern, wenn Sie die Ausgabe später wie folgt verwenden möchten:

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

Um nun jedes Element in einer neuen Zeile zu drucken, können Sie entweder eine forSchleifeniteration für alle Elemente des Arrays verwenden oder die printf-Anweisung verwenden.

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

oder

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

Sie können auch verwenden:

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

Dadurch wird jeder Dateiname in Newline gedruckt

Um die findAusgabe nur in Listenform zu drucken , können Sie eine der folgenden Methoden verwenden:

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

oder

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

Dadurch werden Fehlermeldungen entfernt und nur der Dateiname als Ausgabe in einer neuen Zeile angegeben.

Wenn Sie etwas mit den Dateinamen tun möchten, ist es gut, sie im Array zu speichern. Andernfalls müssen Sie diesen Speicherplatz nicht belegen, und Sie können die Ausgabe direkt ausdrucken find.

Wenn Sie davon ausgehen können, dass die Dateinamen keine Zeilenumbrüche enthalten, können Sie die Ausgabe findmit dem folgenden Befehl in ein Bash-Array einlesen :

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

Hinweis:

• -tbewirkt readarray, dass Zeilenumbrüche entfernt werden.
• Es funktioniert nicht, wenn readarrayes sich in einer Pipe befindet, daher die Prozessersetzung.
• readarray ist seit Bash 4 verfügbar.

Bash 4.4 und höher unterstützt auch den -dParameter zur Angabe des Trennzeichens. Die Verwendung des Nullzeichens anstelle von Zeilenumbruch zur Begrenzung der Dateinamen funktioniert auch in dem seltenen Fall, dass die Dateinamen Zeilenumbrüche enthalten:

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

readarraykann auch wie mapfilemit den gleichen Optionen aufgerufen werden .

Referenz: https://mywiki.wooledge.org/BashFAQ/005#Loading_lines_from_a_file_or_stream

Ich verwende gerne find, das zuerst der Variablen zugewiesen und IFS wie folgt auf eine neue Zeile umgeschaltet wird:

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

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

Nur für den Fall, dass Sie weitere Aktionen für denselben DATENSatz wiederholen möchten und feststellen möchten, dass die Suche auf Ihrem Server sehr langsam ist (hohe E / A-Auslastung).

Sie können die von zurückgegebenen Dateinamen findin ein Array wie folgt einfügen:

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

Jetzt können Sie einfach das Array durchlaufen, um auf einzelne Elemente zuzugreifen und mit ihnen zu tun, was Sie wollen.

Hinweis: Es ist ein Leerraum sicher.

basierend auf anderen Antworten und Kommentaren von @phk, mit fd # 3:
(was immer noch erlaubt, stdin innerhalb der Schleife zu verwenden)

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

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

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

Dadurch werden die Dateien aufgelistet und Details zu Attributen angegeben.

Wie wäre es, wenn Sie grep anstelle von find verwenden?

ls | grep .txt$ > out.txt

Jetzt können Sie diese Datei lesen und die Dateinamen liegen in Form einer Liste vor.