07 - Control Statements

The last chapter, "Statements," discussed no-action, action, and modified statements. This chapter discusses three more types of statements: decision statements, loop statements, and jump statements.

The if statement lets you decide on one or more courses of actions. Loop statements are used to repeat a series of statements until a given condition is either true or false. And finally, we'll wrap up the chapter by looking at jump statements which let you control program flow by moving directly to the beginning or the end of a statement block.

Decision Statements

Example: The If Statement

if (CONDITION) {
    # Code block executed
    # if condition is true.
} else {
    # Code block executed
    # if condition is false.
}

if (CONDITION_ONE) {
    # Code block executed
    # if condition one is true.
} elsif (CONDITION_TWO) {
    # Code block executed
    # if condition two is true.
} else {
    # Code block executed
    # if all other conditions are false.
}

Pseudocode

Assign $firstVar a value of 10. Subtract five from $firstVar and if the resulting value is true (for instance, not zero) then execute the statement block.

$firstVar = 10;
if ($firstVar -= 5) {
    print("firstVar = $firstVar\n");
}

firstVar = 5

This example, in addition to demonstrating the use of assignment operators inside conditional expressions, also shows that the else part of the if statement is optional. If the else part was coded, then it would only be executed when $firstVar starts out with a value of 5.

Pseudocode

Assign $firstVar a value of 5. Subtract five from $firstVar and if the resulting value is true (in other words, not zero) then print $firstVar. If not, print "firstVar is zero".

$firstVar = 5;
if ($firstVar -= 5) {
    print("firstVar = $firstVar\n");
} else {
    print("firstVar is zero\n");
}

firstVar is zero

You can also use the if statement to select among multiple statement blocks. The if...elsif form of the statement is used for this purpose.

Pseudocode

Initialize $month to 2. If the value of $month is 1 then print January. Or else if the value of $month is 2 then print February. Or else if the value of $month is 3 then print March. For every other value of $month, print a message.

$month = 2;

if ($month == 1) {
    print("January\n");
}
elsif ($month == 2) {
    print("February\n");
}
elsif ($month == 3) {
    print("March\n");
}
else {
    print("Not one of the first three months\n");
}

February

Loop Statements

Example: While Loops

The do...while loop has this syntax:

do {
    STATEMENTS
} while (CONDITION);

while (CONDITION) {
    STATEMENTS
}
continue {
    STATEMENTS
}

Which type you use for any particular task is entirely dependent on your needs at the time. The statement block of a do...while loop always will be executed at least once. This is because the condition is checked after the statement block is executed rather than before. Here is an example of the do...while loop.

Pseudocode

Initialize $firstVar to 10. Start the do...while loop. Print the value of $firstVar. Increment $firstVar. Check the while condition, if true jump back to the start of the statement block. Print the value of $firstVar.

$firstVar = 10;
do {
    print("inside:  firstVar = $firstVar\n");
    $firstVar++;
} while ($firstVar < 2);

print("outside: firstVar = $firstVar\n");

inside:  firstVar = 10
outside: firstVar = 11

Pseudocode

Initialize $numPages to 10. Start the do...while loop. Print a page. Decrement $numPages and then loop if the condition is still true.

$numPages = 10;
do {
    printPage();
} while (--$numPages);

If you need to ensure that the statement block does not get executed then you need to use the while statement.

Pseudocode

Initialize $firstVar to 10. Start the while loop and test the condition. If false, don't execute the statement block. Print the value of $firstVar. Increment $firstVar. Jump back to the start of the statement block and test the condition again. Print the value of $firstVar.

$firstVar = 10;
while ($firstVar < 2) {
    print("inside:  firstVar = $firstVar\n");
    $firstVar++;
};
print("outside: firstVar = $firstVar\n");

outside: firstVar = 10

Pseudocode

Initialize $firstVar to 10. Start the while loop and test the condition. Print the value of $firstVar. Increment $firstVar. Jump back to the start of the statement block and test the condition again. Print the value of $firstVar.

$firstVar = 10;
while ($firstVar < 12) {
    print("inside:  firstVar = $firstVar\n");
    $firstVar++;
};
print("outside: firstVar = $firstVar\n");

inside:  firstVar = 10
inside:  firstVar = 11
outside: firstVar = 12

Example: Until Loops

The do...until loop has this syntax:

do {
    STATEMENTS
} until (CONDITION);

until (CONDITION) {
    STATEMENTS
}

Pseudocode

Initialize $firstVar to 10. Start the do..until loop. Print the value of $firstVar. Increment $firstVar. Check the until condition, if false jump back to the start of the statement block. Print the value of $firstVar.

$firstVar = 10;
do {
    print("inside:  firstVar = $firstVar\n");
    $firstVar++;
} until ($firstVar < 2);

print("outside: firstVar = $firstVar\n");

inside:  firstVar = 10
inside:  firstVar = 11
inside:  firstVar = 12
inside:  firstVar = 13
inside:  firstVar = 14
...

Tip

If you ever find it hard to understand a conditional expression in a loop statement, try the following: Wrap the entire condition expression inside parentheses and add == 1 to the right-hand side. So the above loop becomes do { ... } until (($firstVar < 2) == 1);

This example shows that the statement block is executed even though the condition $firstVar < 2 is false when the loop starts. The next example shows the until loop in action. Notice that the statement block does not execute because the conditional expression is false when the loop starts.

Pseudocode

Initialize $firstVar to 10. Start the until loop and test the condition. If true, don't execute the statement block. Print the value of $firstVar. Increment $firstVar. Jump back to the start of the statement block and test the condition again. Print the value of $firstVar.

$firstVar = 10;
until ($firstVar < 20) {
    print("inside:  firstVar = $firstVar\n");
    $firstVar++;
};
print("outside: firstVar = $firstVar\n");

outside: firstVar = 10

Pseudocode

Initialize $firstVar to 10. Start the while loop and test the condition. Print the value of $firstVar. Increment $firstVar. Jump back to the start of the statement block and test the condition again. Print the value of $firstVar.

$firstVar = 10;
until ($firstVar > 12) {
    print("inside:  firstVar = $firstVar\n");
    $firstVar++;
};
print("outside: firstVar = $firstVar\n");

inside:  firstVar = 10
inside:  firstVar = 11
inside:  firstVar = 12
outside: firstVar = 13

Example: For Loops

for (INITIALIZATION; CONDITION; INCREMENT/DECREMENT) {
    STATEMENTS
}

When initializing variables, be sure not to confuse the equality operator (==) with the assignment operator (=). The following is an example of what this error could look like:

for ($index == 0; $index < 0; $index++)

The condition expression is used to determine whether the loop should continue or be ended. When the condition expression evaluates to false, the loop will end.

The increment/decrement expression is used to modify the loop variables in some way each time the code block has been executed. Here is an example of a basic for loop.

Pseudocode

Start the for loop by initializing $firstVar to zero. The $firstVar variable will be incremented each time the statement block is executed. And the statement block will be executed as long as $firstVar is less than 100. Print the value of $firstVar each time through the loop.

for ($firstVar = 0; $firstVar < 100; $firstVar++) {
    print("inside:  firstVar = $firstVar\n");
}

inside:  firstVar = 0
inside:  firstVar = 1
...
inside:  firstVar = 98
inside:  firstVar = 99

For loops can also be used to count backwards.

Pseudocode

Start the for loop by initializing $firstVar to 100. The $firstVar variable will be decremented each time the statement block is executed. And the statement block will be executed as long as $firstVar is greater than 0. Print the value of $firstVar each time through the loop.

for ($firstVar = 100; $firstVar > 0; $firstVar--) {
    print("inside:  firstVar = $firstVar\n");
}

inside:  firstVar = 100
inside:  firstVar = 99
...
inside:  firstVar = 2
inside:  firstVar = 1

Pseudocode

Start the for loop by initializing $firstVar to 100 and $secondVar to 0. The $firstVar variable will be decremented and $secondVar will be incremented each time the statement block is executed. And the statement block will be executed as long as $firstVar is greater than 0. Print the value of $firstVar and $secondVar each time through the loop.

for ($firstVar = 100, $secondVar = 0;
     $firstVar > 0;
     $firstVar--, $secondVar++) {

        print("inside:  firstVar = $firstVar  secondVar = $secondVar\n");

}

inside:  firstVar = 100  secondVar = 0
inside:  firstVar = 99  secondVar = 1
...
inside:  firstVar = 2  secondVar = 98
inside:  firstVar = 1  secondVar = 99

A more common use of the comma operator might be to initialize some flag variables that you expect the loop to change. This next example will read the first 50 lines of a file. If the end of the file is reached before the last line is read, the $endOfFile flag variable will be set to 1.

Pseudocode

Start the for loop by initializing the end of file flag variable to zero to indicate false then set $firstVar to 0. The $firstVar variable will be incremented each time the statement block is executed. And the statement block will be executed as long as $firstVar is less than 50. Print the value of $firstVar and $secondVar each time through the loop.

for ($endOfFile = 0, $firstVar = 0; $firstVar < 50;
    $firstVar++, $secondVar++) {
    if (readLine() == 0)
        $endOfFile = 1;
}

Example: Foreach Loops

foreach LOOP_VAR (ARRAY) {
    STATEMENTS
}

Pseudocode

Call the max() function twice with different parameters each time. Define the max() function. Create a local variable, $max, then get the first element from the parameter array. Loop through the parameter array comparing each element to $max. If the current element is greater than $max. Return the value of $max.

print max(45..121, 12..23) . "\n";
print max(23..34, 356..564) . "\n";

sub max {
    my($max) = shift(@_);

    foreach $temp (@_) {
        $max = $temp if $temp > $max;
    }
    return($max);
}

121
564

There are a couple of important things buried in this example. One is the use of the shift() function to assign a value to a local variable and remove the first element of the parameter array from the array at the same time. If you use shift() all by itself, the value of the first element is lost.

The other important thing is the use of $temp inside the foreach loop. Some Perl programmers dislike using temporary variables in this manner. When the foreach loop is over, the local $temp variable is destroyed. Perl has an internal variable, $_, that can be used instead. If no loop variable is specified, $_ will be assigned the value of each array element as the loop iterates.

Pseudocode

Print the return value from the max() function. Define the max() function. Create a local variable, $max, then get the first element from the parameter array. Loop through the parameter array comparing each element to $max. If the current element is greater than $max: Return the value of $max.

print max(45..121, 12..23) . "\n";
print max(23..34, 356..564) . "\n";

sub max {
    my($max) = shift(@_);

    foreach (@_) {
        $max = $_ if $_ > $max;
    }
    return($max);
}

$max = $_ if $max < $_;

Now for the fourth, and final, item regarding this small program. Notice that the function name and the local variable name are the same except for the beginning dollar sign. This shows that function names and variable names use different namespaces.

Remember namespaces? They were mentioned in Chapter 3, "Variables".

Using the foreach statement requires using a little bit of caution because the local variable (either $_ or the one you specify) accesses the array elements using the call by reference scheme. When call by reference is used, changing the value in one place (such as inside the loop) also changes the value in the main program.

Pseudocode

Create an array from 1 to 10 with 5 repeated. Print the array. Loop through the array replacing any elements equal to 5 with "**". Print the array.

@array = (1..5, 5..10);
print("@array\n");

foreach (@array) {
    $_ = "**" if ($_ == 5);
}
print("@array\n");

1 2 3 4 5 5 6 7 8 9 10
1 2 3 4 ** ** 6 7 8 9 10

Jump Keywords

Table 7.1 - Perl's Jump Keywords

Keywords	Description
last	Jumps out of the current statement block.
next	Skips the rest of the statement block and continues with the next iteration of the loop.
redo	Restarts the statement block.
goto	Jumps to a specified label.

Each of these keywords is described further in its own section which follows.

Example: The last Keyword

Pseudocode

Create an array holding all 26 letters. Use a for loop to iterate over the array. The index variable will start at zero and increment while it is less than the number of elements in the array. Test the array element to see if it is equal to "T". Notice that the string equality operator is used. If the array element is "T", then exit the loop.

@array = ("A".."Z");
for ($index = 0; $index < @array; $index++) {
    if ($array[$index] eq "T") {
        last;
    }
}
print("$index\n");

19

When the last keyword is executed, the conditional expression and the increment/decrement expression are not re-evaluated, the statement block is just left. Execution begins again immediately after the ending curly brace.

You can also use a label with the last keyword to indicate which loop to exit. A label is a name followed by a colon. Labels names usually use all capital letters, but Perl does not insist on it. When you need to exist a nested loop, labels are a big help. Let's look at this situation in two steps. Here is a basic loop.

Pseudocode

Loop from 0 to 10 using $index as the loop variable. If $index is equal to 5 then exit the loop. Print the value of $index while inside the loop. Print the value of $index after the loop ends.

for ($index = 0; $index < 10; $index++) {
    if ($index == 5) {
        last;
    }
    print("loop: index = $index\n");
}
print("index = $index\n");

loop: index = 0
loop: index = 1
loop: index = 2
loop: index = 3
loop: index = 4
index = 5

Pseudocode

Specify a label called OUTER_LOOP. Loop from 0 to 10 using $index as the loop variable. If $index is equal to 5 then exit the loop. Start an inner loop that repeat while $index is less than 10. If $index is 4 then exit out of both inner and outer loops. Increment $index. Print the value of $index.

OUTER_LOOP:
    for ($index = 0; $index < 10; $index++) {
        if ($index == 5) {
            last;
        }
        while ($index < 10) {
            if ($index == 4) {
                last OUTER_LOOP;
            }
            print("inner: index = $index\n");
            $index++;
        }
       print("outer: index = $index\n");
}
print("index = $index\n");

inner: index = 0
inner: index = 1
inner: index = 2
inner: index = 3
index = 4

Example: The next Keyword

Pseudocode

Create an array of 10 elements. Print the array. Iterate over the array. Ignore the 3rd and 5th element. Change the current element to an asterisk. Print the array to verify that it has been changed.

@array = (0..9);
print("@array\n");
for ($index = 0; $index < @array; $index++) {
    if ($index == 3 || $index == 5) {
        next;
    }
    $array[$index] = "*";
}
print("@array\n");

0 1 2 3 4 5 6 7 8 9
* * * 3 * 5 * * * *

Pseudocode

Define a label called OUTER_LOOP. Start a for loop that iterates from 0 to 3 using $row as the loop variable. Start a for loop that iterates from 0 to 3 using $col as the loop variable. Display the values of $row and $col and mention that the code is inside the inner loop. If $col is equal to 1, start the next iteration of loop near the label OUTER_LOOP. Display the values of $row and $col and mention that the code is inside the outer loop.

OUTER_LOOP: for ($row = 0; $row < 3; $row++) {
                for ($col = 0; $col < 3; $col++) {
                    print("inner: $row,$col\n");
                    if ($col == 1) {
                        next OUTER_LOOP;
                    }
                }
                print("outer: $row,$col\n\n");
            }

inner: 0,0
inner: 0,1
inner: 1,0
inner: 1,1
inner: 2,0
inner: 2,1

Example: The redo Keyword

This example will demonstrate the redo keyword with some keyboard input.

Pseudocode

Start a statement block. Print a prompt asking for a name. Read a string from the keyboard. Control is returned to the program when the user of the program presses the enter key. Remove the newline character from the end of the string. If the string has zero length it means the user simply pressed the enter key without entering a name, so display an error message and redo the statement block. Print a thank you message with the name in upper-case characters.

{
    print("What is your name? ");
    $name = <STDIN>;
    chop($name);

    if (! length($name)) {
        print("Msg: Zero length input. Please try again\n");
        redo;
    }

    print("Thank you, " . uc($name) . "\n");
}

The redo statement helps you to have more straightforward program flow. Without it, you would need to use a do...until loop. For example:

Pseudocode

Start a do...until statement. Print a prompt asking for a name. Read a string from the keyboard. Control is returned to the program when the user of the program presses the enter key. Remove the newline character from the end of the string. If the string has zero length it means the user simply pressed the enter key without entering a name, so display an error message. Evaluate the conditional expression. If true, then the user entered a name and the loop can end. Print a thank you message with the name in upper-case characters.

do {
    print("What is your name? ");
    $name = <STDIN>;
    chomp($name);

    if (! length($name)) {
        print("Msg: Zero length input. Please try again\n");
    }

} until (length($name));


print("Thank you, " . uc($name) . "\n");

Example: The goto Keyword

Summary

The if statement can be used with an else clause to choose one of two statement blocks to execute. Or you can use the elsif clause to choose from among more than two statement blocks.

Both the while and until loop statements have two forms. One form (the do... form) executes a statement block and then tests a conditional expression and the other form tests the condition before executing the statement block.

The for loops are the most complicated type of loop because they involve three expressions in addition to a statement block. There is an initialization expression, an conditional expression, and an increment/decrement expression. The initialization expression is evaluated first, then the conditional expression. If the conditional expression is false, the statement block is executed. Next the increment/decrement expression is evaluated and the loop starts again with the conditional expression.

Foreach loops are used to iterate through an array. Each element in the array is assigned to a local variable as the loop progresses through the array. If you don't specify a local variable, Perl will use the $_ special variable. You need to be careful when changing the value of the local variable because it uses the call by reference scheme. Therefore, any change to the local variable will be reflected in the value of the array element outside the foreach loop.

The last keyword is used to jump out of the current statement block. The next keyword is used to skip the rest of the statement block and continue to the next iteration of the loop. The redo keyword is used to restart the statement block. And finally, the goto keyword should not be used because the other jump keywords are more descriptive. All of the jump keywords can be used with labels so they can be used inside nested loops.

Review Questions

1. What are the four loop keywords?

2. What are the four jump keywords?

3. Which form of the until statement is used when the statement block needs to be executed at least once?

4. What will be displayed when this program executes?

   $firstVar = 5;
   {
       if ($firstVar > 10) {
           last;
       }
       $firstVar++;
       redo;
   }
   print("$firstVar\n");

5. What is the default name of the local variable in the foreach loop?

6. How is the next keyword different from the redo keyword?

7. Why is the comma operator useful in the initialization expression of a for loop?

8. What is the shift() function used for?

Review Exercises

1. Use the while loop in a program to count from 1 to 100 in steps of 5.

2. Use the for loop in a program to print each number from 55 to 1.

3. Use an until loop, the next statement and the modulus operator to loop from 0 to 100 and print out "AAA" every 16th iteration.

4. Use the foreach loop to determine the smallest element in an array.

5. Use a for loop to iterate over an array and multiply each element by 3.

6. Use a do..until loop and the each() function to iterate over an associative array looking for an value equal to "AAA". When the element is found, the loop should be ended.