====== BASH - Quotes ======

Many different types of quotes enable different ways of interpreting their contents. 

Unfortunately, the rules and their behavior varies by context with several special cases and exceptions to remember. 

<WRAP tip>
**TIP:**  When in doubt, **double-quote** every expansion in your shell commands.

The basic rule of thumb is that you should double-quote every expansion.  This prevents unwanted word splitting and globbing.

There are a few cases where double quotes may be safely omitted:

  * On the right hand side of a simple assignment.  You may write the following without quotes. This is POSIX compliant. <code bash>foo=$bar</code> 

----

  * The word following a case keyword.  You may write the following safely.  This is POSIX compliant. <code bash>case $foo in ...</code> 

----

  * Inside a **<nowiki>[[</nowiki>** command, except on the right hand side of an = or == operator.  <nowiki>[[</nowiki> already suppresses word splitting and globbing, so you can write things like the following safely if you wish. <code bash>[[ -z $string ]]</code> 

----

  * <WRAP important>
**WARNING:** However, be warned that quoted and unquoted can act differently.  The <nowiki>[[</nowiki> keyword is a Bash extension. <code bash>[[ foo = $bar ]] and [[ foo = "$bar" ]]</code> These do act differently.
</WRAP>
 

Use single quotes when protecting complex strings, especially ones that contain shell syntax which you don't want evaluated. 
</WRAP>
 

----


===== Types of Quotes =====


There are 3 types of quotes.  Each of the quotes bring different meaning and usage.

<code>
' (single quotes) - Everything wrapped in this quote won't be changed (Strong quotes)

" (double quotes) - Quotes that doesn't expand meta-characters like "*" or "?," but does expand variables and does command substitution (Weaker quotes)

` (back quotes) - To execute command.  The legacy command substitution syntax; deprecated in favor of **$(...)** but still permitted for historical reasons.
</code>

----

==== Escaping Quotes ====

Putting a **backslash** character **\** in front of a quote removes its special meaning. 

This works inside double quotes, or in the absence of quotes.

It does not work inside single quotes. 

==== Example ====

<code bash>
echo 'Don'\''t walk!'
echo "Don't walk!"
echo $'Don\'t talk!'
</code>

  * **1st line:**  A single quoted string that can contain anything other than single-quotes.  In this case, an escaped, unquoted single-quote is concatenated with the argument between two single quoted strings.
  * **2nd line:**  A double-quoted string with all expansions and double-quotes within escaped.
  * **3rd line:**  A less portable equivalent using $'...':

**$(...)**-style command substitutions are unique in that the quoting of their contents is completely independent to their surroundings.  This means you don't have to worry about nested quote escaping problems.

----

===== Concatenating Quotes =====

The various types of quotes can be combined, or concatenated, if needed.

For example, if you have one section of a string that has lots of special characters that you'd like to single-quote, and another section with a parameter expansion in it which must be double-quoted, you may mix them:

<code bash>
foo=bar
echo '!%$*&'"$foo"
</code>

returns:

<code bash>
!%$*&bar
</code>

The result (after appropriate expansions in the double-quoted sections) is a single word.

<WRAP info>
**NOTE:** Any number of quoted substrings, of any style, may be concatenated in this manner.
</WRAP>

----

===== Expand argument lists =====

Double-quoting **$@** or **${array[@]}** has a special meaning.

"$@" expands to a list of words, with each positional parameter's value being one word.

Likewise, "${array[@]}" expands to a list of words, one per array element.

When dealing with the positional parameters or with the contents of an array as a list of words, always use the double-quoted syntax.

Example of proper iteration over the positional parameters using a quoted "$@". Never use an unquoted $@ or $*.

<code bash>
for file in "$@"; do
...
done
</code>

----

Double-quoting **$*** or **${array[*]}** results in one word which is the concatenation of all the positional parameters (or array elements) with the first character of IFS between them.

This is similar to the join function in some other languages, although the fact that you can only have a single join character can sometimes be a crippling limitation. 

<code bash>
for index in "${array[@]}"; do
...
</code>

----

===== Prevent field splitting and ignore glob pattern characters =====

<code bash>
cp $file $destination         # WRONG
cp -- "$file" "$destination"  # Right
</code>

In this example, the double quotes protect the value of each parameter from undergoing word splitting or globbing should it happen to contain whitespace or wildcard characters (* or ? or [...]).

Without the quotes, a filename like hot stuff.mp3 would be split into two words, and each word would be passed to the cp command as a separate argument.  or, a filename that contains * with whitespace around it would produce one word for every file in the current directory.  That is not what we want.

With the quotes, every character in the value of the filename parameter is treated literally, and the whole value becomes the second argument to the cp command.

<WRAP info>
When in doubt, always double-quote your parameter expansions.
</WRAP>
 


----


===== Example - using back quotes within single quotes =====

Example of using back quotes within single quotes.  Nothing is changed.

<code bash>
echo 'Today is `date`'

Today is `date`
</code>

----

===== Example of using back quotes within double quotes =====

Example of using back quotes within double quotes.  The `date` command will be executed:

<code bash>
echo "Today is `date`"

Today is Mon May 26 09:42:50 MYT 2008
</code>