Fare script BASH `per` gestire i nomi di file con spazi (o soluzione alternativa)

Mentre uso BASH da diversi anni, la mia esperienza con gli script BASH è relativamente limitata.

Il mio codice è come di seguito. Dovrebbe prendere l'intera struttura di directory dall'interno della directory corrente e replicarla in $OUTDIR.

for DIR in `find . -type d -printf "\"%P\"\040"`
do
  echo mkdir -p \"${OUTPATH}${DIR}\"        # Using echo for debug; working script will simply execute mkdir
  echo Created $DIR
done

Il problema è che ecco un esempio della mia struttura di file:

$ ls
Expect The Impossible-Stellar Kart
Five Iron Frenzy - Cheeses...
Five Score and Seven Years Ago-Relient K
Hello-After Edmund
I Will Go-Starfield
Learning to Breathe-Switchfoot
MMHMM-Relient K

Nota gli spazi: -S E foraccetta i parametri parola per parola, quindi l'output del mio script è simile al seguente:

Creating directory structure...
mkdir -p "/myfiles/multimedia/samjmusicmp3test/Learning"
Created Learning
mkdir -p "/myfiles/multimedia/samjmusicmp3test/to"
Created to
mkdir -p "/myfiles/multimedia/samjmusicmp3test/Breathe-Switchfoot"
Created Breathe-Switchfoot

Ma ne ho bisogno per prendere interi nomi di file (una riga alla volta) dall'output di find. Ho anche provato a findmettere virgolette doppie attorno a ciascun nome file. Ma questo non aiuta.

for DIR in `find . -type d -printf "\"%P\"\040"`

E output con questa linea modificata:

Creating directory structure...
mkdir -p "/myfiles/multimedia/samjmusicmp3test/"""
Created ""
mkdir -p "/myfiles/multimedia/samjmusicmp3test/"Learning"
Created "Learning
mkdir -p "/myfiles/multimedia/samjmusicmp3test/to"
Created to
mkdir -p "/myfiles/multimedia/samjmusicmp3test/Breathe-Switchfoot""
Created Breathe-Switchfoot"

Ora, ho bisogno di un modo per poter scorrere in questo modo, perché desidero anche eseguire un comando più complicato che coinvolge gstreamerogni file in una struttura simile seguente. Come dovrei farlo?

Modifica: ho bisogno di una struttura di codice che mi permetta di eseguire più righe di codice per ogni directory / file / loop. Scusa se non ero chiaro.

Soluzione: inizialmente ho provato:

find . -type d | while read DIR
do
  mkdir -p "${OUTPATH}${DIR}"
  echo Created $DIR
done

Questo ha funzionato bene per la maggior parte. Tuttavia, in seguito ho scoperto che, poiché la pipe risulta in esecuzione nel ciclo while in una subshell, tutte le variabili impostate nel ciclo non sono state successivamente disponibili, il che ha reso piuttosto difficile l'implementazione di un contatore di errori. La mia soluzione finale (da questa risposta su SO ):

while read DIR
do
  mkdir -p "${OUTPATH}${DIR}"
  echo Created $DIR
done < <(find . -type d)

Questo in seguito mi ha permesso di incrementare condizionalmente le variabili all'interno del ciclo che sarebbero rimaste disponibili più avanti nello script.

È necessario reindirizzare findin un whileciclo.

find ... | while read -r dir
do
    something with "$dir"
done

Inoltre, non sarà necessario utilizzare -printfin questo caso.

Puoi fare questa prova contro i file con nuove righe nei loro nomi, se lo desideri, usando un delimitatore nullbyte (che è l'unico carattere che non può apparire in un percorso file * nix):

find ... -print0 | while read -d '' -r dir
do
    something with "$dir"
done

Troverai anche l'utilizzo al $()posto dei backtick per essere più versatile e più facile. Possono essere nidificati molto più facilmente e la quotazione può essere eseguita molto più facilmente. Questo esempio inventato illustrerà questi punti:

echo "$(echo "$(echo "hello")")"

Prova a farlo con i backtick.

Vedi questa risposta che ho scritto qualche giorno fa per un esempio di uno script che gestisce i nomi dei file con spazi.

C'è un modo leggermente più contorto (ma più conciso) per ottenere ciò che stai cercando di fare:

find . -type d -print0 | xargs -0 -I {} mkdir -p ../theredir/{}

-print0dice a find di separare gli argomenti con un null; da -0 a xargs indica che si aspettano argomenti separati da null. Ciò significa che gestisce bene gli spazi.

-I {}dice a xargs di sostituire la stringa {}con il nome file. Questo implica anche che dovrebbe essere usato un solo nome di file per riga di comando (normalmente xargs ne riempirà quanti ne rientrano nella riga)

Il resto dovrebbe essere ovvio.

Il problema che stai riscontrando è che l'istruzione for sta rispondendo alla ricerca come argomenti separati. Il delimitatore di spazio. Devi usare la variabile IFS di bash per non dividere lo spazio.

Ecco un link che spiega come farlo.

La variabile interna IFS

Un modo per aggirare questo problema è cambiare la variabile IFS (Internal Field Separator) interna di Bash in modo che divida i campi con qualcosa di diverso dallo spazio bianco predefinito (spazio, tab, newline), in questo caso, una virgola.

#!/bin/bash
IFS=$';'

for I in `find -type d -printf \"%P\"\;`
do
   echo "== $I =="
done

Imposta la tua ricerca per generare il delimitatore di campo dopo% P e imposta l'IFS in modo appropriato. Ho scelto il punto e virgola poiché è molto improbabile trovarlo nei nomi dei file.

L'altra alternativa è quella di chiamare mkdir dalla ricerca direttamente tramite -execè possibile saltare del tutto il ciclo for. Questo se non hai bisogno di eseguire ulteriori analisi.

Se il corpo del tuo ciclo è più di un singolo comando, è possibile usare xargs per guidare uno script di shell:

export OUTPATH=/some/where/else/
find . -type d -print0 | xargs -0 bash -c 'for DIR in "$@"; do
  printf "mkdir -p %q\\n" "${OUTPATH}${DIR}"        # Using echo for debug; working script will simply execute mkdir
  echo Created $DIR
done' -

Assicurati di includere il trattino finale (o qualche altra 'parola') se la shell è della varietà Bourne / POSIX (è usata per impostare $ 0 nello script della shell). Inoltre, è necessario fare attenzione con le virgolette, poiché lo script della shell viene scritto all'interno di una stringa tra virgolette anziché direttamente al prompt.

nella tua domanda aggiornata hai

mkdir -p \"${OUTPATH}${DIR}\"

questo dovrebbe essere

mkdir -p "${OUTPATH}${DIR}"

find . -type d -exec mkdir -p "{}\040" ';' -exec echo "Created {}\040" ';'

o per rendere il tutto molto meno complicato:

% rsync -av --include='*/' --exclude='*' SRC DST

questo replica la struttura di directory di SRC in ora legale.

Se hai GNU Parallel http: // www.gnu.org/software/parallel/ installato puoi farlo:

find . -type d | parallel echo making {} ";" mkdir -p /tmp/outdir/{} ";" echo made {}

Guarda il video introduttivo di GNU Parallel per saperne di più: http://www.youtube.com/watch?v=OpaiGYxkSuQ