Como percorrer os nomes de arquivos retornados pelo find?

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

se eu executar o código acima no shell Bash, o que eu recebo é uma string contendo vários nomes de arquivos separados por branco, não uma lista.

Claro, posso separá-los ainda mais em branco para obter uma lista, mas tenho certeza de que há uma maneira melhor de fazê-lo.

Então, qual é a melhor maneira de percorrer os resultados de um findcomando?

TL; DR: Se você está aqui apenas para obter a resposta mais correta, provavelmente deseja minha preferência pessoal find . -name '*.txt' -exec process {} \;(veja a parte inferior desta postagem). Se você tiver tempo, leia o restante para ver várias maneiras diferentes e os problemas com a maioria delas.

A resposta completa:

A melhor maneira depende do que você deseja fazer, mas aqui estão algumas opções. Contanto que nenhum arquivo ou pasta na subárvore tenha um espaço em branco em seu nome, você pode simplesmente fazer um loop sobre os arquivos:

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

Marginalmente melhor, corte a variável temporária x:

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

É muito melhor glob quando puder. Cofre em espaço em branco, para arquivos no diretório atual:

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

Ao ativar a globstaropção, você pode enviar todos os arquivos correspondentes neste diretório e todos os subdiretórios:

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

Em alguns casos, por exemplo, se os nomes dos arquivos já estiverem em um arquivo, você pode precisar usar 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

readpode ser usado com segurança em combinação com a findconfiguração apropriada do delimitador:

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

Para pesquisas mais complexas, você provavelmente desejará usar find, com sua -execopção ou com -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

findtambém pode cd no diretório de cada arquivo antes de executar um comando usando em -execdirvez de -exece pode ser interativo (prompt antes de executar o comando para cada arquivo) usando em -okvez de -exec(ou em -okdirvez de -execdir).

*: Tecnicamente, ambos finde xargs(por padrão) executarão o comando com o maior número possível de argumentos na linha de comando, quantas vezes forem necessárias para passar por todos os arquivos. Na prática, a menos que você tenha um número muito grande de arquivos, isso não importará e, se você exceder o comprimento, mas precisar de todos na mesma linha de comando, o SOL encontrará uma maneira diferente.

O que quer que você faça, não use um forloop :

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

Três razões:

• Para que o loop for seja iniciado, é findnecessário executar até a conclusão.
• Se um nome de arquivo tiver algum espaço em branco (incluindo espaço, tabulação ou nova linha), ele será tratado como dois nomes separados.
• Embora agora seja improvável, você pode exceder o buffer da linha de comando. Imagine se o buffer da linha de comando tiver 32 KB e o forloop retornar 40 KB de texto. Os últimos 8 KB serão eliminados do seu forloop e você nunca saberá.

Sempre use uma while readconstrução:

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

O loop será executado enquanto o findcomando estiver em execução. Além disso, este comando funcionará mesmo se um nome de arquivo for retornado com espaço em branco. E você não sobrecarregará seu buffer de linha de comando.

Ele -print0usará o NULL como um separador de arquivos em vez de uma nova linha e o -d $'\0'NULL como o separador durante a leitura.

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

Nota: este método e o (segundo) método mostrado por bmargulies são seguros para uso com espaço em branco nos nomes de arquivos / pastas.

Para ter também o caso - um tanto exótico - de novas linhas nos nomes de arquivos / pastas, você precisará recorrer ao -execpredicado findcomo este:

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

O {}é o espaço reservado para o item encontrado e \;é usado para finalizar o -execpredicado.

E por uma questão de perfeição, deixe-me acrescentar outra variante - você precisa amar as maneiras * nix por sua versatilidade:

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

Isso separaria os itens impressos com um \0caractere que não é permitido em nenhum dos sistemas de arquivos nos nomes de arquivos ou pastas, que eu saiba e, portanto, deve cobrir todas as bases. xargspega-os um por um, então ...

Os nomes de arquivos podem incluir espaços e até controlar caracteres. Os espaços são delimitadores (padrão) para expansão de shell no bash e, como resultado disso, x=$(find . -name "*.txt")a pergunta não é recomendada. Se find obtiver um nome de arquivo com espaços, por exemplo, "the file.txt"você receberá 2 strings separadas para processamento, se você processar xem um loop. Você pode melhorar isso alterando delimitador (bash IFSVariable), por exemplo \r\n, para , mas os nomes de arquivos podem incluir caracteres de controle - portanto, este não é um método (completamente) seguro.

Do meu ponto de vista, existem 2 padrões recomendados (e seguros) para o processamento de arquivos:

1. Use para expansão de loop e nome de arquivo:

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. Use a busca / leitura / enquanto substitui o processo

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

Observações

no padrão 1:

1. bash retorna o padrão de pesquisa ("* .txt") se nenhum arquivo correspondente for encontrado - portanto, a linha extra "continuar, se o arquivo não existir" será necessária. consulte Manual do Bash, Expansão do nome do arquivo
2. A opção shell nullglobpode ser usada para evitar essa linha extra.
3. "Se a failglobopção shell estiver definida e nenhuma correspondência for encontrada, uma mensagem de erro será impressa e o comando não será executado." (do Bash Manual acima)
4. opção de shell globstar: "Se definido, o padrão '**' usado em um contexto de expansão de nome de arquivo corresponderá a todos os arquivos e zero ou mais diretórios e subdiretórios. Se o padrão for seguido por um '/', apenas diretórios e subdiretórios corresponderão." consulte o Manual do Bash, Shopt Builtin
5. outras opções para a expansão filename: extglob, nocaseglob, dotglob& variável shellGLOBIGNORE

no padrão 2:

1. os nomes de arquivos podem conter espaços em branco, tabulações, espaços, novas linhas, ... para processar os nomes de arquivos de maneira segura, findsendo -print0utilizados: o nome do arquivo é impresso com todos os caracteres de controle e finalizado com NUL. consulte também Página de manual do Gnu Findutils, tratamento inseguro de nomes de arquivos , tratamento seguro de nomes de arquivos , caracteres incomuns nos nomes de arquivos . Veja David A. Wheeler abaixo para uma discussão detalhada sobre este tópico.

2. Existem alguns padrões possíveis para processar resultados de busca em um loop while. Outros (Kevin, David W.) mostraram como fazer isso usando pipes:

   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"

   Ao tentar esse trecho de código, você verá que ele não funciona: files_foundé sempre "verdadeiro" e o código sempre ecoará "nenhum arquivo encontrado". A razão é: cada comando de um pipeline é executado em um subshell separado, portanto, a variável alterada dentro do loop (subshell separado) não altera a variável no script de shell principal. É por isso que recomendo usar a substituição de processo como o padrão "melhor", mais útil e mais geral.
   Consulte Eu defino variáveis ​​em um loop que está em um pipeline. Por que eles desaparecem ... (nas Perguntas frequentes sobre o Greg's Bash) para uma discussão detalhada sobre esse tópico.

Referências e fontes adicionais:

• Manual do Gnu Bash, correspondência de padrões

• Nomes de arquivos e nomes de caminhos no Shell: Como fazer isso corretamente, David A. Wheeler

• Por que você não lê linhas com "for", Greg's Wiki

• Por que você não deve analisar a saída de ls (1), Greg's Wiki

• Gnu Bash Manual, Substituição de Processo

(Atualizado para incluir a excelente melhoria de velocidade da @ Socowi)

Com qualquer um $SHELLque o suporte (dash / zsh / bash ...):

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

Feito.

Resposta original (mais curta, mas mais lenta):

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

Você pode armazenar sua findsaída em array se desejar usá-la posteriormente como:

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

Agora, para imprimir cada elemento na nova linha, você pode usar fora iteração de loop para todos os elementos da matriz ou usar a instrução printf.

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

ou

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

Você também pode usar:

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

Isso imprimirá cada nome de arquivo em nova linha

Para imprimir apenas a findsaída no formato de lista, você pode usar um dos seguintes:

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

ou

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

Isso removerá as mensagens de erro e fornecerá apenas o nome do arquivo como saída em nova linha.

Se você deseja fazer algo com os nomes de arquivo, armazená-lo em matriz é bom; caso contrário, não há necessidade de consumir esse espaço e você pode imprimir diretamente a saída find.

Se você pode assumir que os nomes dos arquivos não contêm novas linhas, você pode ler a saída findem uma matriz Bash usando o seguinte comando:

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

Nota:

• -tcausas readarraypara descartar novas linhas.
• Não funcionará se readarrayestiver em um pipe, daí a substituição do processo.
• readarray está disponível desde o Bash 4.

O Bash 4.4 ou superior também suporta o -dparâmetro para especificar o delimitador. O uso do caractere nulo, em vez de nova linha, para delimitar os nomes de arquivo também funciona nos raros casos em que os nomes de arquivo contêm novas linhas:

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

readarraytambém pode ser chamado como mapfilecom as mesmas opções.

Referência: https://mywiki.wooledge.org/BashFAQ/005#Loading_lines_from_a_file_or_stream

Eu gosto de usar o find, que é atribuído primeiro à variável e o IFS mudou para a nova linha da seguinte maneira:

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

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

Apenas no caso de você desejar repetir mais ações no mesmo conjunto de dados e encontrar muito lento no seu servidor (alta utilização de I / 0)

Você pode colocar os nomes de arquivos retornados por findem uma matriz como esta:

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

Agora você pode simplesmente percorrer a matriz para acessar itens individuais e fazer o que quiser com eles.

Nota: É um espaço em branco seguro.

baseado em outras respostas e comentários do @phk, usando o fd # 3:
(que ainda permite usar stdin dentro do loop)

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

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

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

Isso listará os arquivos e fornecerá detalhes sobre os atributos.

Que tal se você usar grep em vez de encontrar?

ls | grep .txt$ > out.txt

Agora você pode ler este arquivo e os nomes dos arquivos estão na forma de uma lista.