Como posso escapar do espaço em branco em uma lista de loop bash?

Eu tenho um script de shell bash que percorre todos os diretórios filho (mas não arquivos) de um determinado diretório. O problema é que alguns dos nomes de diretório contêm espaços.

Aqui está o conteúdo do meu diretório de teste:

$ls -F test
Baltimore/  Cherry Hill/  Edison/  New York City/  Philadelphia/  cities.txt

E o código que percorre os diretórios:

for f in `find test/* -type d`; do
  echo $f
done

Aqui está a saída:

teste / Baltimore
teste / cereja
Colina
teste / Edison 
teste / novo
Iorque
Cidade
test / Filadélfia

Cherry Hill e New York City são tratadas como 2 ou 3 entradas separadas.

Tentei citar os nomes de arquivos, assim:

for f in `find test/* -type d | sed -e 's/^/\"/' | sed -e 's/$/\"/'`; do
  echo $f
done

mas sem sucesso.

Deve haver uma maneira simples de fazer isso.

As respostas abaixo são ótimas. Mas para tornar isso mais complicado - nem sempre quero usar os diretórios listados no meu diretório de teste. Às vezes, quero passar os nomes de diretório como parâmetros da linha de comando.

Peguei a sugestão de Charles de definir o IFS e criei o seguinte:

dirlist="${@}"
(
  [[ -z "$dirlist" ]] && dirlist=`find test -mindepth 1 -type d` && IFS=$'\n'
  for d in $dirlist; do
    echo $d
  done
)

e isso funciona bem, a menos que haja espaços nos argumentos da linha de comando (mesmo que esses argumentos sejam citados). Por exemplo, chamar o script assim: test.sh "Cherry Hill" "New York City"produz a seguinte saída:

cereja
Colina
Novo
Iorque
Cidade

Primeiro, não faça dessa maneira. A melhor abordagem é usar find -execcorretamente:

# this is safe
find test -type d -exec echo '{}' +

A outra abordagem segura é usar a lista terminada por NUL, embora isso exija que você encontre suporte -print0:

# this is safe
while IFS= read -r -d '' n; do
  printf '%q\n' "$n"
done < <(find test -mindepth 1 -type d -print0)

Você também pode preencher uma matriz de find e passar essa matriz mais tarde:

# this is safe
declare -a myarray
while IFS= read -r -d '' n; do
  myarray+=( "$n" )
done < <(find test -mindepth 1 -type d -print0)
printf '%q\n' "${myarray[@]}" # printf is an example; use it however you want

Se a sua descoberta não suportar -print0, o resultado será inseguro - o abaixo não se comportará como desejado se existirem arquivos contendo novas linhas em seus nomes (o que, sim, é legal):

# this is unsafe
while IFS= read -r n; do
  printf '%q\n' "$n"
done < <(find test -mindepth 1 -type d)

Se alguém não usar um dos itens acima, uma terceira abordagem (menos eficiente em termos de tempo e uso de memória, pois lê toda a saída do subprocesso antes de dividir palavras) é usar uma IFSvariável que não contém o caractere de espaço. Desative globbing ( set -f) para impedir que cadeias contendo caracteres globos, como [], *ou ?sejam expandidas:

# this is unsafe (but less unsafe than it would be without the following precautions)
(
 IFS=$'\n' # split only on newlines
 set -f    # disable globbing
 for n in $(find test -mindepth 1 -type d); do
   printf '%q\n' "$n"
 done
)

Finalmente, para o caso de parâmetro da linha de comando, você deve usar matrizes se o seu shell suportar (por exemplo, é ksh, bash ou zsh):

# this is safe
for d in "$@"; do
  printf '%s\n' "$d"
done

manterá a separação. Observe que a citação (e o uso de $@e não $*) é importante. As matrizes também podem ser preenchidas de outras maneiras, como expressões glob:

# this is safe
entries=( test/* )
for d in "${entries[@]}"; do
  printf '%s\n' "$d"
done

find . -type d | while read file; do echo $file; done

No entanto, não funciona se o nome do arquivo contiver novas linhas. A descrição acima é a única solução que eu sei quando você realmente deseja ter o nome do diretório em uma variável. Se você quiser apenas executar algum comando, use xargs.

find . -type d -print0 | xargs -0 echo 'The directory is: '

Aqui está uma solução simples que lida com guias e / ou espaços em branco no nome do arquivo. Se você precisar lidar com outros caracteres estranhos no nome do arquivo, como novas linhas, escolha outra resposta.

O diretório de teste

ls -F test
Baltimore/  Cherry Hill/  Edison/  New York City/  Philadelphia/  cities.txt

O código para entrar nos diretórios

find test -type d | while read f ; do
  echo "$f"
done

O nome do arquivo deve ser citado ( "$f") se usado como argumento. Sem aspas, os espaços atuam como separador de argumentos e vários argumentos são dados ao comando invocado.

E a saída:

test/Baltimore
test/Cherry Hill
test/Edison
test/New York City
test/Philadelphia

Isso é extremamente complicado no Unix padrão, e a maioria das soluções falha em novas linhas ou em algum outro personagem. No entanto, se você estiver usando o conjunto de ferramentas GNU, poderá explorar a findopção -print0e usarxargs com a opção correspondente -0(menos-zero). Existem dois caracteres que não podem aparecer em um nome de arquivo simples; essas são barras e NUL '\ 0'. Obviamente, a barra aparece nos nomes dos caminhos, portanto a solução GNU de usar um NUL '\ 0' para marcar o final do nome é engenhosa e à prova de idiotas.

Por que não colocar

IFS='\n'

na frente do comando for? Isso altera o separador de campos de <Espaço> <Guia> <Nova Linha> para apenas <Nova Linha>

find . -print0|while read -d $'\0' file; do echo "$file"; done

eu uso

SAVEIFS=$IFS
IFS=$(echo -en "\n\b")
for f in $( find "$1" -type d ! -path "$1" )
do
  echo $f
done
IFS=$SAVEIFS

Isso não seria suficiente?
Ideia retirada de http://www.cyberciti.biz/tips/handling-filenames-with-spaces-in-bash.html

Não armazene listas como strings; armazene-os como matrizes para evitar toda essa confusão de delimitadores. Aqui está um exemplo de script que irá operar em todos os subdiretórios de teste ou na lista fornecida em sua linha de comando:

#!/bin/bash
if [ $# -eq 0 ]; then
        # if no args supplies, build a list of subdirs of test/
        dirlist=() # start with empty list
        for f in test/*; do # for each item in test/ ...
                if [ -d "$f" ]; then # if it's a subdir...
                        dirlist=("${dirlist[@]}" "$f") # add it to the list
                fi
        done
else
        # if args were supplied, copy the list of args into dirlist
        dirlist=("$@")
fi
# now loop through dirlist, operating on each one
for dir in "${dirlist[@]}"; do
        printf "Directory: %s\n" "$dir"
done

Agora vamos tentar isso em um diretório de teste com uma ou duas curvas inseridas:

$ ls -F test
Baltimore/
Cherry Hill/
Edison/
New York City/
Philadelphia/
this is a dirname with quotes, lfs, escapes: "\''?'?\e\n\d/
this is a file, not a directory
$ ./test.sh 
Directory: test/Baltimore
Directory: test/Cherry Hill
Directory: test/Edison
Directory: test/New York City
Directory: test/Philadelphia
Directory: test/this is a dirname with quotes, lfs, escapes: "\''
'
\e\n\d
$ ./test.sh "Cherry Hill" "New York City"
Directory: Cherry Hill
Directory: New York City

Você pode usar o IFS (separador de campo interno) temporariamente usando:

OLD_IFS=$IFS     # Stores Default IFS
IFS=$'\n'        # Set it to line break
for f in `find test/* -type d`; do
    echo $f
done

$IFS=$OLD_IFS

ps se for apenas sobre o espaço na entrada, algumas aspas duplas funcionaram sem problemas para mim ...

read artist;

find "/mnt/2tb_USB_hard_disc/p_music/$artist" -type f -name *.mp3 -exec mpg123 '{}' \;

Para adicionar ao que Jonathan disse: use a -print0opção para findem conjunto com xargso seguinte:

find test/* -type d -print0 | xargs -0 command

Isso executará o comando commandcom os argumentos adequados; diretórios com espaços neles serão citados corretamente (ou seja, serão passados ​​como um argumento).

#!/bin/bash

dirtys=()

for folder in *
do    
 if [ -d "$folder" ]; then    
    dirtys=("${dirtys[@]}" "$folder")    
 fi    
done    

for dir in "${dirtys[@]}"    
do    
   for file in "$dir"/\*.mov   # <== *.mov
   do    
       #dir_e=`echo "$dir" | sed 's/[[:space:]]/\\\ /g'`   -- This line will replace each space into '\ '   
       out=`echo "$file" | sed 's/\(.*\)\/\(.*\)/\2/'`     # These two line code can be written in one line using multiple sed commands.    
       out=`echo "$out" | sed 's/[[:space:]]/_/g'`    
       #echo "ffmpeg -i $out_e -sameq -vcodec msmpeg4v2 -acodec pcm_u8 $dir_e/${out/%mov/avi}"    
       `ffmpeg -i "$file" -sameq -vcodec msmpeg4v2 -acodec pcm_u8 "$dir"/${out/%mov/avi}`    
   done    
done

O código acima irá converter arquivos .mov para .avi. Os arquivos .mov estão em pastas diferentes e os nomes das pastas têm espaços em branco . Meu script acima irá converter os arquivos .mov para o arquivo .avi na mesma pasta. Não sei se isso ajuda as pessoas.

Caso:

[sony@localhost shell_tutorial]$ ls
Chapter 01 - Introduction  Chapter 02 - Your First Shell Script
[sony@localhost shell_tutorial]$ cd Chapter\ 01\ -\ Introduction/
[sony@localhost Chapter 01 - Introduction]$ ls
0101 - About this Course.mov   0102 - Course Structure.mov
[sony@localhost Chapter 01 - Introduction]$ ./above_script
 ... successfully executed.
[sony@localhost Chapter 01 - Introduction]$ ls
0101_-_About_this_Course.avi  0102_-_Course_Structure.avi
0101 - About this Course.mov  0102 - Course Structure.mov
[sony@localhost Chapter 01 - Introduction]$ CHEERS!

Felicidades!

Também tinha que lidar com espaços em branco em nomes de caminho. O que finalmente fiz foi usar uma recursão e for item in /path/*:

function recursedir {
    local item
    for item in "${1%/}"/*
    do
        if [ -d "$item" ]
        then
            recursedir "$item"
        else
            command
        fi
    done
}

Converta a lista de arquivos em uma matriz Bash. Isso usa a abordagem de Matt McClure para retornar uma matriz de uma função Bash: http://notes-matthewlmcclure.blogspot.com/2009/12/return-array-from-bash-function-v-2.html O resultado é uma maneira para converter qualquer entrada com várias linhas em uma matriz Bash.

#!/bin/bash

# This is the command where we want to convert the output to an array.
# Output is: fileSize fileNameIncludingPath
multiLineCommand="find . -mindepth 1 -printf '%s %p\\n'"

# This eval converts the multi-line output of multiLineCommand to a
# Bash array. To convert stdin, remove: < <(eval "$multiLineCommand" )
eval "declare -a myArray=`( arr=(); while read -r line; do arr[${#arr[@]}]="$line"; done; declare -p arr | sed -e 's/^declare -a arr=//' ) < <(eval "$multiLineCommand" )`"

for f in "${myArray[@]}"
do
   echo "Element: $f"
done

Essa abordagem parece funcionar mesmo quando caracteres ruins estão presentes e é uma maneira geral de converter qualquer entrada em uma matriz Bash. A desvantagem é que, se a entrada for longa, você poderá exceder os limites de tamanho da linha de comando do Bash ou consumir grandes quantidades de memória.

As abordagens nas quais o loop que está trabalhando na lista também têm a lista em questão têm a desvantagem de que ler stdin não é fácil (como pedir entrada ao usuário) e o loop é um novo processo, então você pode estar se perguntando por que variáveis você definir dentro do loop não estará disponível depois que o loop terminar.

Também não gosto de configurar o IFS, ele pode atrapalhar outro código.

Bem, eu vejo muitas respostas complicadas. Eu não quero passar a saída do utilitário find ou escrever um loop, porque o find tem a opção "exec" para isso.

Meu problema era que eu queria mover todos os arquivos com extensão dbf para a pasta atual e alguns deles continham espaço em branco.

Eu lidei com isso assim:

 find . -name \*.dbf -print0 -exec mv '{}'  . ';'

Parece muito simples para mim

acabei de descobrir que existem algumas semelhanças entre a minha pergunta e a sua. Aparentemente, se você deseja passar argumentos para comandos

test.sh "Cherry Hill" "New York City"

para imprimi-los em ordem

for SOME_ARG in "$@"
do
    echo "$SOME_ARG";
done;

observe que o $ @ está entre aspas duplas, algumas notas aqui

Eu precisava do mesmo conceito para compactar sequencialmente vários diretórios ou arquivos de uma determinada pasta. Eu resolvi usar o awk para analisar a lista de ls e evitar o problema de espaço em branco no nome.

source="/xxx/xxx"
dest="/yyy/yyy"

n_max=`ls . | wc -l`

echo "Loop over items..."
i=1
while [ $i -le $n_max ];do
item=`ls . | awk 'NR=='$i'' `
echo "File selected for compression: $item"
tar -cvzf $dest/"$item".tar.gz "$item"
i=$(( i + 1 ))
done
echo "Done!!!"

O que você acha?

find Downloads -type f | while read file; do printf "%q\n" "$file"; done

Para mim, isso funciona, e é praticamente "limpo":

for f in "$(find ./test -type d)" ; do
  echo "$f"
done

Só tinha um problema de variante simples ... Converta arquivos de .flv digitados em .mp3 (bocejo).

for file in read `find . *.flv`; do ffmpeg -i ${file} -acodec copy ${file}.mp3;done

encontre recursivamente todos os arquivos flash do usuário do Macintosh e transforme-os em áudio (cópia, sem transcodificação) ... é como o descrito acima, observando que a leitura em vez de apenas 'para o arquivo ' escapará.