Quotes and escaping

Quoting and escaping is really an important way to influence the way, Bash treats your input. There are three recognized types:

• per-character escaping using a backslash: \$stuff
• weak quoting with double-quotes: "stuff"
• strong quoting with single-quotes: 'stuff'

All three forms have the very same purpose: They give you general control over parsing, expansion and expansion's results.

Beside these common basic variants, there are some more special quoting methods (like interpreting ANSI-C escapes in a string) you'll meet below.

ATTENTION These quote characters (", double quote and ', single quote) are a syntax element that influences parsing. It is not related to eventual quote characters that are passed as text to the commandline! The syntax-quotes are removed before the command is called! Look:

### NO NO NO: this passes three strings:
###      (1)  "my
###      (2)  multiword
###      (3)  argument"
MYARG="\"my multiword argument\""
somecommand $MYARG

### THIS IS NOT (!!!!) THE SAME AS ###
command "my multiword argument"

### YOU NEED ###
MYARG="my multiword argument"
command "$MYARG"

Per-character escaping is useful in different places, also here, on expansions and substitutions. In general, a character that has a special meaning for Bash, like the dollar-sign ($) to introduce some expansion types, can be masked to not have that special meaning using the backslash:

echo \$HOME is set to \"$HOME\"

• \$HOME won't expand because it's not variable expansion syntax anymore
• The quotes are masked with the backslash to be literal - otherwise they would be interpreted by Bash

The sequence \<newline> (an unquoted backslash, followed by a <newline> character) is interpreted as line continuation. It is removed from the input stream and thus effectively ignored. Use it to beautify your code:

# escapestr_sed()
# read a stream from stdin and escape characters in text that could be interpreted as
# special characters by sed
escape_sed() {
 sed \
  -e 's/\//\\\//g' \
  -e 's/\&/\\\&/g'
}

The backslash can be used to mask every character that has a special meaning for bash. Exception: Inside a single-quoted string (see below).

Inside a weak-quoted string there's no special interpretion of:

• spaces as word-separators (on inital commandline splitting and on word splitting!)
• single-quotes to introduce strong-quoting (see below)
• characters for pattern matching
• pathname expansion
• process substitution

Everything else, especially parameter expansion, is performed!

ls -l "*"

echo "Your PATH is: $PATH"

If a backslash in double-quotes ("weak quoting") occurs, there are 2 ways to deal with it

• if the baskslash is followed by a character that would have a special meaning even inside double-quotes, the backslash is removed and the following character looses its special meaning
• if the backslash is followed by a character without special meaning, the backslash is not removed

In particuar this means that "\$" will become $, but "\x" will become \x.

Strong quoting is very easy to explain:

Inside a single-quoted string nothing(!!!!) is interpreted, except the single-quote that closes the quoting.

echo 'Your PATH is: $PATH'

In practise that means, to produce a text like Here's my test… as a single-quoted string, you have to leave and re-enter the single-quoting to get the character "'" as literal text:

# WRONG
echo 'Here's my test...'

# RIGHT
echo 'Here'\''s my test...'

There's another quoting mechanism, Bash provides: Strings that are scanned for ANSI C like escape sequences. The Syntax is

$'string'

This is especially useful when you want to give special characters as arguments to some programs, like giving a newline to sed.

The resulting text is treated as if it was single-quoted. No further expansions happen.

A dollar-sign followed by a double-quoted string, for example

echo $"generating database..."

If the string was replaced (translated), the result is double-quoted.

In case you're a C-programmer: The purpose of $"…" is the same as for gettext() or _().

For useful examples to localize your scripts, please see Appendix I of the Advanced Bash Scripting Guide.

Attention: There is a security hole. Please read in the gettext documentation

The classic for-loop uses a list of words to iterate through. This list can - of course - also be in a variable:

mylist="DOG CAT BIRD HORSE"

WRONG way to iterate through this list:

for animal in "$mylist"; do
  echo $animal
done

RIGHT way to iterate through this list:

for animal in $mylist; do
  echo $animal
done

The command test or [ … ] ( the classic test command) is a normal ordinary command, so normal ordinary syntax rules apply. Let's take string comparison as example:

[ WORD = WORD ]

The ] at the end is a convenience; if you type which [ you will see that there is in fact a binary with that name. So if we were writing this as just a test command it would be:

test WORD = WORD

When you compare variables, it's wise to quote them. Let's invent a test string with spaces:

mystring="my string"

And now check that string against the word "testword":

[ $mystring = testword ] # WRONG!!!

[ my string = testword ]
test my string = testword

So what you really want to do is:

[ "$mystring" = testword ] # RIGHT!!!

test 'my string' = testword

Now the command has three parameters, which makes sense for a binary (two argument) operator.

Hint: Inside the conditional expression ([[ ]]) Bash doesn't perform word splitting, and thus you don't need to quote your variable references - they are always seen as "one word".

• Internal: Some words about words...
• Internal: Word splitting
• Internal: Introduction to expansions and substitutions

• External: Grymore: Shellquoting