Biorąc pod uwagę te nazwy plików:

$ ls -1
file
file name
otherfile

bash sam doskonale sobie radzi z osadzonymi białymi znakami:

$ for file in *; do echo "$file"; done
file
file name
otherfile
$ select file in *; do echo "$file"; done
1) file
2) file name
3) otherfile
#?

Czasami jednak nie chcę pracować z każdym plikiem, a nawet ściśle w tym $PWD, co tam findjest. Który obsługuje również białe znaki nominalnie:

$ find -type f -name file\*
./file
./file name
./directory/file
./directory/file name

Próbuję wymyślić bezpieczną dla whispace wersję tego skryptu, który weźmie dane wyjściowe findi zaprezentuje je w select:

$ select file in $(find -type f -name file); do echo $file; break; done
1) ./file
2) ./directory/file

Jednak wybucha to spacjami w nazwach plików:

$ select file in $(find -type f -name file\*); do echo $file; break; done
1) ./file        3) name          5) ./directory/file
2) ./file        4) ./directory/file  6) name

Zwykle poradziłbym sobie z tym, bawiąc się IFS. Jednak:

$ IFS=$'\n' select file in $(find -type f -name file\*); do echo $file; break; done
-bash: syntax error near unexpected token `do'
$ IFS='\n' select file in $(find -type f -name file\*); do echo $file; break; done
-bash: syntax error near unexpected token `do'

Jakie jest na to rozwiązanie?

Jeśli potrzebujesz tylko obsługiwać spacje i tabulatory (nie osadzone znaki nowej linii), możesz użyć mapfile(lub jego synonimu readarray), aby odczytać tablicę, np.

$ ls -1
file
other file
somefile

następnie

$ IFS= mapfile -t files < <(find . -type f)
$ select f in "${files[@]}"; do ls "$f"; break; done
1) ./file
2) ./somefile
3) ./other file
#? 3
./other file

Jeśli zrobić potrzebę nowej linii uchwytów, a bashwersja zapewnia zerowy rozdzielany mapfile¹ , a następnie można modyfikować, że do IFS= mapfile -t -d '' files < <(find . -type f -print0). W przeciwnym razie złóż równoważną tablicę z finddanych wyjściowych rozdzielonych znakiem null za pomocą readpętli:

$ touch $'filename\nwith\nnewlines'
$ 
$ files=()
$ while IFS= read -r -d '' f; do files+=("$f"); done < <(find . -type f -print0)
$ 
$ select f in "${files[@]}"; do ls "$f"; break; done
1) ./file
2) ./somefile
3) ./other file
4) ./filename
with
newlines
#? 4
./filename?with?newlines

¹-d opcji dodano mapfilew bashwersji 4.4 IIRC

Ta odpowiedź zawiera rozwiązania dla każdego rodzaju plików. Z nowymi liniami lub spacjami.
Istnieją rozwiązania dla ostatniego basha, a także starożytnego basha, a nawet starych powłok posix.

Do testów użyto drzewa wymienionego poniżej w tej odpowiedzi ^[1] .

Wybierz

selectPraca z tablicą jest łatwa :

$ dir='deep/inside/a/dir'
$ arr=( "$dir"/* )
$ select var in "${arr[@]}"; do echo "$var"; break; done

Lub z parametrami pozycyjnymi:

$ set -- "$dir"/*
$ select var; do echo "$var"; break; done

Tak więc jedynym prawdziwym problemem jest umieszczenie „listy plików” (poprawnie rozdzielonej) w tablicy lub w parametrach pozycyjnych. Czytaj dalej.

grzmotnąć

Nie widzę problemu, który zgłaszasz za pomocą bash. Bash może wyszukiwać w danym katalogu:

$ dir='deep/inside/a/dir'
$ printf '<%s>\n' "$dir"/*
<deep/inside/a/dir/directory>
<deep/inside/a/dir/file>
<deep/inside/a/dir/file name>
<deep/inside/a/dir/file with a
newline>
<deep/inside/a/dir/zz last file>

Lub, jeśli lubisz pętlę:

$ set -- "$dir"/*
$ for f; do printf '<%s>\n' "$f"; done
<deep/inside/a/dir/directory>
<deep/inside/a/dir/file>
<deep/inside/a/dir/file name>
<deep/inside/a/dir/file with a
newline>
<deep/inside/a/dir/zz last file>

Zauważ, że powyższa składnia będzie działać poprawnie z dowolną (rozsądną) powłoką (przynajmniej csh).

Jedynym ograniczeniem powyższej składni jest zejście do innych katalogów.
Ale bash może to zrobić:

$ shopt -s globstar
$ set -- "$dir"/**/*
$ for f; do printf '<%s>\n' "$f"; done
<deep/inside/a/dir/directory>
<deep/inside/a/dir/directory/file>
<deep/inside/a/dir/directory/file name>
<deep/inside/a/dir/directory/file with a
newline>
<deep/inside/a/dir/directory/zz last file>
<deep/inside/a/dir/file>
<deep/inside/a/dir/file name>
<deep/inside/a/dir/file with a
newline>
<deep/inside/a/dir/zz last file>

Aby wybrać tylko niektóre pliki (takie jak te, które kończą się plikiem), po prostu zamień *:

$ set -- "$dir"/**/*file
$ printf '<%s>\n' "$@"
<deep/inside/a/dir/directory/file>
<deep/inside/a/dir/directory/zz last file>
<deep/inside/a/dir/file>
<deep/inside/a/dir/zz last file>

krzepki

Kiedy w tytule umieścisz słowo „ bezpieczny dla przestrzeni”, założę , że to, co miałeś na myśli, było „ solidne ”.

Najprostszym sposobem na solidne podejście do spacji (lub znaków nowej linii) jest odrzucenie przetwarzania danych wejściowych zawierających spacje (lub znaki nowej linii). Bardzo prostym sposobem na wykonanie tego w powłoce jest wyjście z błędem, jeśli dowolna nazwa pliku rozwija się spacją. Można to zrobić na kilka sposobów, ale najbardziej kompaktowy (i posiks) (ale ograniczony do jednej zawartości katalogu, w tym nazw suddirectories i unikania plików kropkowych):

$ set -- "$dir"/file*                            # read the directory
$ a="$(printf '%s' "$@" x)"                      # make it a long string
$ [ "$a" = "${a%% *}" ] || echo "exit on space"  # if $a has an space.
$ nl='
'                    # define a new line in the usual posix way.  

$ [ "$a" = "${a%%"$nl"*}" ] || echo "exit on newline"  # if $a has a newline.

Jeśli zastosowane rozwiązanie jest solidne w którymkolwiek z tych elementów, usuń test.

W bash podkatalogi mogą być testowane jednocześnie z ** wyjaśnionym powyżej.

Istnieje kilka sposobów dołączania plików kropek, rozwiązaniem Posix jest:

set -- "$dir"/* "$dir"/.[!.]* "$dir"/..?*

odnaleźć

Jeśli z jakiegoś powodu należy użyć find, zamień separator na NUL (0x00).

bash 4.4+

$ readarray -t -d '' arr < <(find "$dir" -type f -name file\* -print0)
$ printf '<%s>\n' "${arr[@]}"
<deep/inside/a/dir/file name>
<deep/inside/a/dir/file with a
newline>
<deep/inside/a/dir/directory/file name>
<deep/inside/a/dir/directory/file with a
newline>
<deep/inside/a/dir/directory/file>
<deep/inside/a/dir/file>

bash 2.05+

i=1  # lets start on 1 so it works also in zsh.
while IFS='' read -d '' val; do 
    arr[i++]="$val";
done < <(find "$dir" -type f -name \*file -print0)
printf '<%s>\n' "${arr[@]}"

POSIXLY

Aby stworzyć prawidłowe rozwiązanie POSIX, w którym find nie ma separatora NUL i nie ma -d(ani -a) do odczytu, potrzebujemy zupełnie innego podejścia.

Musimy użyć kompleksu -execz find z wywołaniem powłoki:

find "$dir" -type f -exec sh -c '
    for f do
        echo "<$f>"
    done
    ' sh {} +

Lub, jeśli potrzebna jest opcja select (select jest częścią bash, a nie sh):

$ find "$dir" -type f -exec bash -c '
      select f; do echo "<$f>"; break; done ' bash {} +

1) deep/inside/a/dir/file name
2) deep/inside/a/dir/zz last file
3) deep/inside/a/dir/file with a
newline
4) deep/inside/a/dir/directory/file name
5) deep/inside/a/dir/directory/zz last file
6) deep/inside/a/dir/directory/file with a
newline
7) deep/inside/a/dir/directory/file
8) deep/inside/a/dir/file
#? 3
<deep/inside/a/dir/file with a
newline>

^[1] To drzewo (\ 012 to nowe linie):

$ tree
.
└── deep
    └── inside
        └── a
            └── dir
                ├── directory
                │   ├── file
                │   ├── file name
                │   └── file with a \012newline
                ├── file
                ├── file name
                ├── otherfile
                ├── with a\012newline
                └── zz last file

Można go zbudować za pomocą tych dwóch poleceń:

$ mkdir -p deep/inside/a/dir/directory/
$ touch deep/inside/a/dir/{,directory/}{file{,\ {name,with\ a$'\n'newline}},zz\ last\ file}

Nie można ustawić zmiennej przed konstrukcją zapętloną, ale można ustawić ją przed warunkiem. Oto segment ze strony podręcznika:

Środowisko dla dowolnej prostej komendy lub funkcji można tymczasowo rozszerzyć, poprzedzając je przypisaniami parametrów, jak opisano powyżej w PARAMETRACH.

(Pętla nie jest prostym poleceniem .)

Oto często używany konstrukt pokazujący scenariusze awarii i sukcesu:

IFS=$'\n' while read -r x; do ...; done </tmp/file     # Failure
while IFS=$'\n' read -r x; do ...; done </tmp/file     # Success

Niestety nie widzę sposobu na osadzenie zmiany IFSw selectkonstrukcie, gdy ma to wpływ na przetwarzanie powiązanego $(...). Jednak nic nie stoi na przeszkodzie, IFSaby ustawić ją poza pętlą:

IFS=$'\n'; while read -r x; do ...; done </tmp/file    # Also success

i widzę, że ten konstrukt działa z select:

IFS=$'\n'; select file in $(find -type f -name 'file*'); do echo "$file"; break; done

Podczas pisania kodu obronną, polecam, że klauzula albo być uruchamiane w podpowłoce, albo IFSi SHELLOPTSzapisane i przywrócone wokół bloku:

OIFS="$IFS" IFS=$'\n'                     # Split on newline only
OSHELLOPTS="$SHELLOPTS"; set -o noglob    # Wildcards must not expand twice

select file in $(find -type f -name 'file*'); do echo $file; break; done

IFS="$OIFS"
[[ "$OSHELLOPTS" !~ noglob ]] && set +o noglob

Mogę być poza moją jurysdykcją tutaj, ale może możesz zacząć od czegoś takiego, przynajmniej nie ma żadnych problemów z białymi znakami:

find -maxdepth 1 -type f -printf '%f\000' | {
    while read -d $'\000'; do
            echo "$REPLY"
            echo
    done
}

Aby uniknąć potencjalnych fałszywych założeń, jak zauważono w komentarzach, należy pamiętać, że powyższy kod jest równoważny z:

   find -maxdepth 1 -type f -printf '%f\0' | {
        while read -d ''; do
                echo "$REPLY"
                echo
        done
    }