Bash array com espaços em elementos

Estou tentando construir uma matriz em bash dos nomes de arquivos da minha câmera:

FILES=(2011-09-04 21.43.02.jpg
2011-09-05 10.23.14.jpg
2011-09-09 12.31.16.jpg
2011-09-11 08.43.12.jpg)

Como você pode ver, há um espaço no meio de cada nome de arquivo.

Tentei colocar cada nome entre aspas e escapar do espaço com uma barra invertida, nenhuma das quais funciona.

Quando tento acessar os elementos da matriz, ele continua tratando o espaço como o elemento delimitador.

Como capturar corretamente os nomes de arquivos com um espaço dentro do nome?

Acho que o problema pode estar em parte na maneira como você está acessando os elementos. Se eu fizer um simples for elem in $FILES, encontro o mesmo problema que você. No entanto, se eu acessar a matriz por meio de seus índices, assim funcionará se eu adicionar os elementos numericamente ou com escapes:

for ((i = 0; i < ${#FILES[@]}; i++))
do
    echo "${FILES[$i]}"
done

Qualquer uma dessas declarações de $FILESdeve funcionar:

FILES=(2011-09-04\ 21.43.02.jpg
2011-09-05\ 10.23.14.jpg
2011-09-09\ 12.31.16.jpg
2011-09-11\ 08.43.12.jpg)

ou

FILES=("2011-09-04 21.43.02.jpg"
"2011-09-05 10.23.14.jpg"
"2011-09-09 12.31.16.jpg"
"2011-09-11 08.43.12.jpg")

ou

FILES[0]="2011-09-04 21.43.02.jpg"
FILES[1]="2011-09-05 10.23.14.jpg"
FILES[2]="2011-09-09 12.31.16.jpg"
FILES[3]="2011-09-11 08.43.12.jpg"

Deve haver algo errado com a maneira como você acessa os itens da matriz. Veja como é feito:

for elem in "${files[@]}"
...

Na página de manual do bash :

Qualquer elemento de uma matriz pode ser referenciado usando $ {name [subscript]}. ... Se subscrito for @ ou *, a palavra se expandirá para todos os membros do nome. Esses subscritos diferem apenas quando a palavra aparece entre aspas duplas. Se a palavra estiver entre aspas duplas, $ {name [*]} será expandida para uma única palavra com o valor de cada membro da matriz separado pelo primeiro caractere da variável especial IFS e $ {name [@]} expandirá cada elemento de nome para uma palavra separada .

Obviamente, você também deve usar aspas duplas ao acessar um único membro

cp "${files[0]}" /tmp

Você precisa usar o IFS para parar o espaço como delimitador de elemento.

FILES=("2011-09-04 21.43.02.jpg"
       "2011-09-05 10.23.14.jpg"
       "2011-09-09 12.31.16.jpg"
       "2011-09-11 08.43.12.jpg")
IFS=""
for jpg in ${FILES[*]}
do
    echo "${jpg}"
done

Se você deseja separar com base em. então faça IFS = "." Espero que ajude você :)

Concordo com os outros que é provável que você esteja acessando os elementos que são o problema. A citação dos nomes de arquivo na atribuição da matriz está correta:

FILES=(
  "2011-09-04 21.43.02.jpg"
  "2011-09-05 10.23.14.jpg"
  "2011-09-09 12.31.16.jpg"
  "2011-09-11 08.43.12.jpg"
)

for f in "${FILES[@]}"
do
  echo "$f"
done

O uso de aspas duplas em torno de qualquer matriz do formulário "${FILES[@]}"divide a matriz em uma palavra por elemento da matriz. Não faz nenhuma divisão de palavras além disso.

Usar "${FILES[*]}"também tem um significado especial, mas une os elementos da matriz ao primeiro caractere de $ IFS, resultando em uma palavra, que provavelmente não é o que você deseja.

Usando um valor simples ${array[@]}ou ${array[*]}assuntos, o resultado dessa expansão para uma maior divisão de palavras, resultará em palavras divididas em espaços (e qualquer outra coisa dentro $IFS) em vez de uma palavra por elemento da matriz.

Usar um loop for no estilo C também é bom e evita a preocupação com a divisão de palavras, se você não estiver claro:

for (( i = 0; i < ${#FILES[@]}; i++ ))
do
  echo "${FILES[$i]}"
done

Escapar funciona.

#!/bin/bash

FILES=(2011-09-04\ 21.43.02.jpg
2011-09-05\ 10.23.14.jpg
2011-09-09\ 12.31.16.jpg
2011-09-11\ 08.43.12.jpg)

echo ${FILES[0]}
echo ${FILES[1]}
echo ${FILES[2]}
echo ${FILES[3]}

Resultado:

$ ./test.sh
2011-09-04 21.43.02.jpg
2011-09-05 10.23.14.jpg
2011-09-09 12.31.16.jpg
2011-09-11 08.43.12.jpg

Citar as strings também produz a mesma saída.

Se você tivesse seu array assim: #! / Bin / bash

Unix[0]='Debian'
Unix[1]="Red Hat"
Unix[2]='Ubuntu'
Unix[3]='Suse'

for i in $(echo ${Unix[@]});
    do echo $i;
done

Você obteria:

Debian
Red
Hat
Ubuntu
Suse

Não sei por que, mas o loop divide os espaços e os coloca como um item individual, até você o envolve com aspas.

Para contornar isso, em vez de chamar os elementos da matriz, você chama os índices, que recebem a cadeia completa envolvida entre aspas. Deve estar entre aspas!

#!/bin/bash

Unix[0]='Debian'
Unix[1]='Red Hat'
Unix[2]='Ubuntu'
Unix[3]='Suse'

for i in $(echo ${!Unix[@]});
    do echo ${Unix[$i]};
done

Então você terá:

Debian
Red Hat
Ubuntu
Suse

Não é exatamente uma resposta para o problema de citação / escape da pergunta original, mas provavelmente algo que realmente teria sido mais útil para o op:

unset FILES
for f in 2011-*.jpg; do FILES+=("$f"); done
echo "${FILES[@]}"

Onde é claro que a expressão teria que ser adotada para o requisito específico (por exemplo, *.jpgpara todas ou 2001-09-11*.jpgapenas as figuras de um determinado dia).

Outra solução é usar um loop "while" em vez de um loop "for":

index=0
while [ ${index} -lt ${#Array[@]} ]
  do
     echo ${Array[${index}]}
     index=$(( $index + 1 ))
  done

Se você não está preso ao uso bash, o manuseio diferente dos espaços nos nomes dos arquivos é um dos benefícios da casca do peixe . Considere um diretório que contém dois arquivos: "a b.txt" e "b c.txt". Aqui está um palpite razoável ao processar uma lista de arquivos gerados a partir de outro comando bash, mas falha devido aos espaços nos nomes dos arquivos que você encontrou:

# bash
$ for f in $(ls *.txt); { echo $f; }
a
b.txt
b
c.txt

Com fish, a sintaxe é quase idêntica, mas o resultado é o que você esperaria:

# fish
for f in (ls *.txt); echo $f; end
a b.txt
b c.txt

Funciona de maneira diferente porque o peixe divide a saída dos comandos em novas linhas, não em espaços.

Se você tem um caso em que deseja dividir espaços em vez de novas linhas, fishhá uma sintaxe muito legível para isso:

for f in (ls *.txt | string split " "); echo $f; end

Eu costumava redefinir o valor e a reversão do IFS quando concluído.

# backup IFS value
O_IFS=$IFS

# reset IFS value
IFS=""

FILES=(
"2011-09-04 21.43.02.jpg"
"2011-09-05 10.23.14.jpg"
"2011-09-09 12.31.16.jpg"
"2011-09-11 08.43.12.jpg"
)

for file in ${FILES[@]}; do
    echo ${file}
done

# rollback IFS value
IFS=${O_IFS}

Possível saída do loop:

2011-09-04 21.43.02.jpg

2011-09-05 10.23.14.jpg

2011-09-09 12.31.16.jpg

2011-09-11 08.43.12.jpg