Escape unusual characters on filenames with `find . -printf "%p \n"`

Question

The file paths coming from this find command

find . -printf "%p \n"

do not escape unusual (whitespace, backslash, double quote...) characters.

The -ls option does print the escaped paths, but it just prepends the output of ls -dils to the output of printf.

I need a highly efficient command, so running an extra ls does not help, and neither does printing out all the extra characters.

Is there any other (elegant) way to ouput escaped paths with find?

Answer 1

Usually you'd want to use find -exec to run a command for all file names, or find -print0 to pipe the names to some command that can read entries separated by nul bytes (like xargs -0).

If you really want to have quoted strings, Bash has a couple of options to do that:

$ find -exec bash -c 'printf "%s\n" "${@@Q}"' sh {} +
'./single'\''quote'
'./space 1'
$'./new\nline'
'./double"quote'

$ find -exec bash -c 'printf "%q\n" "$@"' sh {} +
./single\'quote
./space\ 1
$'./new\nline'
./double\"quote

This does require an extra invocation of the shell, but handles multiple file names with one exec.

---

Regarding saving the permission bits (not ACL's though), you could do something like this (in GNU find):

find -printf "%#m:%p\0" > files-and-modes

That would output entries with the permissions, a colon, the filename, and a nul byte, like: 0644:name with spaces\0. It will not escape anything, but instead will print the file names as-is (unless the output goes to a terminal, in which case at least newlines will be mangled.)

You can read the result with a Perl script:

perl -0 -ne '($m, $f) = split/:/, $_, 2; chmod oct($m), $f; ' < files-and-modes 

Or barely in Bash, see comments:

while IFS=: read -r -d '' mode file ; do
    # do something useful
    printf "<%s> <%s>\n" "$mode" "$file"
    chmod "$mode" "$file"
done < files-and-modes

As far as I tested, that works with newlines, quotes, spaces, and colons. Note that we need to use something other than whitespace as the separator, as setting IFS=" " would remove trailing spaces if any names contain them.

Answer 2

With zsh, you could do:

print -r -- ./**/*(.D:q)

. being the equivalent of -type f, D being to include hidden files like find would, and :q for quoting (using zsh-style quoting, I can't tell if that's the kind of quoting you're expecting).

You can get different styles of quoting with:

$ print -r -- ./**/*(.D:q)
./$'\200' ./a\ b ./é ./\"foo\" ./It\'s\ bad ./$'\n'
$ files=(./**/*(.D))
$ print -r -- ${(q)files}
./$'\200' ./$'\n' ./a\ b ./é ./\"foo\" ./It\'s\ bad
$ print -r -- ${(qq)files}
'./�' './
' './a b' './é' './"foo"' './It'\''s bad'
$ print -r -- ${(qqq)files}
"./�" "./
" "./a b" "./é" "./\"foo\"" "./It's bad"
$ print -r -- ${(qqqq)files}
$'./\200' $'./\n' $'./a b' $'./é' $'./"foo"' $'./It\'s bad'

(� being a placeholder displayed by my terminal emulator for that non-printable \200 byte).

Here, if you want to be able to store the permissions in such a way that can be restored, it's just a matter of:

find . -type f -printf '%m\0%p\0' > saved-permissions

To be restored (assuming GNU xargs) with:

xargs -r0n2 -a saved-permissions chmod

That would however run one chmod invocation per file, which would be terribly inneficient. You may want to use a shell where chmod is builtin like zsh again after zmodload zsh/files:

zmodload zsh/files
while IFS= read -rd '' mode && IFS= read -rd '' file; do
  chmod $mode $file
done < saved-permissions

Answer 3

I found a far more simple solution:

find -exec echo \'{}\' \;

We may use this to pipe to any other program:

find -exec echo \'{}\' \; | xargs ls 

Or we can simply use any command instead of echo and add any number of arguments:

find -exec mv \'{}\' somewhereelse \;

Don't forget to prepend echo for testing first.

The last DOES NOT WORK because mv does not remove the quotes before accessing the file, use pipe instead:

find -exec echo mv \'{}\' somewhereelse \;| bash

Answer 4

To print nicely quoted and escaped filenames (correctly handling apostrophes and quotes together) try the following:

find . -exec printf "%q\n" {} \;

which will produce (for example)

.
./DSC07051_.jpg
./Photos
"./Photos/TestDSC9910'Apos .jpg"
'./Photos/TestDSC9913 Space.jpg'
./Photos/DSC07053+.jpG
./Photos/DSC07048.jpg
./Photos/Photos.zip
'./Photos/TestDSC9912(x)Braces.jpg'
'./Photos/TestDSC9911"Quote.jpg'
'./Photos/TestDSC9919'\''The" (Lot).jpg'
./Photos/TestDSC9901Jpeg.jpEg
./DSC07053.jpg

Answer 5

Why not escaping EVERY character? It then works for anything (ls, rm, echo etc.):

find -name *.txt | sed -E 's/(.)/\\\1/g' | xargs ls

(you'll probably need to adapt it to the -exec form so it becomes more efficient)