Here is an example of setting the value of a shell variable:

$ color=blue
							

This sets the variable color to the string blue. One can output the value of any variable with the echo command:

$ echo $color
blue

This also indicates how to reference a shell variable: It must be preceded by the dollar sign ($). This can cause some problems.

If you are using a shell variable as a prefix, and you want to append text immediately, you might think that this would work:

$ leaning='anti-'
$ echo Joe is basically $leaningtaxes
							

The output here is just Joe is basically. The shell does not know to differentiate between the variables $leaning and what appears to be a new variable, $leaningtaxes. Because no value is assigned to $leaningtaxes, the output is a NULL string. To solve this problem, enclose the variable in curly braces.

$ echo Joe is basically ${leaning}taxes
Joe is basically anti-taxes

If leaning is undefined, the output might not make sense. It would be Joe is basically taxes. Fortunately, the shell provides a means to have a default value if a variable is undefined:

$ echo Joe is basically ${leaning:-pro }taxes
Joe is basically pro taxes

If leaning is undefined, the :- syntax tells the shell to use the following string, including the space character, instead of leaving the output blank. This does not assign a new value to the variable. If you need to use the variable repeatedly, you might want to assign a new value to it, if it is undefined. The = character does this:

$ echo Joe is basically ${leaning=pro }taxes and ${leaning}spending.
Joe is basically pro taxes and pro spending.

The first interpretation of the variable finds it undefined, so the shell assigns “pro ” (pro with a trailing space) to the variable and outputs that. The second time the variable is interpreted, it has the value “pro ”.

Variables often are assigned by the read command. This assigns an individual word to a specified variable, with the last variable in the list being assigned the remaining words.

$ read city state message
CapeMay, New Jersey Hi Mom!
$ echo $city is city
CapeMay, is city
$ echo $state is state
New is state
$ echo $message is message
Jersey Hi Mom! is message

As you can see, only New is assigned to state. The best way around this is to escape the space (make sure that the space isn't interpreted as separating variable values) with a backslash:

$ read city state message
CapeMay, NewJersey Hi Mom!
$ echo $city is city
CapeMay, is city
$ echo $state is state
New Jersey is state
$ echo $message is message
Hi Mom! is message

This can be a bit tricky at first.

The third common way to assign variables is from command-line arguments. The shell has built-in variables to access the command line. If you've written a script to copy files and named it copy-files, you might want to list all the files on the command line:

$ copy-files file1 file2 file3
							

The program would access these arguments as $1, $2, and $3:

cp $1 destination
cp $2 destination
cp $3 destination

The $0 variable is a special case for looking at the command name, and $* lists all the command-line variables.

If a shell is assigned a numeric value, you can perform some basic arithmetic on the value by using the command expr. This command takes several arguments to perform arithmetic:

$ expr 1 + 1
2

Arguments must be separated by spaces, and present, for the expr command to work. If a variable is undefined or does not have a value assigned to it (sometimes called zero length), the result is a syntax error. Here is where the :- syntax is particularly helpful:

$ expr $undef + 1
expr: syntax error
$ expr ${undef:-0}  + 1
1

expr also supports subtraction, multiplication, integer division, and remainders. These are illustrated here:

$ expr 11 - 5
6
$ expr 11 '*' 5
55
$ expr 11 / 5
2
$ expr 11 % 5
1

Note that I had to include the asterisk in single quotation marks. If I didn't do that, the shell would expand it to be the list of files in the current directory, and the expr program wouldn't understand that.

You can assign the results of the arithmetic to other variables by enclosing the command in backquotes:

$ newvalue=`expr ${oldvalue:-0) + 1`
							

If oldvalue is assigned, it is incremented by 1. If not, newvalue is set to 1. This is useful when looping through data for a number of iterations.

The expr command also can work with complex arithmetic. You can write an expression to add two numbers and then multiply by a third number. Normally, you would need to worry about operator precedence, but expr is not that sophisticated. Instead, you just group the operations in parentheses:

$ expr ( 11 + 5 ) * 6
2

This command first adds 11 and 5, then multiplies the result by 6. Because the parentheses are important shell characters, I need to escape them with backslashes.

Because the shell treats the less-than and greater-than symbols as redirection characters, they can't be used within the test command. Instead, I have a series of two-letter flags, as described in Table 15.1. These flags are always placed between the two arguments:

test 3 -eq 4

This example would return false because 3 and 4 are not equal.

You can use the result of expr, or any other command that returns a numeric value, in test. There is also a special expression in test, -l string, that returns the length of a string. So you can write the following tests:

test $value -eq -l $string
test `wc -l filename` -ge 10000

The first test determines whether $value is the same as the length of $string. The second takes a count of the number of lines in a file, and it is true if 10,000 or more lines are present.

The second type of comparison is on strings. The first two are unary, which means they apply to only one string:

test -z $string
test -n $string

The first test is true if the string is of zero length or undefined. The second is true if the string has some content.

The next two tests compare strings with each other. The simple equals sign and the exclamation point (commonly used to mean “not!” in UNIX) are used for these comparisons:

test alphabet = Alphabet
test alphabet != Alphabet

The first is false; the second is true.

The final test operators work on the file system. They are single flags, as listed in Table 15.2, followed by a path.

Here's a sample test:

test -d $HOME/bin

This checks to see whether you have a directory named bin in your home directory. The most common flags you see in shell programs are the -f flag and the -d flag. The others are used only in unusual situations.

The file system also has three binary comparisons. The -ef test determines whether the two files are the same. (When you create a link between files, this is true.) The -nt flag is true if the first file is newer than the second, and the -ot flag is true if the first file is older than the second. You might see a test in a looping statement like this:

test file1 -ot file2
							

This test compares the two files, and it is true if file1 is older than file2. If you are waiting for data to appear in file1, you might use this test to cause a shell program to wait for the first file to appear.

Test commands can be negated with the exclamation point, or combined with -a for and, and -o for or. You can make arbitrarily long conditions, at the cost of readability:

test $var -eq 0 -a ! -e file
							

This checks to see whether the value of $var is zero, and whether file exists.

test also has a second form. Instead of explicitly calling test, you can surround the condition by square brackets:

[ -f file ]

Doing this makes shell programs more readable.

The if command is the most commonly seen conditional command. It takes the following form:

if
    command-block
then
    command-block
fi

A command-block is a sequence of one or more shell commands. The first command-block is always executed. The return value of the last statement executed is used to determine whether the second block is executed. The most commonly used command at the end of the first command-block is the test command in its [] notation:

if
    [ -f $file ]
then
    echo $file is a regular file
fi

This if statement notifies the user that a file is a regular file. If the file is not a regular file (such as a directory), you don't see output.

Sometimes, you may want output regardless of the situation. In the preceding case, you may be interested in the status of the file even if it is not a regular file. The if command can expand with the else keyword to provide that second option:

if
    [ -f $file ]
then
    echo $file is a regular file
else
    echo $file is not a regular file
fi

This statement provides output regardless of the status of the file.

For these simple tests and output, the shell provides a second, quicker means of executing the if statement. If the two commands are joined by &&, the second command is executed if the first command is true. If the commands are joined by ||, the second command is executed if the first is false. The preceding command would, therefore, look like:

[ -f $file ] && echo $file is a regular file
[ -f $file ] || echo $file is not a regular file

This shorthand is very useful but can be confusing for a novice. If you accidentally place a space between the characters, you have a wildly different command; the & will run the first command at the same time as the echo, and the | will pipe the output of the test (none) to the echo.

If you want even more information, your if statement can have more than two options. You need multiple tests and the elif keyword:

if
    [ -f $file ]
then
    echo $file is a regular file
elif
    [ -d $file ]
then
    echo $file is a directory
else
    echo $file is not a regular file or a directory.
fi

This command first tests to see whether the file is a regular file; if not, it checks to see whether it is a directory; if it is neither, it gives output. You can expand any if statement with an unlimited number of elif branches.

At some point, though, the code will become confusing. When you have many possible branches, you should use the case command. The syntax is more complicated than that for if:

case string in
pattern) command-block ;;
pattern) command-block ;;
...
esac

If you were looking for possible values for a variable, you could use case:

echo What do you want:
read var remainder
case $var in
house) echo The price must be very high;;
car) echo The price must be high;;
popsicle) echo The price must be low;;
*) echo I do not know the price;;
esac

This case statement follows an input request and gives the user a rough idea of the price. A case list can contain any number of items.

The pattern-matching algorithms used are for wildcards.

The usual command for a determinate loop is the for command. It has the following syntax:

for var in list
do
    command-block
done

You can build any list you like. It could be a sequence of numbers or the output of a command. Earlier, I mentioned looping through a list of files. This is performed with the following loop:

for var in 'ls'
do
    if
        [ -f $var ]
    then
        echo $var is a regular file
    fi
done

This steps through all the files listed in the 'ls' output, showing only regular files.

A nice trick that can be performed in a shell program is to step through the list of command-line arguments. The for loop provides a neat mechanism: If the in list part is omitted from the command, the for loop steps through the list of command-line arguments.

j=0
for i
do
   j=`expr $j + 1`
    echo $i is argument $j
done

This snippet steps through the command-line arguments and identifies where they are in the order of arguments.

In both cases, when you enter the for loop, you know how many times you need to run the loop. If you look at the case where you are waiting for something to happen, though, you need to use a different loop. The while loop is the solution for this problem.

In Task 15.3, I mentioned the case where you might want to wait on the arrival of a file. This echoes a real-world situation I recently faced. We were processing a program log file, but we did not know exactly when it would be placed in our directory. We tried to set up the job to run after the file arrived, but this approach still ran into problems.

Using the while loop, we solved the problem. At the end of the execution of our script, we created a checkpoint file. At the beginning, if the checkpoint file was newer than the log file, we would wait. Programmatically, that is:

while
    [ checkpoint -nt logfile ]
do
    sleep 60
done

This program would wait one minute between checks. If the new logfile had not been written, the program would go back to sleep for a minute.

While loops also can be used in a determinate manner. In the case where you are not concerned with a variable's value, but know a count of times to run a command-block, you can use a counter to increment through the number:

i=0
while
    [ $i -lt 100 ]
do
    i=`expr "$i" + 1`
    commands
done

This is certainly easier than listing 100 items in a list!