Jak mogę uciec od spacji na liście pętli bash?

Mam skrypt powłoki bash, który przechodzi przez wszystkie katalogi podrzędne (ale nie pliki) określonego katalogu. Problem polega na tym, że niektóre nazwy katalogów zawierają spacje.

Oto zawartość mojego katalogu testowego:

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

Oraz kod, który przechodzi przez katalogi:

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

Oto wynik:

test / Baltimore
test / Cherry
Wzgórze
test / Edison 
test / nowy
York
Miasto
test / Philadelphia

Cherry Hill i Nowy Jork są traktowane jako 2 lub 3 osobne wpisy.

Próbowałem zacytować nazwy plików, na przykład:

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

ale bez skutku.

Musi być na to prosty sposób.

Odpowiedzi poniżej są świetne. Ale żeby to jeszcze bardziej skomplikować - nie zawsze chcę używać katalogów wymienionych w moim katalogu testowym. Czasami chcę zamiast tego przekazać nazwy katalogów jako parametry wiersza polecenia.

Przyjąłem sugestię Charlesa dotyczącą ustawienia IFS i wymyśliłem, co następuje:

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

i działa to dobrze, chyba że w argumentach wiersza poleceń są spacje (nawet jeśli te argumenty są cytowane). Na przykład wywołanie skryptu w ten sposób: test.sh "Cherry Hill" "New York City"daje następujący wynik:

wiśnia
Wzgórze
Nowy
York
Miasto

Po pierwsze, nie rób tego w ten sposób. Najlepszym podejściem jest find -execprawidłowe użycie :

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

Innym bezpiecznym podejściem jest użycie listy zakończonej znakiem NUL, chociaż wymaga to wsparcia wyszukiwania -print0:

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

Możesz również wypełnić tablicę z funkcji find i przekazać ją później:

# 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

Jeśli twoje znalezisko nie obsługuje -print0, twój wynik jest niebezpieczny - poniższe nie będą zachowywać się zgodnie z oczekiwaniami, jeśli istnieją pliki zawierające znaki nowej linii w nazwie (co, tak, jest legalne):

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

Jeśli nie mamy zamiaru używać jednego z powyższych, trzecim podejściem (mniej wydajnym pod względem czasu i wykorzystania pamięci, ponieważ odczytuje całe wyjście podprocesu przed wykonaniem podziału na słowa) jest użycie IFSzmiennej, która nie nie zawierają znaku spacji. Wyłącz globbing ( set -f), aby zapobiec ciągi znaków zawierające takie jak glob [], *lub ?przed rozwinięciem:

# 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
)

Na koniec, w przypadku parametrów wiersza poleceń, powinieneś używać tablic, jeśli twoja powłoka je obsługuje (tj. Jest to ksh, bash lub zsh):

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

utrzyma separację. Zauważ, że cytowanie (i użycie $@zamiast $*) jest ważne. Tablice można również wypełniać na inne sposoby, na przykład wyrażenia 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

Jednak nie działa, jeśli nazwa pliku zawiera znaki nowej linii. Powyższe jest jedynym rozwiązaniem, jakie znam, kiedy faktycznie chcesz mieć nazwę katalogu w zmiennej. Jeśli chcesz po prostu wykonać jakąś komendę, użyj xargs.

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

Oto proste rozwiązanie, które obsługuje tabulatory i / lub spacje w nazwie pliku. Jeśli masz do czynienia z innymi dziwnymi znakami w nazwie pliku, takimi jak znaki nowej linii, wybierz inną odpowiedź.

Katalog testów

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

Kod, aby przejść do katalogów

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

Jeśli nazwa pliku jest "$f"używana jako argument, należy ją wpisać w cudzysłów ( ). Bez cudzysłowów spacje działają jako separator argumentów, a wywoływanemu poleceniu jest podawanych wiele argumentów.

A wynik:

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

Jest to niezwykle trudne w standardowym Uniksie, a większość rozwiązań zawiera znaki nowej linii lub inne znaki. Jeśli jednak używasz zestawu narzędzi GNU, możesz wykorzystać tę findopcję -print0i użyć xargsz odpowiednią opcją -0(minus-zero). Istnieją dwa znaki, które nie mogą pojawić się w prostej nazwie pliku; to są slash i NUL '\ 0'. Oczywiście ukośnik pojawia się w nazwach ścieżek, więc rozwiązanie GNU polegające na użyciu NUL '\ 0' do oznaczenia końca nazwy jest genialne i niezawodne.

Dlaczego po prostu nie położyć

IFS='\n'

przed dowództwem? Spowoduje to zmianę separatora pól z <Spacja> <Tab> <Nowa linia> na <Nowa linia>

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

używam

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

Czy to nie wystarczy?
Pomysł zaczerpnięty z http://www.cyberciti.biz/tips/handling-filenames-with-spaces-in-bash.html

Nie przechowuj list jako ciągów; przechowuj je jako tablice, aby uniknąć całego zamieszania w separatorach. Oto przykładowy skrypt, który będzie działał na wszystkich podkatalogach testu lub na liście podanej w jego wierszu poleceń:

#!/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

Teraz wypróbujmy to w katalogu testowym z wrzuconą krzywą lub dwiema:

$ 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

Możesz tymczasowo użyć IFS (wewnętrznego separatora pól), używając:

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 jeśli chodzi tylko o spację na wejściu, to niektóre podwójne cudzysłowy działały dla mnie gładko ...

read artist;

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

Aby dodać do tego, co powiedział Jonathan : użyj -print0opcji findw połączeniu z xargsnastępującymi:

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

Spowoduje to wykonanie polecenia commandz odpowiednimi argumentami; katalogi ze spacjami będą odpowiednio cytowane (tj. zostaną przekazane jako jeden argument).

#!/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

Powyższy kod konwertuje pliki .mov do .avi. Pliki .mov znajdują się w różnych folderach, a nazwy folderów mają spacje . Mój powyższy skrypt sam skonwertuje pliki .mov do pliku .avi w tym samym folderze. Nie wiem, czy to wam pomoże, ludzie.

Walizka:

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

Twoje zdrowie!

Musiał też mieć do czynienia ze spacjami w nazwach ścieżek. W końcu użyłem rekurencji i for item in /path/*:

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

Przekonwertuj listę plików na tablicę Bash. Wykorzystuje podejście Matta McClure'a do zwracania tablicy z funkcji Bash: http://notes-matthewlmcclure.blogspot.com/2009/12/return-array-from-bash-function-v-2.html Wynikiem jest sposób aby przekonwertować dowolne wejście wieloliniowe na tablicę 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

To podejście wydaje się działać nawet wtedy, gdy obecne są złe znaki i jest ogólnym sposobem konwersji dowolnego wejścia na tablicę Bash. Wadą jest to, że jeśli dane wejściowe są długie, możesz przekroczyć limity rozmiaru wiersza poleceń Basha lub zużywać duże ilości pamięci.

Podejścia, w których pętla, która ostatecznie działa na liście, również ma tę listę, ma tę wadę, że odczyt stdin nie jest łatwy (na przykład proszenie użytkownika o wprowadzenie danych), a pętla jest nowym procesem, więc możesz się zastanawiać, dlaczego zmienne ustawione wewnątrz pętli nie są dostępne po zakończeniu pętli.

Nie podoba mi się też ustawianie IFS, może to zepsuć inny kod.

Cóż, widzę zbyt wiele skomplikowanych odpowiedzi. Nie chcę przekazywać danych wyjściowych narzędzia find ani pisać pętli, ponieważ find ma do tego opcję "exec".

Mój problem polegał na tym, że chciałem przenieść wszystkie pliki z rozszerzeniem dbf do bieżącego folderu, a niektóre z nich zawierały spacje.

Tak sobie z tym poradziłem:

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

Wydaje mi się to bardzo proste

właśnie się dowiedziałem, że istnieją pewne podobieństwa między moim pytaniem a twoim. Na razie, jeśli chcesz przekazywać argumenty do poleceń

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

wydrukować je w kolejności

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

zauważ, że $ @ jest otoczony podwójnymi cudzysłowami, kilka uwag tutaj

Potrzebowałem tej samej koncepcji, aby skompresować sekwencyjnie kilka katalogów lub plików z określonego folderu. Rozwiązałem użycie awk do przeanalizowania listy z ls i uniknięcia problemu spacji w nazwie.

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

co myślisz?

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

U mnie to działa i jest prawie „czyste”:

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

Właśnie miałem prosty problem z wariantem ... Konwertuj pliki o typie .flv do .mp3 (ziewanie).

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

rekurencyjnie znajdź wszystkie pliki flash użytkownika Macintosha i zamień je na audio (kopiuj, bez transkodowania) ... to tak jak powyżej, zauważ, że odczyt zamiast tylko „dla pliku w ” zostanie usunięty.