Using shell variables for command options

In general, it's a bad idea to demote a list of separate items into a single string, no matter whether it's a list of command line options or a list of pathnames.

Using an array instead:

rsync_options=( -rnv --exclude='.*' )

or

rsync_options=( -r -n -v --exclude='.*' )

and later...

rsync "${rsync_options[@]}" source/ target

This way, the quoting of the individual options is maintained (as long as you double quote the expansion of ${rsync_options[@]}). It also allows you to easily manipulate the individual entries of the array, would you need to do so, before calling rsync.

In any POSIX shell, one may use the list of positional parameters for this:

set -- -rnv --exclude='.*'

rsync "$@" source/ target

Again, double quoting the expansion of $@ is critical here.

Tangentially related:

• How can we run a command stored in a variable?

---

The issue is that when you put the two sets of option into a string, the single quotes of the --exclude option's value becomes part of that value. Hence,

RSYNC_OPTIONS='-rnv --exclude=.*'

would have worked¹... but it's better (as in safer) to use an array or the positional parameters with individually quoted entries. Doing so would also allow you to use things with spaces in them, if you would need to, and avoids having the shell perform filename generation (globbing) on the options.

---

^{¹ provided that $IFS is not modified and that there's no file whose name starts with --exclude=. in the current directory, and that the nullglob or failglob shell options are not set.}

@Kusalananda has already explained the basic problem and how to solve it, and the Bash FAQ entry linked to by @glenn jackmann also provides a lot of useful information. Here's a detailed explanation of what's happening in my problem based on these resources.

We'll use a small script that prints each of its arguments on a separate line to illustrate things (argtest.bash):

#!/bin/bash

for var in "$@"
do
    echo "$var"
done

Passing options "manually":

$ ./argtest.bash -rnv --exclude='.*'
-rnv
--exclude=.*

As expected, the parts -rnv and --exclude='.*' are split into two arguments, as they are separated by unquoted whitespace (this is called word splitting).

Also note that the quotes around .* have been removed: the single quotes tell the shell to pass their content without special interpretation, but the quotes themselves are not passed to the command.

If we now store the options in a variable as a string (as opposed to using an array), then the quotes are not removed:

$ OPTS="--exclude='.*'"

$ ./argtest.bash $OPTS
--exclude='.*'

This is because of two reasons: the double quotes used when defining $OPTS prevent special treatment of the single quotes, so the latter are part of the value:

$ echo $OPTS
--exclude='.*'

When we now use $OPTS as an argument to a command then quotes are processed before parameter expansion, so the quotes in $OPTS occur "too late".

This means that (in my original problem) rsync uses the exclude pattern '.*' (with quotes!) instead of the pattern .* -- it excludes files whose name starts with single quote followed by a dot and ends with a single quote. Obviously that's not what was intended.

A workaround would have been to omit the double quotes when defining $OPTS:

$ OPTS2=--exclude='.*'

$ ./argtest.bash $OPTS2
--exclude=.*

However, it's a good practice to always quote variable assignments because of subtle differences in more complex cases.

As @Kusalananda noted, not quoting .* would also have worked. I had added the quotes to prevent pattern expansion, but that wasn't stricly necessary in this special case:

$ ./argtest.bash --exclude=.*
--exclude=.*

It turns out that Bash does perform pattern expansion, but the pattern --exclude=.* doesn't match any file, so the pattern is passed on to the command. Compare:

$ touch some_file

$ ./argtest.bash some_*
some_file

$ ./argtest.bash does_not_exit_*
does_not_exit_*

However, not quoting the pattern is dangerous, because if (for whatever reason) there was a file matching --exclude=.* then the pattern gets expanded:

$ touch -- --exclude=.special-filenames-happen

$ ./argtest.bash --exclude=.*
--exclude=.special-filenames-happen

Finally, let's see why using an array prevents my quoting problem (in addition to the other advantages of using arrays to store command arguments).

When defining the array, word splitting and quote handling happens as expected:

$ ARRAY_OPTS=( -rnv --exclude='.*' )

$ echo length of the array: "${#ARRAY_OPTS[@]}"
length of the array: 2

$ echo first element: "${ARRAY_OPTS[0]}"
first element: -rnv

$ echo second element: "${ARRAY_OPTS[1]}"
second element: --exclude=.*

When passing the options to the command, we use the syntax "${ARRAY[@]}", which expands each element of the array into a separate word:

$ ./argtest.bash "${ARRAY_OPTS[@]}"
-rnv
--exclude=.*