The general form of the while loop is

Use a while loop whenever the loop exit is controlled by an external event, or when the amount of data to be processed is large, or when the things to iterate on are read from a file or from a pipe. (We will go over using pipes and files with while loops in the next module.) 

I will divide the major uses of a while loop into two groups:

• repetition of a larger action - this can take the form of a loop around a large block of code, even around an entire shell program.
• ensuring that some value is usable - this can be used to verify a particular data value is correct before proceedinig

We will use second case to discuss the while loop and learn some of its intricies. 

Using a while loop to validate data

In our previous  shell scripts, many events were fatal. This is common in a command-line program, where there is not the ability to request corrected data. In an interactive program, however, if the user enters an incorrect data value, we could certainly ask them to re-enter it. Let's consider a snippet of shell code:

This is rather unfortunate. The user made a typo well into the program and we just had to give up. Adding a while loop allows us to repeat the question until the input is valid. Here is the algorithm:

Let's look at such a loop in actual code:

Going over a few issues about this loop we notice:

• the loop body contains a statement that can result in stopping the loop. This, remember, is what is necessary for avoiding an infinite loop.
• the loop is very simple and readable.
• there is a problem when the loop is first encountered: will it be entered? if so, the error message is output before the new filename is requested.

This last issue can be resolved by repeating the input question outside the loop:

Much better. Although we have to repeat a bit of the loop code outside the loop, this loop is very clear and quite compact. This occurred because the code to verify the data was incorrect was simple and there was no preparation for re-entering it. The harder it is to determine the data is bad, the more difficult it is to write a simple loop like this or the more code must be repeated outside of the loop.

Controlling the loop with continue and break

To see this, consider what would happen if we added a single requirement on $file: that it contained a particular type of data, say, it was a colon-delimited file with four fields. We could still write the loop, but it would be very ugly

This worked, but what do we do about the error message? When we enter the loop each time, we do not know which error caused the failure unless we repeat some of the code. This gets worse as the complexity increases.

Although it is an affront to everything you would learn in other programming classes, while loops in the shell are often written as infinite loops with multiple exit points. This is accomplished by the use of two statements: break and continue

Execution of a break command causes the exit of the most recently entered while loop. Execution of a continue command causes the termination of the current iteration, and the beginning of a new iteration. 

In our loop, we will use break in the loop body to exit the loop. This means that our controlling expression should be something that always succeeds. You have two choices here:

• the null command : OR
• the command true

We will use true as it makes the loop easier to read: while true

Now that our loop is always entered, we have no need of repititious code outside the loop. A little restructuring and we have

Another slight modification makes this loop even simpler:

Although this is less structured according to standard programming practices it has several advantages:

• there is no repetition of code
• it is easier to add complexity to the loop control
• although the multiple exit points merit caution when reading the loop, using break and continue often requires less code

Let's look at a slightly different case to illustrate these points. We will write a loop that repeatedly asks the user for a filename, then, once the filename is verified as being a readable file, displays the file. The loop will stop when the user enters an empty filename. 

First, let's write the loop using a controlling command

Not bad, really. This was pretty easy to write in the standard way. Let's look at how this could be written using an infinite loop:

You could certainly argue that the first method was more straightforward. However, existing shell scripts will favor the second form. Why? Well, when we get to more complicated loops it will be more obvious that restricting the loop control to the top of the loop creates problems as there are often several loop conditions that need testing during each iteration. Any of these loop conditions may force the end of the loop or the beginning of another iteration. Also, shell programmers have a fondness for concise cryptic code, which this certainly is.

Another issue should be mentioned here: the fondness of shell programmers for the && and || construct. Any if statement with a single command in the then or else clause will be written as a && or || statement. If you are not comfortable with that syntax, practice it.

Processing commandline arguments

The while loop is often the loop of choice for processing commandline arguments, as it avoids the problem with retokenization of the command-line that we will see with the for loop, and it allows the analysis of complex options that take more than one commandline argument.

The algorithm for processing commandline arguments in a while loop goes like this:

Here, deciding what to do with it could involve setting a flag to indicate the option was seen, saving the option in a variable, or outputting an error message. Let's try a simple example:

You are writing a shell script whileex1 that takes two options and one required directory. The options are -x and -y, each is independent, and optional. The directory is to be used to store file(s) resulting from the execution of whileex1, so it must be writable. As will all Unix commands, the paths must follow the options. Write the code to process the arguments for whileex1

Since we only have two options, we will use an if construct to handle it. Let's discuss the types of questions we must ask:

• is it -x? if so, set a flag variable (a variable we will use to indicate whether the option was seen or not).
• is it -y? if so, set a flag variable likewise.
• is it the path? If so, we must be at the end of the arguments, and it must be a writable directory.
• after the arguments are processed we must check to ensure the directory argument was seen.

Here is some sample code for this problem:

There are several things to note about whileex1:

• the flag variables "look like" Boolean variables. They are not. All variables in shell are strings, we are just using the strings false and true as special values to assign to our flag variables to make the shell script more readable. 
• if the user enters an illegal option, it will be treated as the name of the target directory. We will fix this problem shortly.
• the shell script gives up at the first error. This is not the best behavior. We would like to give the user as much information as possible about their errors before aborting. We will fix this problem shortly.
• multiple instances of -x or -y are ignored. This is probably okay. Alternately you could check the value of the variable keeping track of the option. If the option has already been seen, you could issue a warning about redundant options.

First, let's fix the issue about assuming the first illegal argument is the filename. The more conservative approach is to assume any argument with a leading dash is an option, and to complain about illegal options. Let's first modify the existing code. This is whileex2:

But our code still gives up at the first error. To fix this problem, we will have to delay exiting until we have examined all the arguments and detected all the possible errors. When we detect an error we will set a flagvariable errors to indicate an error was found and use this flag to exit after the loop is complete. The variable errors will be set by our function error:

Our shell script looks better. However, if we add any options to it, it requires modifying our if statement. The typical way to write option-handling code is with a case statement. Let's rewrite this code using a case statement and see how it looks:

Adding a new option to our shell program now just involves adding a new clause on our case statement. One last thing: our syntax message is output once per error. This is kind of silly. The syntax message should be output once when the shell script aborts. Can you fix this?

The examples whileex* are in this module's directory beneath examples on our public data area on hills.

The until loop

The until loop is very similar to the while loop. The only difference is the loop condition. The while loop repeats while the loop condition succeeds. The until loop continues until the loop condition succeeds. We will illustrate by rewriting our first example of a while loop:

Choosing a while or until loop

Any time you have a loop that must repeat until some external event occurs, you must use a while or until loop. It is often easier to design the loop as an infinite loop. Just be sure to alter the loop exit condition (or to use break) during the loop. while and until loops are also the loops of choice for processing command-line arguments.

Copyright 2010 Greg Boyd - All Rights Reserved.