UNIX SHELL Quote Tutorial

Written by Bruce Barnett

Table of Contents

• Quoting a single character with the back slash
• Strong Quoting with the Single Quotes
• Weak Quotes with the Double Quotes
• Using quotes to include spaces and characters in filenames
• Quotes within Quotes
• Finding out if your quotes are wrong
• The verbose and echo variables in the C shell
• The Bourne Shell variables
• Including identical quotes within quotes
• Quoting long lines
• HERE IS documents
• When to quote?

Copyright © 1991, 2001 Bruce Barnett and General Electric Company

I had planned to discuss regular expressions with you this month. I realized, however, that unless you fully understood the Unix quoting mechanism, you might become confused. Regular expressions use meta-characters. The shells also have meta-characters. Meta-characters are simply characters that have a special meaning. The problem occurs when you want to use a regular expression in a shell script. Will the shell do something special with the character? Or will it be passed unchanged to the program? The "$" character is a good example. It could be the beginning of a variable name, or it could be part of a regular expression. If you need a regular expression, you must know if any of the characters of the expression are meta-characters, and must know the right way to quote that character, so that it is passed to the program without being modified by the shell.

Here is a chart of the meta-characters the Bourne and C shell know about. I have also included several combinations of characters just to make this table more complete. There is a lot of detail on this chart.

List of Special Characters and what they mean

I am not going to cover each one of these special meta-characters. I'll save that for a future column, perhaps. What is important is a solid understanding of the characters that have these special meanings. I will also discuss how you can verify the shell is interpreting the special characters, so you can pinpoint where your problem lies.

There are three different mechanisms used for quoting characters. One of them is not the use of the back quote character "`". That character is used for command substitution:

% echo the date is `date`

Quoting a single character with the back slash

echo This script removes all files that
echo contain an asterisk in the name.
echo
echo Are you sure you want to remove these files\?
rm -i *\**

Are you sure you want to remove these files1 files2

which is not what you want.

The back slash is the "strongest" method of quotation. It works when every other method fails. If you want to place text on two or more lines for readability, but the program expects one line, you need a line continuation character. Just use the back slash as the last character on the line:

% echo This could be \
a very \
long line\!
This could be a very long line!
%

Strong Quoting with the Single Quotes

% echo a\ \ \ \ \ \ \ b

% echo 'a b'

% echo 'What the *heck* is a $ doing here???'
What the *heck* is a $ doing here???

Weak Quotes with the Double Quotes

% echo "Is your home directory $HOME?"
Is your home directory /home/kreskin/u0/barnett?
% echo "Your current directory is `pwd`"
Your current directory is /home/kreskin/u0/barnett

Using quotes to include spaces and characters in filenames

% cp /dev/null 'a file with spaces in the name'

% mv a\ file a_file

Using the same techniques, you can deal with any character in a filename:

% mv a 'a?'

Quotes within Quotes

% echo "Don't do that"
Don't do that
% echo 'The quote of the day is: "TGIF"'
The quote of the day is: "TGIF"
%

Finding out if your quotes are wrong

An easy way to check quotes is to add an "echo" before the command so you can see what is happening, or change an "ls" command into an "echo" command:

echo rcp gateway:\*.tar.Z .
rsh -n cruncher echo ls \*
rsh -n cruncher echo 'ls *'

rsh -n cruncher echo 'ls * >/tmp/file'

rsh -n cruncher "echo 'ls * >/tmp/file'"
rsh -n cruncher 'echo "ls * >/tmp/file"'
rsh -n cruncher "echo 'cd newdir;ls * >>/tmp/file'"

If you are debugging a shell script, and you want to see what your script is doing, you can duplicate one of the important lines in your script and insert an "echo" in front of one of the duplicates. Doing this one or two times in a script isn't very difficult, but there are times when you want to watch every line of your script. In this case, just ask the shell to show you want is going on.

The verbose and echo variables in the C shell

set verbose

set echo

A convenient way to turn these variables on the first line of the script using the the "-x" option (echo)

#!/bin/csh -x

or the "-v" option (verbose):

#!/bin/csh -v

#!/bin/csh -fxv

#!/bin/csh -XV

It is not necessary to modify the program if you want to turn on the verbose or echo variables. If this is a script that you do not have the permissions to modify, you can set these variables from the command line:

% csh -x shell_script

The Bourne Shell variables

% sh -v script
% sh -x script

set -v

set -x

set +x
set +v

Including identical quotes within quotes

echo "The word for today is \"TGIF\""
echo 'Don\'t quote me'

echo 'a'b'c'

echo 'a'$HOME'b'

#!/bin/sh
# this is a shell script that acts like a filter,
# but in only prints out one column.
# the value of the column is the argument 
# to the script
#
# uncomment the next line to see how this works
#set -x
#
# example:
#       printcol 1
#       printcol 3
# the value of the argument is $1
# Here comes the tricky part -
awk '{print $'$1'}'
# I told you!

printcol 2 </etc/hosts

You must understand this when you want to have quotes within quotes. In fact, you don't want to put quotes within quotes, you want to combine or concatenate several units into one argument.

Let me rephrase that. If you want to include a single quote in an argument that starts with a single quote, you must turn off the mechanism started by the single quote, and use a different quoting method. Remember, the back quote is the strongest of all quoting mechanisms. You can quote anything with the back quote. This example quotes all three quote characters:

% echo \'\"\\

Where the results are

'"\

% echo 'Don' \' 't do that'
Don ' t do that

% echo 'Don'\''t do that'
Don't do that

% echo "The quote for today is "\"TGIF\"
The quote for today is "TGIF"

% echo "The quote for today is "\""TGIF"\"
The quote for today is "TGIF"

Quoting long lines

The Bourne shell and C shell behave differently when you are quoting lines that continue beyond the end of line marker. The C shell will not extend a quote beyond the line unless the last character is a back slash:

% echo "A quote \
on two lines"
A quote 
on two lines

$ echo "A quote
> on two lines"
A quote
on two lines

echo 'Don\'t do that'

I find the Bourne shell easier to use when I write multi-line quotes which are awk scripts:

#!/bin/sh -x
#this script counts how many people
# are in the group specified as the first argument
grp=${1:?}	# get group ID number
awk -F: '
# Awk script starts here
BEGIN {
	# set total to zero 
	#   before we start
	total=0;	
}
$3 ~ /^'$grp'$/ {total++;} 
END {
	# end of file, print total
	printf("Total: %d\n", total);
}' </etc/passwd

HERE IS documents

% sort >file <<EndOfSort
zygote
abacus
EndOfSort

#!/bin/sh
# Usage:
# ftpfile machine file
# set -x
SOURCE=$1
FILE=$2
BFILE=`basename $FILE`
ftp -n $SOURCE <<EndFTP
ascii
user anonymous $USER@`hostname`
get $FILE /tmp/$BFILE
EndFTP

cat >file <<\FunkyStriNG

When to quote?