7.5 Conditionals

7.5.1 && and || Logical Constructs

There are two quick one-line conditional constructs that you may see from time to time: && ("and") and || ("or").

The && construct works like this:

command1 && command2

Here, the shell runs command1, and if the exit code is 0, it also runs command2.

The || construct is similar; if the command before a || returns a nonzero exit code, the shell runs the second command.

&& and || often find their way into use in if tests. In both cases, the exit code of the last command run determines how the shell processes the conditional. In &&, if the first command fails, the shell uses its exit code for the if statement, but if the first command is successful, the shell uses the exit code of the second command for the conditional. For ||, the shell uses the exit code of the first command if successful, or the exit code of the second if the first is unsuccessful.

Here is an example:

#!/bin/sh
if [ "$1" = hi ] || [ "$1" = bye ]; then
    echo 'The first argument was "'$1'"'
fi

If your conditionals include the test ([) command (as here), you can use -a and -o instead of && and ||, as described in the next section.

7.5.2 Testing Conditions

You have already seen how [ works; the exit code is 0 if the test is true and nonzero when the test fails. You also know how to test string equality with [ str1 = str2 ].

However, remember that shell scripts are well suited to operations on entire files. An important reason for this is that the most useful [ tests involve file properties. For example, the following line checks whether file is a regular file (not a directory or special file):

[ -f file ]

In a script, you might see the -f test in a loop similar to this next one, which tests all of the items in the current working directory:

for filename in *; do
    if [ -f $filename ]; then
        ls -l $filename
        file $filename
    else
        echo $filename is not a regular file.
    fi
done

You can invert a test by placing the ! operator before the test. For example, [ ! -f file ] returns true if file is not a regular file. Furthermore, the -a and -o flags are the and and or operators (for example, [ -f file1 -a file2 ]).

There are dozens of test operations that fall into three general categories: file tests, string tests, and arithmetic tests. The info pages contain complete online documentation, but the test(1) manual page is also a fast reference. The following sections outline the main tests (some of the less common tests have been omitted).

[ file1 -nt file2 ]

7.5.3 Matching Strings with case

The case keyword forms another conditional construct that is exceptionally useful for matching strings. case does not execute any test commands and therefore does not evaluate exit codes. Here is an example that should tell most of the story:

#!/bin/sh
case $1 in
    bye)
        echo Fine, bye.
        ;;
    hi|hello)
        echo Nice to see you.
        ;;
    what*)
        echo Whatever.
        ;;
    *)
        echo 'Huh?'
        ;;
esac

The shell executes this as follows:

1. The script matches $1 against each case value demarcated with the) character.

2. If a case value matches $1, the shell executes the commands below the case until encountering ;;. The shell then skips to the esac keyword.

3. The conditional ends with esac.

For each case value, you can match a single string (such as bye in the preceding example), multiple strings with | (hi|hello returns true if $1 equals hi or hello), or make use of the * or ? wildcards (what*). If you want to make a case that catches all possible values other than the case values specified, use a single *, as shown by the final case in the preceding example.