As mentioned at the start of this section, c is basically equivalent to 'c'. One exception to this rule is when the backslash is used as the very last character on the line:

$ lines=one'
> 'two          Single quotes tell shell to ignore newline
$ echo "$lines"
one
two
$ lines=one          Try it with a  instead
> two
$ echo "$lines"
onetwo
$

The shell treats a backslash at the end of the line as a line continuation. It removes the newline character that follows and also does not treat the newline as an argument delimiter (it's as if it wasn't even typed). This construct is most often used for typing long commands over multiple lines.

We noted earlier that the backslash is one of the three characters interpreted by the shell inside double quotes. This means that you can use the backslash inside these quotes to remove the meaning of characters that otherwise would be interpreted inside double quotes (that is, other backslashes, dollar signs, back quotes, newlines, and other double quotes). If the backslash precedes any other character inside double quotes, the backslash is ignored by the shell and passed on to the program:

$ echo "$x"
$x
$ echo " is the backslash character"
 is the backslash character
$ x=5
$ echo "The value of x is "$x""
The value of x is "5"
$

In the first example, the backslash precedes the dollar sign, interpreted by the shell inside double quotes. So the shell ignores the dollar sign, removes the backslash, and executes echo. In the second example, the backslash precedes a space, not interpreted by the shell inside double quotes. So the shell ignores the backslash and passes it on to the echo command. The last example shows the backslash used to enclose double quotes inside a double-quoted string.

As an exercise in the use of quotes, let's say that you want to display the following line at the terminal:

<<< echo $x >>> displays the value of x, which is $x

The intention here is to substitute the value of x in the second instance of $x, but not in the first. Let's first assign a value to x:

$ x=1
$

Now try displaying the line without using any quotes:

$ echo <<< echo $x >>> displays the value of x, which is $x
syntax error: '<' unexpected
$

The < signals input redirection to the shell; this is the reason for the error message.

If you put the entire message inside single quotes, the value of x won't be substituted at the end. If you enclose the entire string in double quotes, both occurrences of $x will be substituted. Here are two different ways to do the quoting properly (realize that there are usually several different ways to quote a string of characters to get the results you want):

$ echo "<<< echo $x >>> displays the value of x, which is $x"
<<< echo $x >>> displays the value of x, which is 1
$ echo '<<< echo $x >>> displays the value of x, which is' $x
<<< echo $x >>> displays the value of x, which is 1
$

In the first case, everything is enclosed in double quotes, and the backslash is used to prevent the shell from performing variable substitution in the first instance of $x. In the second case, everything up to the last $x is enclosed in single quotes. If the variable x might have contained some filename substitution or whitespace characters, a safer way of writing the echo would have been

echo '<<< echo $x >>> displays the value of x, which is' "$x"

The back quote is unlike any of the previously encountered types of quotes. Its purpose is not to protect characters from the shell but to tell the shell to execute the enclosed command and to insert the standard output from the command at that point on the command line. The general format for using back quotes is

`command`

where command is the name of the command to be executed and whose output is to be inserted at that point.^[1]

Here is an example:

$ echo The date and time is: `date`
The date and time is: Wed Aug 28 14:28:43 EDT 2002
$

When the shell does its initial scan of the command line, it notices the back quote and expects the name of a command to follow. In this case, the shell finds that the date command is to be executed. So it executes date and replaces the `date` on the command line with the output from the date. After that, it divides the command line into arguments in the normal manner and then initiates execution of the echo command.

$ echo Your current working directory is `pwd`
Your current working directory is /users/steve/shell/ch6
$

Here the shell executes pwd, inserts its output on the command line, and then executes the echo. Note that in the following section, back quotes can be used in all the places where the $(...) construct is used.

The POSIX standard shell supports the newer $(...) construct for command substitution. The general format is

$(command)

where, as in the back quoting method, command is the name of the command whose standard output is to be substituted on the command line. For example:

$ echo The date and time is: $(date)
The date and time is: Wed Aug 28 14:28:43 EDT 2002
$

This construct is better than back quotes for a couple of reasons. First, complex commands that use combinations of forward and back quotes can be difficult to read, particularly if the typeface you're using doesn't have visually different single quotes and back quotes; second, $(...) constructs can be easily nested, allowing command substitution within command substitution. Although nesting can also be performed with back quotes, it's a little trickier. You'll see an example of nested command substitution later in this section.

You are not restricted to executing a single command between the parentheses: Several commands can be executed if separated by semicolons. Also, pipelines can be used. Here's a modified version of the nu program that displays the number of logged-in users:

$ cat nu
echo There are $(who | wc –l) users logged in
$ nu                    Execute it
There are 13 users logged in
$

Because single quotes protect everything, the following output should be clear:

$ echo '$(who | wc –l) tells how many users are logged in'
$(who | wc –l) tells how many users are logged in
$

But command substitution is interpreted inside double quotes:

$ echo "You have $(ls | wc –l) fi1es in your directory"
You have       7 files in your directory
$

(What causes those leading spaces before the 7?) Remember that the shell is responsible for executing the command enclosed between the parentheses. The only thing the echo command sees is the output that has been inserted by the shell.

Suppose that you're writing a shell program and want to assign the current date and time to a variable called now, perhaps to display it later at the top of a report, or log it into a file. The problem here is that you somehow want to take the output from date and assign it to the variable. Command substitution can be used for this:

$ now=$(date)          Execute date and store the output in now
$ echo $now          See what got assigned
Wed Aug 28 14:47:26 EDT 2002
$

When you write

now=$(date)

the shell realizes that the entire output from date is to be assigned to now. Therefore, you don't need to enclose $(date) inside double quotes.

Even commands that produce more than a single line of output can be stored inside a variable:

$ filelist=$(ls)
$ echo $filelist
addresses intro lotsaspaces names nu numbers phonebook stat
$

What happened here? You end up with a horizontal listing of the files even though the newlines from ls were stored inside the filelist variable (take our word for it). The newlines got eaten up when the value of filelist was substituted by the shell in processing the echo command line. Double quotes around the variable will preserve the newlines:

$ echo "$filelist"
addresses
intro
lotsaspaces
names
nu
numbers
phonebook
stat
$

To store the contents of a file into a variable, you can use cat:

$ namelist=$(cat names)
$ echo "$names"
Charlie
Emanuel
Fred
Lucy
Ralph
Tony
Tony
$

If you want to mail the contents of the file memo to all the people listed in the names file (who we'll assume here are users on your system), you can do the following:

$ mail $(cat names) < memo
$

Here the shell executes the cat and inserts the output on the command line so it looks like this:

mail Charlie Emanuel Fred Lucy Ralph Tony Tony < memo

Then it executes mail, redirecting its standard input from the file memo and passing it the names of seven users who are to receive the mail.

Notice that Tony receives the same mail twice because he's listed twice in the names file. You can remove any duplicate entries from the file by using sort with the -u option (remove duplicate lines) rather than cat to ensure that each person only receives mail once:

$ mail $(sort -u names) < memo
$

It's worth noting that the shell does filename substitution after it substitutes the output from commands. Enclosing the commands inside double quotes prevents the shell from doing the filename substitution on this output if desired.

Command substitution is often used to change the value stored in a shell variable. For example, if the shell variable name contains someone's name, and you want to convert every character in that variable to uppercase, you could use echo to get the variable to tr's input, perform the translation, and then assign the result back to the variable:

$ name="Ralph Kramden"
$ name=$(echo $name | tr '[a-z]' '[A-Z]')   Translate to uppercase
$ echo $name
RALPH KRAMDEN
$

The technique of using echo in a pipeline to write data to the standard input of the following command is a simple yet powerful technique; it's used often in shell programs.

The next example shows how cut is used to extract the first character from the value stored in a variable called filename:

$ filename=/users/steve/memos
$ firstchar=$(echo $filename | cut -c1)
$ echo $firstchar
/
$

sed is also often used to “edit” the value stored in a variable. Here it is used to extract the last character from the variable file:

$ file=exec.o
$ lastchar=$(echo $file | sed 's/.*(.)$/1/')
$ echo $lastchar
o
$

The sed command says to replace all the characters on the line with the last one. The result of the sed is stored in the variable lastchar. The single quotes around the sed command are important because they prevent the shell from messing around with the backslashes (would double quotes also have worked?).

Finally, command substitutions can be nested. Suppose that you want to change every occurrence of the first character in a variable to something else. In a previous example, firstchar=$(echo $filename | cut -c1) gets the first character from filename, but how do we use this character to change every occurrence in filename? A two-step process is one way:

$ filename=/users/steve/memos
$ firstchar=$(echo $filename | cut -c1)
$ filename=$(echo $filename | tr "$firstchar" "^")    translate / to ^
$ echo $filename
^users^steve^memos
$

Or a single, nested command substitution can perform the same operation:

$ filename=/users/steve/memos
$ filename=$(echo $filename | tr "$(echo $filename | cut -c1)" "^")
$ echo $filename
^users^steve^memos
$

If you have trouble understanding this example, compare it to the previous one: Note how the firstchar variable in the earlier example is replaced by the nested command substitution; otherwise, the two examples are the same.

Although the POSIX standard shell supports built-in integer arithmetic operations, older shells don't. It's likely that you may see command substitution with a Unix program called expr, which evaluates an expression given to it on the command line:

$ expr 1 + 2
3
$

Each operator and operand given to expr must be a separate argument, thus explaining the output from the following:

$ expr 1+2
1+2
$

The usual arithmetic operators are recognized by expr: + for addition, - for subtraction, / for division, * for multiplication, and % for modulus (remainder).

$ expr 10 + 20 / 2
20
$

Multiplication, division, and modulus have higher precedence than addition and subtraction. Thus, in the preceding example the division was performed before the addition.

$ expr 17 * 6
expr: syntax error
$

What happened here? The answer: The shell saw the * and substituted the names of all the files in your directory! It has to be quoted to keep it from the shell:

$ expr "17 * 6"
17 * 6
$

That's not the way to do it. Remember that expr must see each operator and operand as a separate argument; the preceding example sends the whole expression in as a single argument.

$ expr 17 * 6
102
$

Naturally, one or more of the arguments to expr can be the value stored inside a shell variable because the shell takes care of the substitution first anyway:

$ i=1
$ expr $i + 1
2
$

This is the older method for performing arithmetic on shell variables. Do the same type of thing as shown previously only use the command substitution mechanism to assign the output from expr back to the variable:

$ i=1
$ i=$(expr $i + 1)       Add 1 to i
$ echo $i
2
$

In legacy shell programs, you're more likely to see expr used with back quotes:

$ i=`expr $i + 1`       Add 1 to i
$ echo $i
3
$

Note that like the shell's built-in integer arithmetic, expr only evaluates integer arithmetic expressions. You can use awk or bc if you need to do floating point calculations. Also note that expr has other operators. One of the most frequently used ones is the : operator, which is used to match characters in the first operand against a regular expression given as the second operand. By default, it returns the number of characters matched.

The expr command

expr "$file" : ".*"

returns the number of characters stored in the variable file, because the regular expression .* matches all the characters in the string. For more details on expr, consult your Unix User's Manual.

Table A.5 in Appendix A summarizes the way quotes are handled by the shell.