Unlike general-purpose languages such as C and Java, a Bourne shell conditional command does not take a Boolean (true/false) expression. Rather, it takes a Unix command, and the decision is based on the exit status of that command. The general syntax of a Bourne shell family conditional is shown below. Note that there can be an unlimited number of elifs, but we will use only one for this example.

#!/bin/sh -e

if command1; then   # Command1 succeeded (exit status was 0)
    command
    command
    ...
elif command2; then # Command2 succeeded (exit status was 0)
    command
    command
    ...
else                # All commands above failed
    command
    command
    ...
fi
                

In the example above, the if command executes command1 and checks the exit status when it completes. If the exit status is 0 (indicating success), then all the commands before the elif are executed, and everything after the elif is skipped.

If the exit status is non-zero, then nothing above the elif is executed. The elif command then executes command2 and checks its exit status.

If the exit status of command2 is 0, then the commands between the elif and the else are executed and everything after the else is skipped.

If the exit status of command2 is non-zero, everything above the else is skipped and everything between the else and the fi is executed.

In most programming languages, we use some sort of Boolean expression (usually a comparison, also known as a relation), not a command, as the condition for an if statement. This is generally true in Bourne shell scripts as well, but the capability is provided in an interesting way. We'll illustrate by showing an example and then explaining how it works.

Suppose we have a shell variable and we want to check whether it contains the string "blue". We could use the following if command to test:

#!/bin/sh -e

printf "Enter the name of a color: "
read color

if [ "$color" = "blue" ]; then
    printf "You entered blue.\n"
elif [ "$color" = "red" ]; then
    printf "You entered red.\n"
else
    printf "You did not enter blue or red.\n"
fi

This may look like it violates what we just stated; that Bourne shell conditionals take a command, not a Boolean expression. The interesting thing about this code is that the square brackets are not Bourne shell syntax.

The '[' in the conditional above is actually an external command. In fact, it is simply another name for the test command. The files /bin/test and /bin/[ are actually links the same executable file:

shell-prompt: ls -l /bin/test /bin/[
-r-xr-xr-x  2 root  wheel  8516 Apr  9  2012 /bin/[*
-r-xr-xr-x  2 root  wheel  8516 Apr  9  2012 /bin/test*
                

We could have also written the following, to make it more obvious that we are actually running another command in the if command:

if test "$color" = "blue"; then
                

Hence, '$color', '=', 'blue', and ']' are arguments to the '[' command, and must be separated by white space. If the command is invoked as '[', it requires the last argument to be ']'. If invoked as 'test', the ']' is not allowed.

The test command can be used to perform comparisons (relational operations) on variables and constants, as well as a wide variety of tests on files. For comparisons, test takes three arguments: the first and third are string values and the second is a relational operator.

# Compare a variable to a string constant
test "$name" = 'Bob'
[ "$name" = 'Bob' ]
                

# Compare the output of a program directly to a string constant
test `myprog` = 42
[ `myprog` = 42 ]
                

For file tests, test takes two arguments: The first is a flag indicating which test to perform and the second is the path name of the file or directory.

# See if output file exists and is readable to the user
# running test
test -r output.txt
[ -r output.txt ]
                

The exit status of test is 0 (success) if the test is deemed to be true and a non-zero value if it is false.

shell-prompt: test 1 = 1
shell-prompt: echo $?   # Or $status for C shell
0
shell-prompt: test 1 = 2
shell-prompt: echo $?   # Or $status for C shell
1
                

The relational operators supported by test are shown in Table 4.5, “Test Command Relational Operators”.

[ 10 > 9 ]
test 10 > 9     # Redirects output to a file called '9'.
                # The only argument sent to the test command is '10'.
                # The test command issues an error message since it
                # did not receive enough arguments.

[ 10 \> 9 ]
test 10 \> 9    # Compares 10 to 9

[ 10 '>' 9 ]
test 10 '>' 9   # Compares 10 to 9
                

Common file tests are shown in Table 4.6, “Test command file operations”. To learn about additional file tests, run man test.

name=""
if [ "$name" = "Bob" ]; then    # Error, expands to: if [ = Bob; then
if [ 0"$name" = 0"Bob" ]; then  # OK, expands to: if [ 0 = 0Bob ]; then
                

Relational operators are provided by the test command, not by the shell. Hence, to find out the details, we would run "man test" or "man [", not "man sh" or "man bash".

which [ test
test 1 = 1
test 1=2
test 1 = 2
[ 1 = 1
[ 1 = 1 ]
[ 2 < 10 ]
[ 2 \< 10 ]
[ 2 -lt 10 ]
name=''             # Bourne shell only
set name=''         # C shell only
[ $name = Bill ]
[ 0$name = 0Bill ]
name=Bob            # Bourne shell only
set name=Bob        # C shell only
[ $name = Bill ]
[ $name = Bob ]
                    

Unlike the Bourne shell family of shells, the C shell family implements its own conditional expressions and operators, so there is generally no need for the test or [ command, though you can use it in C shell scripts if you really want to.

The C shell if command requires () around the condition, and the condition is a Boolean expression, just like in C and similar languages. As in C, and unlike Bourne shell, a value of zero is considered false and non-zero is true.

#!/bin/csh -ef

printf "Enter the name of a color: "
set color = "$<"

if ( { test "$color" \< blue } ) then
    printf "Yup.\n"
endif

if ( "$color" == "blue" ) then
    printf "You entered blue.\n"
else if ( "$color" == "red" ) then
    printf "You entered red.\n"
else
    printf "You did not enter blue or red.\n"
endif

The C shell relational operators are shown in Table 4.7, “C Shell Relational Operators”.

C shell if commands also need soft quotes around strings that contain white space. However, unlike the test command, it can handle empty strings, so we don't need to add an arbitrary prefix like '0' if the string may be empty.

if [ 0"$name" = 0"Bob" ]; then
                

if ( "$name" == "Bob" ) then
                

The most readable way to check the status of a command in C shell is using the status variable. Note that we need to avoid invoking csh with -e so that the shell process will not terminate when a command fails.

#!/bin/csh -f

command1
if ( $status == 0 ) then
    # Stuff to do only if command1 succeeded
else
    exit 1  # Exit on error since we did not use #!/bin/csh -e
endif