Words, Quoting & Expansion

If you only ever properly learn one thing about bash, make it this module. Quoting is not style. It is the difference between a script that works and a script that deletes the wrong directory when someone puts a space in a filename. Nearly every shell bug you will ever hit — and a large share of the shell-related CVEs ever filed — is a quoting bug wearing a disguise.

The shell is a word-splitting machine

A command line is not a string that gets passed to a program. It is a list of words, and bash decides where the boundaries are. Programs receive an array of arguments; the shell's job is to build that array. Everything in this module is about controlling how it does that.

file="my report.txt"

rm $file      # TWO words: rm "my" "report.txt"  -- deletes the wrong things
rm "$file"    # ONE word:  rm "my report.txt"    -- correct

Read that until it is boring. The variable holds one value in both cases. What differs is whether bash was allowed to split it after substituting it.

The expansion order, precisely

When bash processes a word it performs these steps in this order:

1. Brace expansion — {a,b} becomes a b
2. Tilde expansion — ~ becomes your home directory
3. Parameter expansion — $var becomes its value
4. Command substitution — $(cmd) becomes cmd's output
5. Arithmetic expansion — $((1+1)) becomes 2
6. Word splitting — the result is chopped on IFS characters
7. Filename expansion (globbing) — *.txt becomes matching filenames

Two consequences people find surprising, both of which follow directly from the ordering:

• Brace expansion is first, so it cannot use variables: {1..$n} does not work, because $n has not been substituted yet when braces are processed.
• Globbing is last and operates on the result of substitution, so a variable containing * will expand to filenames when used unquoted. If a filename can contain an asterisk, an unquoted variable is a landmine.

IFS: the thing doing the splitting

IFS (Internal Field Separator) is the variable holding the characters bash splits on. Its default is space, tab, and newline. Change it and you change what "a word" means:

line="root:x:0:0:root:/root:/bin/bash"

IFS=':' read -r user pass uid gid gecos home shell <<< "$line"
echo "$user"   # root
echo "$shell"  # /bin/bash

Setting IFS on the same line as the command scopes the change to that one command only — a very useful idiom, and much safer than assigning it globally and forgetting to restore it.

The three kinds of quoting

Inside single quotes there is no escape mechanism at all — you cannot backslash-escape a single quote. To include one, end the string, add an escaped quote, and start again: 'it'\''s'. It looks absurd and it is the standard idiom.

"$@" versus "$*" versus $@

This is the highest-value distinction in the language, and it is worth memorising outright:

show() { printf '[%s]' "$@"; echo; }

set -- "one two" "three"       # two arguments

show "$@"   # [one two][three]      <- correct: each arg preserved
show $@     # [one][two][three]     <- split on whitespace, now three args
show "$*"   # [one two three]       <- joined into ONE arg

• "$@" expands to each argument as a separate, intact word. This is what you want, essentially always.
• "$*" joins all arguments into a single word, separated by IFS's first character. Useful when you deliberately want one string.
• Unquoted $@ or $* re-splits and globs every argument. Almost always a bug.

The same distinction applies verbatim to arrays in Module 07: "${arr[@]}" versus "${arr[*]}".

Where quoting actually bites

# 1. Command substitution splits too
files=$(ls)              # any filename with a space is now several words

# 2. Empty variables VANISH when unquoted
name=""
[ -n $name ]             # becomes: [ -n ]  -- which is TRUE. Bug.
[ -n "$name" ]           # becomes: [ -n "" ] -- correctly false

# 3. A leading dash makes your value look like a flag
user_input="-rf"
rm "$user_input"         # quoted, and STILL parsed as a flag
rm -- "$user_input"      # -- ends option parsing. Now it is a filename.

# 4. Globs inside variables expand on use
pattern="*.txt"
echo $pattern            # lists your .txt files
echo "$pattern"          # prints the literal string *.txt

Case 3 deserves emphasis because quoting alone does not save you. Quoting controls word splitting; it does not stop a program from interpreting a leading dash as an option. Any time a value could begin with -, terminate the option list with --. This is a real attack surface, not a theoretical one.

The rule