Làm thế nào để lặp qua tên tập tin được trả về bởi find?

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

nếu tôi chạy đoạn mã trên trong shell Bash, cái tôi nhận được là một chuỗi chứa một vài tên tệp được phân tách bằng khoảng trống, không phải là danh sách.

Tất nhiên, tôi có thể phân tách chúng thêm bằng cách để trống một danh sách, nhưng tôi chắc chắn có một cách tốt hơn để làm điều đó.

Vì vậy, cách tốt nhất để lặp qua các kết quả của một findlệnh là gì?

TL; DR: Nếu bạn chỉ ở đây để có câu trả lời đúng nhất, có lẽ bạn muốn sở thích cá nhân của tôi, find . -name '*.txt' -exec process {} \;(xem phần dưới của bài đăng này). Nếu bạn có thời gian, hãy đọc qua phần còn lại để xem một số cách khác nhau và các vấn đề với hầu hết chúng.

Câu trả lời đầy đủ:

Cách tốt nhất phụ thuộc vào những gì bạn muốn làm, nhưng đây là một vài lựa chọn. Miễn là không có tệp hoặc thư mục nào trong cây con có khoảng trắng trong tên của nó, bạn chỉ có thể lặp qua các tệp:

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

Tốt hơn một chút, cắt bỏ biến tạm thời x:

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

Nó là tốt hơn nhiều để toàn cầu khi bạn có thể. Không gian trắng an toàn cho các tệp trong thư mục hiện tại:

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

Bằng cách bật globstartùy chọn, bạn có thể toàn cầu hóa tất cả các tệp phù hợp trong thư mục này và tất cả các thư mục con:

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

Trong một số trường hợp, ví dụ: nếu tên tệp đã có trong một tệp, bạn có thể cần phải sử dụng 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

readcó thể được sử dụng an toàn kết hợp với findbằng cách đặt dấu phân cách phù hợp:

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

Đối với các tìm kiếm phức tạp hơn, có thể bạn sẽ muốn sử dụng find, với -exectùy chọn của nó hoặc với -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

findcũng có thể cd vào thư mục của mỗi tệp trước khi chạy lệnh bằng cách sử dụng -execdirthay vì -execvà có thể được thực hiện tương tác (nhắc trước khi chạy lệnh cho mỗi tệp) bằng cách sử dụng -okthay vì -exec(hoặc -okdirthay vì -execdir).

*: Về mặt kỹ thuật, cả hai findvà xargs(theo mặc định) sẽ chạy lệnh với càng nhiều đối số càng tốt trên dòng lệnh, bao nhiêu lần để vượt qua tất cả các tệp. Trong thực tế, trừ khi bạn có số lượng tệp rất lớn, điều đó sẽ không thành vấn đề và nếu bạn vượt quá độ dài nhưng cần tất cả chúng trên cùng một dòng lệnh, thì bạn sẽ tìm thấy một cách khác.

Dù bạn làm gì, đừng sử dụng forvòng lặp :

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

Ba lý do:

• Để vòng lặp for bắt đầu, findphải chạy đến khi hoàn thành.
• Nếu một tên tệp có bất kỳ khoảng trắng (bao gồm khoảng trắng, tab hoặc dòng mới) trong đó, nó sẽ được coi là hai tên riêng biệt.
• Mặc dù bây giờ không thể, bạn có thể vượt qua bộ đệm dòng lệnh của bạn. Hãy tưởng tượng nếu bộ đệm dòng lệnh của bạn giữ 32KB và forvòng lặp của bạn trả về 40KB văn bản. 8KB cuối cùng đó sẽ bị loại bỏ khỏi forvòng lặp của bạn và bạn sẽ không bao giờ biết điều đó.

Luôn sử dụng while readcấu trúc:

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

Vòng lặp sẽ thực thi trong khi findlệnh đang thực thi. Thêm vào đó, lệnh này sẽ hoạt động ngay cả khi tên tệp được trả về với khoảng trắng trong đó. Và, bạn sẽ không tràn bộ đệm dòng lệnh của bạn.

Các -print0sẽ sử dụng NULL như một tách tập tin thay vì một dòng mới và -d $'\0'sẽ sử dụng NULL như tách trong khi đọc.

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

Lưu ý: phương pháp này và phương thức (thứ hai) được hiển thị bởi bmargulies là an toàn để sử dụng với khoảng trắng trong tên tệp / thư mục.

Để có trường hợp - hơi kỳ lạ - của các dòng mới trong tên tệp / thư mục được bảo hiểm, bạn sẽ phải sử dụng đến -execvị từ findgiống như sau:

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

Các {} là giữ chỗ cho mục tìm thấy và \;được sử dụng để chấm dứt -execvị.

Và để hoàn thiện, hãy để tôi thêm một biến thể khác - bạn phải yêu thích các cách * nix vì tính linh hoạt của chúng:

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

Điều này sẽ phân tách các mục được in bằng một \0ký tự không được phép trong bất kỳ hệ thống tệp nào trong tên tệp hoặc thư mục, theo hiểu biết của tôi và do đó sẽ bao gồm tất cả các cơ sở. xargsnhặt chúng lên từng cái một ...

Tên tập tin có thể bao gồm không gian và thậm chí các nhân vật điều khiển. Dấu cách là dấu phân cách (mặc định) để mở rộng shell trong bash và kết quả là x=$(find . -name "*.txt")từ câu hỏi không được khuyến nghị. Nếu find nhận được một tên tệp có khoảng trắng, ví dụ: "the file.txt"bạn sẽ nhận được 2 chuỗi riêng biệt để xử lý, nếu bạn xử lý xtrong một vòng lặp. Bạn có thể cải thiện điều này bằng cách thay đổi dấu phân cách ( IFSbiến bash ) \r\n, nhưng tên tệp có thể bao gồm các ký tự điều khiển - vì vậy đây không phải là phương pháp an toàn (hoàn toàn).

Theo quan điểm của tôi, có 2 mẫu được đề xuất (và an toàn) để xử lý tệp:

1. Sử dụng để mở rộng vòng lặp & tên tệp:

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. Sử dụng thay thế find-read-while & process

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

Nhận xét

trên Mẫu 1:

1. bash trả về mẫu tìm kiếm ("* .txt") nếu không tìm thấy tệp phù hợp - vì vậy dòng bổ sung "tiếp tục, nếu tệp không tồn tại" là cần thiết. xem hướng dẫn Bash, mở rộng tên tệp
2. tùy chọn vỏ nullglob có thể được sử dụng để tránh dòng thêm này.
3. "Nếu failglob tùy chọn shell được đặt và không tìm thấy kết quả khớp, thông báo lỗi sẽ được in và lệnh không được thực thi." (từ Sổ tay Bash ở trên)
4. tùy chọn shell globstar: "Nếu được đặt, mẫu '**' được sử dụng trong ngữ cảnh mở rộng tên tệp sẽ khớp với tất cả các tệp và không hoặc nhiều thư mục và thư mục con. Nếu mẫu được theo sau bởi '/', chỉ các thư mục và thư mục con phù hợp." xem hướng dẫn sử dụng Bash, nội dung Shopt
5. lựa chọn khác cho việc mở rộng tên tập tin: extglob, nocaseglob, dotglobvà biến vỏGLOBIGNORE

trên Mẫu 2:

1. tên tập tin có thể chứa khoảng trống, tab, khoảng trống, dòng mới, ... để tên tập tin quá trình một cách an toàn, findvới -print0được sử dụng: tên tập tin được in với tất cả các ký tự điều khiển & chấm dứt với NUL. xem thêm Trang chủ Gnu Findutils, Xử lý tên tệp không an toàn , Xử lý tên tệp an toàn , các ký tự bất thường trong tên tệp . Xem David A. Wheeler dưới đây để thảo luận chi tiết về chủ đề này.

2. Có một số mẫu có thể để xử lý tìm kết quả trong một vòng lặp while. Những người khác (kevin, David W.) đã chỉ ra cách thực hiện việc này bằng cách sử dụng đường ống:

   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"

   Khi bạn thử đoạn mã này, bạn sẽ thấy rằng nó không hoạt động: files_foundluôn luôn là "đúng" và mã sẽ luôn lặp lại "không tìm thấy tệp". Lý do là: mỗi lệnh của một đường ống được thực thi trong một lớp con riêng biệt, vì vậy biến đã thay đổi bên trong vòng lặp (lớp con riêng biệt) không thay đổi biến trong tập lệnh shell chính. Đây là lý do tại sao tôi khuyên bạn nên sử dụng thay thế quy trình như là mô hình "tốt hơn", hữu ích hơn, tổng quát hơn.
   Xem tôi đặt các biến trong một vòng lặp trong một đường ống. Tại sao chúng biến mất ... (từ Câu hỏi thường gặp về Bash của Greg) cho một cuộc thảo luận chi tiết về chủ đề này.

Tài liệu tham khảo & nguồn bổ sung:

• Hướng dẫn sử dụng Gnu Bash, Kết hợp mẫu

• Tên tệp và tên đường dẫn trong Shell: Cách thực hiện chính xác, David A. Wheeler

• Tại sao bạn không đọc các dòng với "cho", Wiki của Greg

• Tại sao bạn không nên phân tích đầu ra của ls (1), Greg's Wiki

• Hướng dẫn sử dụng Gnu Bash, thay thế quy trình

(Được cập nhật để bao gồm cải thiện tốc độ thực thi của @ Socowi)

Với bất kỳ $SHELLhỗ trợ nào (dash / zsh / bash ...):

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

Làm xong.

Câu trả lời gốc (ngắn hơn, nhưng chậm hơn):

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

Bạn có thể lưu trữ findđầu ra của mình trong mảng nếu bạn muốn sử dụng đầu ra sau như:

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

Bây giờ để in từng phần tử trong dòng mới, bạn có thể sử dụng forvòng lặp lặp cho tất cả các phần tử của mảng hoặc bạn có thể sử dụng câu lệnh printf.

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

hoặc là

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

Bạn cũng có thể dùng:

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

Điều này sẽ in từng tên tệp trong dòng mới

Để chỉ in findđầu ra ở dạng danh sách, bạn có thể sử dụng một trong các cách sau:

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

hoặc là

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

Điều này sẽ loại bỏ các thông báo lỗi và chỉ cung cấp tên tệp là đầu ra trong dòng mới.

Nếu bạn muốn làm một cái gì đó với tên tệp, lưu trữ nó trong mảng là tốt, thì không cần phải tiêu tốn dung lượng đó và bạn có thể in trực tiếp đầu ra từ đó find.

Nếu bạn có thể giả sử tên tệp không chứa dòng mới, bạn có thể đọc đầu ra của findmột mảng Bash bằng lệnh sau:

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

Ghi chú:

• -tnguyên nhân readarrayđể tước dòng mới.
• Nó sẽ không hoạt động nếu readarraytrong một đường ống, do đó thay thế quá trình.
• readarray có sẵn kể từ Bash 4.

Bash 4.4 trở lên cũng hỗ trợ -dtham số để chỉ định dấu phân cách. Sử dụng ký tự null, thay vì dòng mới, để phân định tên tệp cũng hoạt động trong trường hợp hiếm hoi mà tên tệp chứa dòng mới:

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

readarraycũng có thể được gọi như mapfilevới các tùy chọn tương tự.

Tham khảo: https://mywiki.wooledge.org/BashFAQ/005#Loading_lines_from_a_file_or_stream

Tôi thích sử dụng find được gán đầu tiên cho biến và IFS chuyển sang dòng mới như sau:

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

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

Chỉ trong trường hợp bạn muốn lặp lại nhiều hành động hơn trên cùng một bộ DATA và tìm thấy rất chậm trên máy chủ của bạn (mức sử dụng cao I / 0)

Bạn có thể đặt tên tệp được trả về findvào một mảng như thế này:

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

Bây giờ bạn có thể chỉ cần lặp qua mảng để truy cập các mục riêng lẻ và làm bất cứ điều gì bạn muốn với chúng.

Lưu ý: Đó là không gian trắng an toàn.

dựa trên các câu trả lời và nhận xét khác của @phk, sử dụng fd # 3:
(vẫn cho phép sử dụng stdin bên trong vòng lặp)

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

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

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

Điều này sẽ liệt kê các tập tin và cung cấp chi tiết về các thuộc tính.

Nếu bạn sử dụng grep thay vì tìm thì sao?

ls | grep .txt$ > out.txt

Bây giờ bạn có thể đọc tệp này và tên tệp ở dạng danh sách.