[EnglishFrontPage] [TitleIndex] [WordIndex] 

<- Patterns | Arrays ->

Tests and Conditionals

Contents

  1. Exit Status
  2. Control Operators (&& and ||)
  3. Grouping Statements
  4. Conditional Blocks (if, test and [[)
  5. Conditional Loops (while, until and for)
  6. Choices (case and select)

Sequential execution of commands is one thing, but to achieve any advanced logic in your scripts or your command line one-liners, you'll need tests and conditionals. Tests determine whether something is true or false. Conditionals are used to make decisions which determine the execution flow of a script.

1. Exit Status

Every command results in an exit code whenever it terminates. This exit code is used by whatever application started it to evaluate whether everything went OK. This exit code is like a return value from functions. It's an integer between 0 and 255 (inclusive). Convention dictates that we use 0 to denote success, and any other number to denote failure of some sort. The specific number is entirely application-specific, and is used to hint as to what exactly went wrong.

For example, the ping command sends ICMP packets over the network to a certain host. That host normally responds to this packet by sending the exact same one right back. This way, we can check whether we can communicate with a remote host. ping has a range of exit codes which can tell us what went wrong, if anything did:

From the Linux ping manual:

The special parameter ? shows us the exit code of the last foreground process that terminated. Let's play around a little with ping to see its exit codes: 

    $ ping God
    ping: unknown host God
    $ echo $?
    2
    $ ping -c 1 -W 1 1.1.1.1
    PING 1.1.1.1 (1.1.1.1) 56(84) bytes of data.
    --- 1.1.1.1 ping statistics ---
    1 packets transmitted, 0 received, 100% packet loss, time 0ms
    $ echo $?
    1

2. Control Operators (&& and ||)

Now that we know what exit codes are, and that an exit code of '0' means the command's execution was successful, we'll learn to use this information. The easiest way of performing a certain action depending on the success of a previous command is through the use of control operators. These operators are && and ||, which respectively represent a logical AND and a logical OR. These operators are used between two commands, and they are used to control whether the second command should be executed depending on the success of the first. This concept is called conditional execution.

Let's put that theory in practice: 

    $ mkdir d && cd d

This simple example has two commands, mkdir d and cd d. You could use a semicolon there to separate the commands and execute them sequentially; but we want something more. In the above example, BASH will execute mkdir d, then && will check the result of the mkdir application after it finishes. If the mkdir application was successful (exit code 0), then Bash will execute the next command, cd d. If mkdir d failed, and returned a non-0 exit code, Bash will skip the next command, and we will stay in the current directory.

Another example: 

    $ rm /etc/some_file.conf || echo "I couldn't remove the file"
    rm: cannot remove `/etc/some_file.conf': No such file or directory
    I couldn't remove the file

|| is much like &&, but it does the exact opposite. It only executes the next command if the first failed. As such, the message is only echoed if the rm command was unsuccessful.

In general, it's not a good idea to string together multiple different control operators in one command (we will explore this in the next section). && and || are quite useful in simple cases, but not in complex ones. In the next few sections we'll show some other tools you can use for decision-making.

3. Grouping Statements

Using conditional operators is easy and terse if we want to do simple error checking. Things get a bit more dangerous, though, when we want to run multiple statements if a condition holds true, or if we need to evaluate multiple conditions.

Suppose you want to delete a file if it contains a certain "good" word but also doesn't contain another "bad" word. Using grep (a command that checks its input for patterns), we translate these conditions to: 

    grep -q goodword "$file"            # exit status 0 (success) if "$file" contains 'goodword'
    ! grep -q "badword" "$file"         # exit status 0 (success) if "$file" does not contain 'badword'

We use -q (quiet) on grep because we don't want it to output the lines that match; we just want the exit code to be set.

The ! in front of a command causes Bash to negate the command's exit status. If the command returns 0 (success), the ! turns it into a failure. Likewise, if the command returns non-zero (failure), the ! turns it into a success.

Now, to put these conditions together and delete the file as a result of both holding true, we could use Conditional Operators: 

    $ grep -q goodword "$file" && ! grep -q badword "$file" && rm "$file"

This works great. (In fact, we can string together as many && as we want, without any problems.) Now, imagine we want to show an error message in case the deletion of the file failed: 

    $ grep -q goodword "$file" && ! grep -q badword "$file" && rm "$file" || echo "Couldn't delete: $file" >&2

This looks OK, at first sight. If rm's exit code is not 0 (success), then the || operator will trigger the next command and echo the error message (>&2: to standard error).

But there's a problem. When we have a sequence of commands separated by Conditional Operators, Bash looks at every one of them, in order from left to right. The exit status is carried through from whichever command was most recently executed, and skipping a command doesn't change it.

So, imagine the first grep fails (sets the exit status to 1). Bash sees a && next, so it skips the second grep altogether. Then it sees another &&, so it also skips the rm which follows that one. Finally, it sees a || operator. Aha! The exit status is "failure", and we have a ||, so Bash executes the echo command, and tells us that it couldn't delete a file -- even though it never actually tried to! That's not what we want.

This doesn't sound too bad when it's just a wrong error message you receive, but if you're not careful, this will eventually happen on more dangerous code. You wouldn't want to accidentally delete files or overwrite files as a result of a failure in your logic!

The failure in our logic is in the fact that we want the rm and the echo statements to belong together. The echo is related to the rm, not to the greps. So what we need is to group them. Grouping is done using curly braces: 

    $ grep -q goodword "$file" && ! grep -q badword "$file" && { rm "$file" || echo "Couldn't delete: $file" >&2; }

(Note: don't forget that you need a semicolon or newline before the closing curly brace!)

Now we've grouped the rm and echo command together. That effectively means the group is considered one statement instead of several. Going back to our situation of the first grep failing, instead of BASH trying the && rm "$file" statement, it will now try the && { ... } statement. Since it is preceded by a && and the last command it ran failed (the failed grep), it will skip this group and move on.

Command grouping can be used for more things than just Conditional Operators. We may also want to group them so that we can redirect input to a group of statements instead of just one: 

    {
        read firstLine
        read secondLine
        while read otherLine; do
            something
        done
    } < file

Here we're redirecting file to a group of commands that read input. The file will be opened when the command group starts, stay open for the duration of it, and be closed when the command group finishes. This way, we can keep sequentially reading lines from it with multiple commands.

Another common use of grouping is in simple error handling: 

    cd "$appdir" || { echo "Please create the appdir and try again" >&2; exit 1; }

4. Conditional Blocks (if, test and [[)

if is a shell keyword that executes a command (or a set of commands), and checks that command's exit code to see whether it was successful. Depending on that exit code, if executes a specific, different, block of commands. 

    $ if true
    > then echo "It was true."
    > else echo "It was false."
    > fi
    It was true.

Here you see the basic outline of an if-statement. We start by calling if with the command true. true is a builtin command that always ends successfully. if runs that command, and once the command is done, if checks the exit code. Since true always exits successfully, if continues to the then-block, and executes that code. Should the true command have failed somehow, and returned an unsuccessful exit code, the if statement would have skipped the then code, and executed the else code block instead.

Different people have different preferred styles for writing if statements. Here are some of the common styles: 

    if COMMANDS
    then OTHER COMMANDS
    fi

    if COMMANDS
    then
        OTHER COMMANDS
    fi

    if COMMANDS; then
        OTHER COMMANDS
    fi

There are some commands designed specifically to test things and return an exit status based on what they find. The first such command is test (also known as [). A more advanced version is called [[. [ or test is a normal command that reads its arguments and does some checks with them. [[ is much like [, but it's special (a shell keyword), and it offers far more versatility. Let's get practical: 

    $ if [ a = b ]
    > then echo "a is the same as b."
    > else echo "a is not the same as b."
    > fi
    a is not the same as b.

if executes the command [ (remember, you don't need an if to run the [ command!) with the arguments a, =, b and ]. [ uses these arguments to determine what must be checked. In this case, it checks whether the string a (the first argument) is equal (the second argument) to the string b (the third argument), and if this is the case, it will exit successfully. However, since we know this is not the case, [ will not exit successfully (its exit code will be 1). if sees that [ terminated unsuccessfully and executes the code in the else block.

Now, to see why [[ is so much more interesting and trustworthy than [, let us highlight some possible problems with [: 

    $ myname='Greg Wooledge' yourname='Someone Else'
    $ [ $myname = $yourname ]
    -bash: [: too many arguments

Can you guess what caused the problem?

[ was executed with the arguments Greg, Wooledge, =, Someone, Else and ]. That is 6 arguments, not 4! [ doesn't understand what test it's supposed to execute, because it expects either the first or second argument to be an operator. In our case, the operator is the third argument. Yet another reason why quotes are so terribly important. Whenever we type whitespace in Bash that belongs together with the words before or after it, we need to quote it, and the same thing goes for parameter expansions: 

    $ [ "$myname" = "$yourname" ]

This time, [ sees an operator (=) in the second argument and it can continue with its work.

To help us out a little, the Korn shell introduced (and BASH adopted) a new style of conditional test. Original as the Korn shell authors are, they called it [[. [[ is loaded with several very interesting features which are missing from [.

One of the features of [[ is pattern matching: 

    $ [[ $filename = *.png ]] && echo "$filename looks like a PNG file"

Another feature of [[ helps us in dealing with parameter expansions: 

    $ [[ $me = $you ]]           # Fine.
    $ [[ I am $me = I am $you ]] # Not fine!
    -bash: conditional binary operator expected
    -bash: syntax error near `am'

This time, $me and $you did not need quotes. Since [[ isn't a normal command (like [ is), but a shell keyword, it has special magical powers. It parses its arguments before they are expanded by Bash and does the expansion itself, taking the result as a single argument, even if that result contains whitespace. (In other words, [[ does not allow word-splitting of its arguments.) However, be aware that simple strings still have to be quoted properly. [[ can't know whether your literal whitespace in the statement is intentional or not; so it splits it up just like BASH normally would. Let's fix our last example: 

    $ [[ "I am $me" = "I am $you" ]]

Also; there is a subtle difference between quoting and not quoting the right-hand side of the comparison in [[. The = operator does pattern matching by default, whenever the right-hand side is not quoted: 

    $ foo=[a-z]* name=lhunath
    $ [[ $name = $foo   ]] && echo "Name $name matches pattern $foo"
    Name lhunath matches pattern [a-z]*
    $ [[ $name = "$foo" ]] || echo "Name $name is not equal to the string $foo"
    Name lhunath is not equal to the string [a-z]*

The first test checks whether $name matches the pattern in $foo. The second test checks whether $name is equal to the string in $foo. The quotes really do make that much difference -- a subtlety worth noting.

Remember: Always quote stuff if you are unsure. If foo really contains a pattern instead of a string (a rare thing to want -- you would normally write the pattern out literally: [[ $name = [a-z]* ]]), you will get a safe error here and you can come and fix it. If you neglect to quote, bugs can become very hard to find, since the broken code may not fail immediately.

You could also combine several if statements into one using elif instead of else, where each test indicates another possibility: 

    $ name=lhunath
    $ if [[ $name = "George" ]]
    > then echo "Bonjour, $name"
    > elif [[ $name = "Hans" ]]
    > then echo "Goeie dag, $name"
    > elif [[ $name = "Jack" ]]
    > then echo "Good day, $name"
    > else
    > echo "You're not George, Hans or Jack.  Who the hell are you, $name?"
    > fi

Now that you've got a decent understanding of quoting issues that may arise, let's have a look at some of the other features that [ and [[ were blessed with:

Some examples? Sure: 

    $ test -e /etc/X11/xorg.conf && echo 'Your Xorg is configured!'
    Your Xorg is configured!
    $ test -n "$HOME" && echo 'Your homedir is set!'
    Your homedir is set!
    $ [[ boar != bear ]] && echo "Boars aren't bears."
    Boars aren't bears!
    $ [[ boar != b?ar ]] && echo "Boars don't look like bears."
    $ [[ $DISPLAY ]] && echo "Your DISPLAY variable is not empty, you probably have Xorg running."
    Your DISPLAY variable is not empty, you probably have Xorg running.
    $ [[ ! $DISPLAY ]] && echo "Your DISPLAY variable is not not empty, you probably don't have Xorg running."

5. Conditional Loops (while, until and for)

Now you've learned how to make some basic decisions in your scripts. However, that's not enough for every kind of task we might want to script. Sometimes we need to repeat things. For that, we need to use a loop. There are two basic kinds of loops (plus a couple variants), and using the correct kind of loop will help you keep your scripts readable and maintainable.

The two basic kinds of loops are called while and for. The while loop has a variant called until which simply reverses its check; and the for loop can appear in two different forms. Here's a summary:

Each loop form is followed by the key word do, then one or more commands in the body, then the key word done. The do and done are similar to the then and fi (and possible elif and/or else) from the if statement we saw earlier. Their job is to tell us where the body of the loop begins and ends.

In practice, the loops are used for different kinds of tasks. The for loop (first form) is appropriate when we have a list of things, and we want to run through that list sequentially. The while loop is appropriate when we don't know exactly how many times we need to repeat something; we simply want it to keep going until we find what we're looking for.

Here are some examples to illustrate the differences and also the similarities between the loops. (Remember: on most operating systems, you press Ctrl-C to kill a program that's running on your terminal.) 

    $ while true
    > do echo "Infinite loop"
    > done

    $ while ! ping -c 1 -W 1 1.1.1.1; do
    > echo "still waiting for 1.1.1.1"
    > sleep 1
    > done

    $ (( i=10 )); while (( i > 0 ))
    > do echo "$i empty cans of beer."
    > (( i-- ))
    > done
    $ for (( i=10; i > 0; i-- ))
    > do echo "$i empty cans of beer."
    > done
    $ for i in {10..1}
    > do echo "$i empty cans of beer."
    > done

The last three loops achieve exactly the same result, using different syntax. You'll encounter this many times in your shell scripting experience. There will nearly always be multiple approaches to solving a problem. The test of your skill soon won't be about solving a problem as much as about how best to solve it. You must learn to pick the best angle of approach for the job. Usually, the main factors to take into account will be the simplicity and flexibility of the resulting code. My personal favorite is the last of the examples. In that example I used Brace Expansion to generate the words; but there are other ways, too.

Let's take a closer look at that last example, because although it looks the easier of the two fors, it can often be the trickier, if you don't know exactly how it works.

As I mentioned before: for runs through a list of words and puts each one in the loop index variable, one at a time, and then loops through the body with it. The tricky part is how BASH decides what the words are. Let me explain myself by expanding the braces from that previous example: 

    $ for i in 10 9 8 7 6 5 4 3 2 1
    > do echo "$i empty cans of beer."
    > done

BASH takes the characters between in and the end of the line, and splits them up into words. This splitting is done on spaces and tabs, just like argument splitting. However, if there are any unquoted substitutions in there, they will be word-split as well (using IFS). All these split-up words become the iteration elements.

As a result, be VERY careful not to make the following mistake: 

    $ ls
    The best song in the world.mp3
    $ for file in $(ls *.mp3)
    > do rm "$file"
    > done
    rm: cannot remove `The': No such file or directory
    rm: cannot remove `best': No such file or directory
    rm: cannot remove `song': No such file or directory
    rm: cannot remove `in': No such file or directory
    rm: cannot remove `the': No such file or directory
    rm: cannot remove `world.mp3': No such file or directory

You should already know to quote the $file in the rm statement; but what's going wrong here? BASH expands the command substitution ($(ls *.mp3)), replaces it by its output, and then performs word splitting on it (because it was unquoted). Essentially, Bash executes for file in The best song in the world.mp3. Boom, you are dead.

You want to quote it, you say? Let's add another song: 

    $ ls
    The best song in the world.mp3  The worst song in the world.mp3
    $ for file in "$(ls *.mp3)"
    > do rm "$file"
    > done
    rm: cannot remove `The best song in the world.mp3  The worst song in the world.mp3': No such file or directory

Quotes will indeed protect the whitespace in your filenames; but they will do more than that. The quotes will protect all the whitespace from the output of ls. There is no way BASH can know which parts of the output of ls represent filenames; it's not psychic. The output of ls is a simple string, and BASH treats it as such. The for puts the whole quoted output in i and runs the rm command with it. Damn, dead again.

So what do we do? As suggested earlier, globs are your best friend: 

    $ for file in *.mp3
    > do rm "$file"
    > done

This time, BASH does know that it's dealing with filenames, and it does know what the filenames are, and as such it can split them up nicely. The result of expanding the glob is this: for file in "The best song in the world.mp3" "The worst song in the world.mp3". Problem solved!

Now let's look at the while loop. The while loop is very interesting for its capacity to execute commands until something interesting happens. Here are a few examples of how while loops are very often used: 

    $ # The sweet machine; hand out sweets for a cute price.
    $ while read -p $'The sweet machine.\nInsert 20c and enter your name: ' name
    > do echo "The machine spits out three lollipops at $name."
    > done

    $ # Check your email every five minutes.
    $ while sleep 300
    > do kmail --check
    > done

    $ # Wait for a host to come back online.
    $ while ! ping -c 1 -W 1 "$host"
    > do echo "$host is still unavailable."
    > done; echo -e "$host is available again.\a"

The until loop is barely ever used, if only because it is pretty much exactly the same as while !. We could rewrite our last example using an until loop: 

    $ # Wait for a host to come back online.
    $ until ping -c 1 -W 1 "$host"
    > do echo "$host is still unavailable."
    > done; echo -e "$host is available again.\a"

In practice, most people simply use while ! instead.

Lastly, you can use the continue builtin to skip ahead to the next iteration of a loop without executing the rest of the body, and the break builtin to jump out of the loop and continue with the script after it. This works in both for and while loops.

6. Choices (case and select)

Sometimes you want to build application logic depending on the content of a variable. This could be implemented by taking a different branch of an if statement depending on the results of testing against a glob: 

    shopt -s extglob

    if [[ $LANG = en* ]]; then
        echo 'Hello!'
    elif [[ $LANG = fr* ]]; then
        echo 'Salut!'
    elif [[ $LANG = de* ]]; then
        echo 'Guten Tag!'
    elif [[ $LANG = nl* ]]; then
        echo 'Hallo!'
    elif [[ $LANG = it* ]]; then
        echo 'Ciao!'
    elif [[ $LANG = es* ]]; then
        echo 'Hola!'
    elif [[ $LANG = @(C|POSIX) ]]; then
        echo 'hello world'
    else
        echo 'I do not speak your language.'
    fi

But all these comparisons are a bit redundant. BASH provides a keyword called case exactly for this kind of situation. A case statement basically enumerates several possible Glob Patterns and checks the content of your parameter against these: 

    case $LANG in
        en*) echo 'Hello!' ;;
        fr*) echo 'Salut!' ;;
        de*) echo 'Guten Tag!' ;;
        nl*) echo 'Hallo!' ;;
        it*) echo 'Ciao!' ;;
        es*) echo 'Hola!' ;;
        C|POSIX) echo 'hello world' ;;
        *)   echo 'I do not speak your language.' ;;
    esac

Each choice in a case statement consists of a pattern (or a list of patterns with | between them), a right parenthesis, a block of code that is to be executed if the string matches one of those patterns, and two semi-colons to denote the end of the block of code (since you might need to write it on several lines). case stops matching patterns as soon as one is successful. Therefore, we can use the * pattern in the end to match any case that has not been caught by the other choices.

Another construct of choice is the select construct. This statement smells like a loop and is a convenience statement for generating a menu of choices that the user can choose from.

The user is presented by choices and asked to enter a number reflecting his choice. The code in the select block is then executed with a variable set to the choice the user made. If the user's choice was invalid, the variable is made empty: 

    $ echo "Which of these does not belong in the group?"; \
    > select choice in Apples Pears Crisps Lemons Kiwis; do
    > if [[ $choice = Crisps ]]
    > then echo "Correct!  Crisps are not fruit."; break; fi
    > echo "Errr... no.  Try again."
    > done

The menu reappears so long as the break statement is not executed. In the example the break statement is only executed when the user makes the correct choice.

We can also use the PS3 variable to define the prompt the user replies on. Instead of showing the question before executing the select statement, we could choose to set the question as our prompt: 

    $ PS3="Which of these does not belong in the group (#)? "; \
    > select choice in Apples Pears Crisps Lemons Kiwis; do
    > if [[ $choice = Crisps ]]
    > then echo "Correct!  Crisps are not fruit."; break; fi
    > echo "Errr... no.  Try again."
    > done

All of these conditional constructs (if, for, while, and case) can be nested. This means you could have a for loop with a while loop inside it, or any other combination, as deeply as you need to solve your problem. 

    # A simple menu:
    while true; do
        echo "Welcome to the Menu"
        echo "  1. Say hello"
        echo "  2. Say good-bye"

        read -p "-> " response
        case $response in
            1) echo 'Hello there!' ;;
            2) echo 'See you later!'; break ;;
            *) echo 'What was that?' ;;
        esac
    done

<- Patterns | Arrays ->

2012-07-01 04:05