In the good old days when UNIX was young, no one ever would have thought of putting a space in a filename. It simply wasn't done—just as you'd never do that on a DOS or Windows system. Filenames were short, succinct and well-formed, like HW43.DOC.

Most of the Linux command-line utilities and the shells themselves have been designed based on the premise that a space delimits a field value rather than being an acceptable component of a filename. If you've done any scripting, you already know this. Spaces in filenames can cause great trouble in shell scripts! Here's a simple example:

for name in $(ls | grep a)
do
  echo "File #$count = $name"
  count=$(( $count + 1 ))
done

To set the stage, I've created a directory with some tricky filenames:

$ ls
"quoted" beastly filename      sample2.txt
multi-word file name.pdf           test.sh

Yes, to maximize trouble, I have a filename that includes quotes as well as a space. Don't get me started on having an escape character or non-printable character in the name though. It's doable, but I'd rename it as soon as possible.

Not all the filenames above have an “a” in them, so let's see what happens when the fragmentary script is run in this directory:

$ ./test.sh
File # = "quoted"
File #1 = beastly
File #2 = filename
File #3 = multi-word
File #4 = file
File #5 = name.pdf
File #6 = sample2.txt

Oh, is that ugly and wrong!

The shell can deal with these filenames if they're simple enough, and the for loop for name in *a* yields three filenames, not six, but somewhere along your scripting journey, you inevitably will slam into the problem of embedded spaces.

The most common error is to forget to quote filenames when you use them elsewhere in the script, of course. As an example, let's work on a script that replaces spaces in filenames with underscores.

The obvious solution to such renaming is something like this:

for name in "* *"
do
  newname="$(echo $name | sed 's/ /_/g')"
  mv $name $newname
done

This doesn't work, however, and in a most fascinating way:

mv "quoted" beastly filename multi-word file 
 ↪name.pdf sample2.txt test.sh "quoted" 
 ↪beastly filename multi-word file 
 ↪name.pdf sample2.txt test.sh 
↪"quoted"_beastly_filename_multi-word_file_
↪name.pdf_sample2.txt_test.sh_"quoted"_beastly_
↪filename_multi-word_file_name.pdf_sample2.txt_test.sh

What's happened is that "* *" simply produces two full filename listings rather than just those filenames that contain a space—oops. Let's try a different pattern:

for name in *\ *

That does the trick, but we've not compensated for the fact that when the shell sees a line like:

mv multi-word file name.pdf multi-word_file_name.pdf

it's going to complain that it's seeing four filename arguments to the mv command, not the required two:

usage: mv [-f | -i | -n] [-v] source target
       mv [-f | -i | -n] [-v] source ... directory

In this case, the solution is to quote the filename variable:

mv "$name" $newname

As a discipline, it's always good to quote filenames you reference in any context to ensure that when the shell passes them to the command as arguments, the filenames with embedded spaces are handled properly.

This isn't a universal solution, however, because if you're using subshells and pipes, it can be pretty darn hard for quotes to survive multiple steps.

One path to travel is to set IFS, the internal field separator, in the shell to something other than a space, as explained in the Bash man page:

That's useful for “read”, particularly if you're reading lines of text and want to have a different field separator (think flat-file text database files), but it still doesn't really solve our filename problem.

One thing I've used in the past, although it's a sloppy, crude solution, is to start by changing spaces to some unlikely sequence of characters, run through all the processing, and change them back at the last second. For example:

safename="$(echo name | sed 's/ /_-_/g')"

and reversed with:

original="$(echo $safename | sed s'/_-_/ /g')"

It solves the problem, but it's definitely not a very efficient or smart use of computing resources.

I've outlined three possible solution paths herein: modifying the IFS value, ensuring that you always quote filenames where referenced, and rewriting filenames internally to replace spaces with unlikely character sequences, reversing it on your way out of the script.

By the way, have you ever tried using the find|xargs pair with filenames that have spaces? It's sufficiently complicated that modern versions of these two commands have special arguments to denote that spaces might appear as part of the filenames: find -print and xargs -0 (and typically, they're not the same flags, but that's another story).

During the years I've been writing this column, I've more than once tripped up on this particular problem and received e-mail messages from readers sharing how a sample script tosses up its bits when a file with a space in its name appears. They're right.

My defensive reaction is “dude, don't use spaces in filenames”, but that's not really a good long-term solution, is it?

What I'd like to do instead is open this up for discussion on the Linux Journal discussion boards: how do you solve this problem within your scripts? Or, do you just religiously avoid using spaces in your filenames?