¿Cómo puedo escapar del espacio en blanco en una lista de bash loop?

Tengo un script de shell bash que recorre todos los directorios secundarios (pero no los archivos) de un determinado directorio. El problema es que algunos de los nombres de directorio contienen espacios.

Aquí están los contenidos de mi directorio de prueba:

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

Y el código que recorre los directorios:

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

Aquí está la salida:

prueba / Baltimore
prueba / cereza
colina
prueba / Edison 
prueba / nuevo
York
Ciudad
prueba / Filadelfia

Cherry Hill y la ciudad de Nueva York se tratan como 2 o 3 entradas separadas.

Intenté citar los nombres de archivo, así:

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

pero fue en vano.

Tiene que haber una manera simple de hacer esto.

Las respuestas a continuación son geniales. Pero para hacer esto más complicado, no siempre quiero usar los directorios que figuran en mi directorio de prueba. A veces quiero pasar los nombres de directorio como parámetros de línea de comandos.

Tomé la sugerencia de Charles de establecer el IFS y se me ocurrió lo siguiente:

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

y esto funciona bien a menos que haya espacios en los argumentos de la línea de comando (incluso si se citan esos argumentos). Por ejemplo, llamar al script de esta manera: test.sh "Cherry Hill" "New York City"produce el siguiente resultado:

Cereza
colina
Nuevo
York
Ciudad

Primero, no lo hagas así. El mejor enfoque es usar find -execadecuadamente:

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

El otro enfoque seguro es usar la lista terminada en NUL, aunque esto requiere que encuentre soporte -print0:

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

También puede llenar una matriz desde find y pasar esa matriz más 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

Si su búsqueda no es compatible -print0, su resultado no es seguro: lo siguiente no se comportará como se desea si existen archivos que contienen nuevas líneas en sus nombres (lo cual, sí, es legal):

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

Si uno no va a usar uno de los anteriores, un tercer enfoque (menos eficiente en términos de tiempo y uso de memoria, ya que lee toda la salida del subproceso antes de dividir las palabras) es usar una IFSvariable que no No contiene el carácter de espacio. Desactive globbing ( set -f) para evitar que las cadenas que contienen caracteres glob como [], *o ?se expandan:

# 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 el caso de los parámetros de la línea de comandos, debería usar matrices si su shell los admite (es decir, es ksh, bash o zsh):

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

mantendrá la separación. Tenga en cuenta que la cita (y el uso de en $@lugar de $*) es importante. Las matrices también se pueden completar de otras maneras, como las expresiones globales:

# 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

Sin embargo, no funciona si el nombre del archivo contiene nuevas líneas. Lo anterior es la única solución que conozco cuando realmente desea tener el nombre del directorio en una variable. Si solo quieres ejecutar algún comando, usa xargs.

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

Aquí hay una solución simple que maneja pestañas y / o espacios en blanco en el nombre del archivo. Si tiene que lidiar con otros caracteres extraños en el nombre del archivo como líneas nuevas, elija otra respuesta.

El directorio de prueba

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

El código para ir a los directorios.

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

El nombre del archivo debe ser entrecomillado ( "$f") si se usa como argumento. Sin comillas, los espacios actúan como separador de argumentos y se dan múltiples argumentos al comando invocado.

Y la salida:

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

Esto es extremadamente complicado en Unix estándar, y la mayoría de las soluciones funcionan con nuevas líneas o algún otro personaje. Sin embargo, si está utilizando el conjunto de herramientas GNU, puede explotar la findopción -print0y utilizarla xargscon la opción correspondiente -0(menos cero). Hay dos caracteres que no pueden aparecer en un nombre de archivo simple; esos son barra oblicua y NUL '\ 0'. Obviamente, la barra diagonal aparece en los nombres de ruta, por lo que la solución GNU de usar un NUL '\ 0' para marcar el final del nombre es ingeniosa y a prueba de tontos.

¿Por qué no simplemente poner

IFS='\n'

en frente del comando? Esto cambia el separador de campo de <Espacio> <Pestaña> <Nueva línea> a solo <Nueva línea>

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

yo suelo

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

¿No sería eso suficiente?
Idea tomada de http://www.cyberciti.biz/tips/handling-filenames-with-spaces-in-bash.html

No almacene listas como cadenas; guárdelos como matrices para evitar toda esta confusión del delimitador. Aquí hay un script de ejemplo que funcionará en todos los subdirectorios de prueba o en la lista provista en su línea 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

Ahora intentemos esto en un directorio de prueba con una curva o dos:

$ 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

Puede usar IFS (separador de campo interno) temporalmente 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 si solo se trata de espacio en la entrada, entonces algunas comillas dobles funcionaron sin problemas para mí ...

read artist;

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

Para agregar a lo que dijo Jonathan : use la -print0opción findjunto con xargslo siguiente:

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

Eso ejecutará el comando commandcon los argumentos adecuados; los directorios con espacios en ellos se citarán correctamente (es decir, se pasarán como un 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

El código anterior convertirá los archivos .mov a .avi. Los archivos .mov están en diferentes carpetas y los nombres de las carpetas también tienen espacios en blanco . Mi script anterior convertirá los archivos .mov a archivos .avi en la misma carpeta. No sé si les ayuda a los pueblos.

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!

¡Salud!

También tenía que tratar con espacios en blanco en los nombres de ruta. Lo que finalmente hice fue usar una recursión y for item in /path/*:

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

Convierta la lista de archivos en una matriz Bash. Utiliza el enfoque de Matt McClure para devolver una matriz de una función Bash: http://notes-matthewlmcclure.blogspot.com/2009/12/return-array-from-bash-function-v-2.html El resultado es un camino para convertir cualquier entrada de varias líneas en una 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

Este enfoque parece funcionar incluso cuando hay caracteres incorrectos, y es una forma general de convertir cualquier entrada a una matriz Bash. La desventaja es que si la entrada es larga, podría exceder los límites de tamaño de la línea de comandos de Bash o utilizar grandes cantidades de memoria.

Los enfoques en los que el ciclo que finalmente está funcionando en la lista también tiene la lista distribuida tienen la desventaja de que leer stdin no es fácil (como pedirle entrada al usuario), y el ciclo es un proceso nuevo, por lo que puede preguntarse por qué las variables que establezca dentro del bucle no estarán disponibles después de que finalice el bucle.

También no me gusta configurar IFS, puede estropear otro código.

Bueno, veo demasiadas respuestas complicadas. No quiero pasar la salida de la utilidad find o escribir un bucle, porque find tiene la opción "exec" para esto.

Mi problema era que quería mover todos los archivos con extensión dbf a la carpeta actual y algunos de ellos contenían espacios en blanco.

Lo abordé así:

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

Me parece muy simple

Acabo de descubrir que hay algunas similitudes entre mi pregunta y la tuya. Aparentemente si quieres pasar argumentos a comandos

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

para imprimirlos en orden

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

observe que $ @ está rodeado de comillas dobles, algunas notas aquí

Necesitaba el mismo concepto para comprimir secuencialmente varios directorios o archivos de una carpeta determinada. He resuelto usar awk para analizar la lista de ls y evitar el problema del espacio en blanco en el nombre.

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!!!"

¿Qué piensas?

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

Para mí esto funciona, y es bastante "limpio":

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

Acabo de tener un problema de variante simple ... Convertir archivos de .flv mecanografiado a .mp3 (bostezar).

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

encuentre de forma recursiva todos los archivos flash de usuario de Macintosh y conviértalos en audio (copia, sin transcodificación) ... es como en el momento anterior, señalando que la lectura en lugar de solo 'for file in ' se escapará.