{"id":37,"date":"2018-10-20T08:00:00","date_gmt":"2018-10-20T00:00:00","guid":{"rendered":""},"modified":"2018-11-11T16:10:58","modified_gmt":"2018-11-11T08:10:58","slug":"the-linux-command-line-flow-control-part-2","status":"publish","type":"post","link":"https:\/\/yeslq.com\/?p=37","title":{"rendered":"The Linux Command Line—Flow Control – Part 2"},"content":{"rendered":"

The Linux Command Line <\/a><\/i>by William Shotts<\/span><\/h1>\n

<\/span><\/div>\n
<\/p>\n
Hold on to your hats. This lesson is going to be a big one!<\/div>\n

More Branching<\/h2>\n
In the previous lesson on flow control<\/a> we learned about the if<\/tt> command and how it is used to alter program flow based on a command’s exit status. In programming terms, this type of program flow is called branching<\/i> because it is like traversing a tree. You come to a fork in the tree and the evaluation of a condition determines which branch you take.<\/div>\n
There is a second and more complex kind of branching called a case<\/i>. A case is multiple-choice branch. Unlike the simple branch, where you take one of two possible paths, a case supports several possible outcomes based on the evaluation of a value.<\/div>\n
You can construct this type of branch with multiple if<\/tt> statements. In the example below, we evaluate some input from the user:<\/div>\n
\n
#!\/bin\/bash

echo<\/tt> -n \"Enter a number between 1 and 3 inclusive > \"
read<\/tt> character
if<\/tt> [<\/tt> \"$character\" = \"1\" ];<\/tt> then<\/tt>
    echo<\/tt> \"You entered one.\"
elif<\/tt> [<\/tt> \"$character\" = \"2\" ];<\/tt> then<\/tt>
    echo<\/tt> \"You entered two.\"
elif<\/tt> [<\/tt> \"$character\" = \"3\" ];<\/tt> then<\/tt>
    echo<\/tt> \"You entered three.\"
else<\/tt>
    echo<\/tt> \"You did not enter a number between 1 and 3.\"
fi<\/tt>
<\/tt>
<\/pre>\n<\/div>\n
Not very pretty.<\/div>\n
Fortunately, the shell provides a more elegant solution to this problem. It provides a built-in command called case<\/a><\/tt>, which can be used to construct an equivalent program:<\/div>\n
\n
#!\/bin\/bash

echo<\/tt> -n \"Enter a number between 1 and 3 inclusive > \"
read<\/tt> character
case<\/tt> $character in<\/tt>
    1 ) echo<\/tt> \"You entered one.\"
        ;;
    2 ) echo<\/tt> \"You entered two.\"
        ;;
    3 ) echo<\/tt> \"You entered three.\"
        ;;
    * ) echo<\/tt> \"You did not enter a number between 1 and 3.\"
esac<\/tt>
       <\/tt>
<\/pre>\n<\/div>\n
The case<\/tt> command has the following form:<\/div>\n
\n
case<\/tt> word in<\/tt>
    patterns )<\/tt> commands ;;<\/tt>
esac<\/tt>
       <\/tt>
<\/pre>\n<\/div>\n
case<\/tt> selectively executes statements if word matches a pattern. You can have any number of patterns and statements. Patterns can be literal text or wildcards. You can have multiple patterns separated by the “|<\/tt>” character. Here is a more advanced example to show what I mean:<\/div>\n
\n
#!\/bin\/bash

echo<\/tt> -n \"Type a digit or a letter > \"
read<\/tt> character
case<\/tt> $character in<\/tt>
                                # Check for letters
    [[:lower:]] | [[:upper:]] ) echo<\/tt> \"You typed the letter $character\"
                                ;;

                                # Check for digits
    [0-9] )                     echo<\/tt> \"You typed the digit $character\"
                                ;;

                                # Check for anything else
    * )                         echo<\/tt> \"You did not type a letter or a digit\"
esac<\/tt>
<\/tt>
<\/pre>\n<\/div>\n
Notice the special pattern “*<\/tt>“. This pattern will match anything, so it is used to catch cases that did not match previous patterns. Inclusion of this pattern at the end is wise, as it can be used to detect invalid input.<\/div>\n
Loops<\/h2>\n
The final type of program flow control we will discuss is called looping<\/i>. Looping is repeatedly executing a section of your program based on the exit status of a command. The shell provides three commands for looping: while<\/tt>, until<\/tt> and for<\/tt>. We are going to cover while<\/tt> and until<\/tt> in this lesson and for<\/tt> in a upcoming lesson.<\/div>\n
The while<\/tt> command causes a block of code to be executed over and over, as long as the exit status of a specified command is true. Here is a simple example of a program that counts from zero to nine:<\/div>\n
\n
#!\/bin\/bash

number=0
while<\/tt> [<\/tt> \"$number\" -lt 10 ];<\/tt> do<\/tt>
    echo<\/tt> \"Number = $number\"
    number=$((number + 1))
done<\/tt>
       <\/tt>
<\/pre>\n<\/div>\n
On line 3, we create a variable called number<\/tt> and initialize its value to 0. Next, we start the while<\/tt> loop. As you can see, we have specified a command that tests the value of number<\/tt>. In our example, we test to see if number<\/tt> has a value less than 10.<\/div>\n
Notice the word do<\/tt> on line 4 and the word done<\/tt> on line 7. These enclose the block of code that will be repeated as long as the exit status remains zero.<\/div>\n
In most cases, the block of code that repeats must do something that will eventually change the exit status, otherwise you will have what is called an endless loop<\/i>; that is, a loop that never ends.<\/div>\n
In the example, the repeating block of code outputs the value of number<\/tt> (the echo<\/tt> command on line 5) and increments number<\/tt> by one on line 6. Each time the block of code is completed, the test command’s exit status is evaluated again. After the tenth iteration of the loop, number<\/tt> has been incremented ten times and the test<\/tt> command will terminate with a non-zero exit status. At that point, the program flow resumes with the statement following the word done<\/tt>. Sincedone<\/tt> is the last line of our example, the program ends.<\/div>\n
The until<\/tt> command works exactly the same way, except the block of code is repeated as long as the specified command’s exit status is false. In the example below, notice how the expression given to the test<\/tt> command has been changed from the while<\/tt> example to achieve the same result:<\/div>\n
\n
#!\/bin\/bash

number=0
until<\/tt> [<\/tt> \"$number\" -ge 10 ];<\/tt> do<\/tt>
    echo<\/tt> \"Number = $number\"
    number=$((number + 1))
done<\/tt>
       <\/tt>
<\/pre>\n<\/div>\n
Building A Menu<\/h2>\n
One common way of presenting a user interface for a text based program is by using a menu<\/i>. A menu is a list of choices from which the user can pick.<\/div>\n
In the example below, we use our new knowledge of loops and cases to build a simple menu driven application:<\/div>\n
\n
#!\/bin\/bash

selection=
until<\/tt> [<\/tt> \"$selection\" = \"0\" ];<\/tt> do<\/tt>
    echo<\/tt> \"
    PROGRAM MENU
    1 - Display free disk space
    2 - Display free memory

    0 - exit program
\"
    echo<\/tt> -n \"Enter selection: \"
    read<\/tt> selection
    echo<\/tt> \"\"
    case<\/tt> $selection in<\/tt>
        1 ) df ;;
        2 ) free ;;
        0 ) exit<\/tt> ;;
        * ) echo<\/tt> \"Please enter 1, 2, or 0\"
    esac<\/tt>
done<\/tt>
       <\/tt>
<\/pre>\n<\/div>\n
The purpose of the until<\/tt> loop in this program is to re-display the menu each time a selection has been completed. The loop will continue until selection is equal to “0,” the “exit” choice. Notice how we defend against entries from the user that are not valid choices.<\/div>\n
To make this program better looking when it runs, we can enhance it by adding a function that asks the user to press the Enter key after each selection has been completed, and clears the screen before the menu is displayed again. Here is the enhanced example:<\/div>\n
\n
#!\/bin\/bash

press_enter()
{
    echo<\/tt> -en \"nPress Enter to continue\"
    read<\/tt>
    clear
}

selection=
until<\/tt> [<\/tt> \"$selection\" = \"0\" ];<\/tt> do<\/tt>
    echo<\/tt> \"
    PROGRAM MENU
    1 - display free disk space
    2 - display free memory

    0 - exit program
\"
    echo<\/tt> -n \"Enter selection: \"
    read<\/tt> selection
    echo<\/tt> \"\"
    case<\/tt> $selection in<\/tt>
        1 ) df ;<\/tt> press_enter ;;
        2 ) free ;<\/tt> press_enter ;;
        0 ) exit<\/tt> ;;
        * ) echo<\/tt> \"Please enter 1, 2, or 0\"; press_enter
    esac<\/tt>
done<\/tt>
<\/tt>
<\/pre>\n<\/div>\n

<\/p>\n
\n
When your computer hangs…<\/h2>\n
We have all had the experience of an application hanging<\/i>. Hanging is when a program suddenly seems to stop and become unresponsive. While you might think that the program has stopped, in most cases, the program is still running but its program logic is stuck in an endless loop.
Imagine this situation: you have an external device attached to your computer, such as a USB disk drive but you forgot to turn it on. You try and use the device but the application hangs instead. When this happens, you could picture the following dialog going on between the application and the interface for the device:<\/p>\n
Application:    Are you ready?
Interface:  Device not ready.

Application:    Are you ready?
Interface:  Device not ready.

Application:    Are you ready?
Interface:  Device not ready.

Application:    Are you ready?
Interface:  Device not ready.
<\/tt>
<\/pre>\n
and so on, forever.
Well-written software tries to avoid this situation by instituting a timeout<\/i>. This means that the loop is also counting the number of attempts or calculating the amount of time it has waited for something to happen. If the number of tries or the amount of time allowed is exceeded, the loop exits and the program generates an error and exits.<\/div>\n
<\/div>\n
<\/span><\/div>\n","protected":false},"excerpt":{"rendered":"
The Linux Command Line by William Shotts Hold on t … \u9605\u8bfb\u66f4\u591a<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3,4,6],"tags":[],"class_list":["post-37","post","type-post","status-publish","format-standard","hentry","category-linux","category-shell","category-the-linux-command-line"],"_links":{"self":[{"href":"https:\/\/yeslq.com\/index.php?rest_route=\/wp\/v2\/posts\/37","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/yeslq.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/yeslq.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/yeslq.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/yeslq.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=37"}],"version-history":[{"count":1,"href":"https:\/\/yeslq.com\/index.php?rest_route=\/wp\/v2\/posts\/37\/revisions"}],"predecessor-version":[{"id":98,"href":"https:\/\/yeslq.com\/index.php?rest_route=\/wp\/v2\/posts\/37\/revisions\/98"}],"wp:attachment":[{"href":"https:\/\/yeslq.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=37"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/yeslq.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=37"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/yeslq.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=37"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}