You could even have an else clause with an unless. While this syntax is supported, it’s potentially confusing:

unless ($mon =~ /^(Feb)/) {
  print "This month has at least thirty days.
";
} else {
  print "Do you see what's going on here?
";
}

Some people may wish to use this, especially when the first clause is very short (perhaps only one line) and the second is several lines of code. But we’d make this one a negated if, or maybe simply swap the clauses to make a normal if :

if ($mon =~ /^(Feb)/) {
  print "Do you see what's going on here?
";
} else {
  print "This month has at least thirty days.
";
}

It’s important to remember that you’re always writing code for two readers: the computer that will run the code and the human being who has to keep the code working. If the human can’t understand what you’ve written, pretty soon the computer won’t be doing the right thing either.

You can fetch the value of a variable and change that value at the same time. Put the ++ operator in front of the variable name to increment the variable first and then fetch its value. This is a preincrement :

my $a = 5;
my $b = ++$a;  # increment $a to 6, and put that value into $b

Or put the -- operator in front to decrement the variable first and then fetch its value. This is a predecrement:

my $c = --$a;  # decrement $a to 5, and put that value into $c

Here’s the tricky part. Put the variable name first to fetch the value first, and then do the increment or decrement. This is called a postincrement or postdecrement:

my $d = $a++;  # $d gets the old value (5), then increment $a to 6
my $e = $a--;  # $e gets the old value (6), then decrement $a to 5

It’s tricky because we’re doing two things at once. We’re fetching the value, and we’re changing it in the same expression. If the operator is first, we increment (or decrement) first, then use the new value. If the variable is first, we return its (old) value first, then do the increment or decrement. Another way to say it is that these operators return a value, but they also have the side effect of modifying the variable’s value.

If you write these in an expression of their own,^[7] not using the value but only the side effect, there’s no difference^[8] whether you put the operator before or after the variable:

$bedrock++;  # adds one to $bedrock
++$bedrock;  # just the same; adds one to $bedrock

A common use of these operators is in connection with a hash, to identify when an item has been seen before:

my @people = qw{ fred barney bamm-bamm wilma dino barney betty pebbles };
my %seen;

foreach (@people) {
  print "I've seen you somewhere before, $_!
"
    if $seen{$_}++;
}

When barney shows up for the first time, the value of $seen{$_}++ is false, since it’s the value of $seen{$_}, which is $seen{"barney"}, which is undef. But that expression has the side effect of incrementing $seen{"barney"}. When barney shows up again, $seen{"barney"} is now a true value, so the message is printed.

It turns out that, inside the Perl grammar, the keyword foreach is exactly equivalent to the keyword for . That is, any time Perl sees one of them, it’s the same as if you had typed the other. Perl can tell which you meant by looking inside the parentheses. If you’ve got the two semicolons, it’s a computed for loop (like we’ve just been talking about). If you don’t have the semicolons, it’s really a foreach loop:

for (1..10) {  # Really a foreach loop from 1 to 10
  print "I can count to $_!
";
}

That’s really a foreach loop, but it’s written for. Except for that one example, all through this book, we’ll spell out foreach wherever it appears. But in the real world, do you think that Perl folks will type those extra four letters?^[13] Excepting only beginners’ code, it’s always written for, and you’ll have to do as Perl does and look for the semicolons to tell which kind of loop it is.

In Perl, the true foreach loop is almost always a better choice. In the foreach loop (written for) in that previous example, it’s easy to see at a glance that the loop will go from 1 to 10. But do you see what’s wrong with this computed loop that’s trying to do the same thing? Don’t peek at the answer in the footnote until you think you’ve found what’s wrong:^[14]

for ($i = 1; $i < 10; $i++) {  # Oops! Something is wrong here!
  print "I can count to $_!
";
}

The last operator immediately ends execution of the loop. (If you’ve used the “break” operator in C or a similar language, it’s like that.) It’s the “emergency exit” for loop blocks. When you hit last, the loop is done. For example:

# Print all input lines mentioning fred, until the __END__ marker
while (<STDIN>) {
  if (/__END__/) {
    # No more input on or after this marker line
    last;
  } elsif (/fred/) {
    print;
  }
}
## last comes here ##

Once an input line has the __END__ marker, that loop is done. Of course, that comment line at the end is merely a comment—it’s not required in any way. We just threw that in to make it clearer what’s happening.

There are five kinds of loop blocks in Perl. These are the blocks of for, foreach, while, until, or the naked block.^[15] The curly braces of an if block or subroutine^[16] don’t qualify. As you may have noticed in the example above, the last operator applied to the entire loop block.

The last operator will apply to the innermost currently running loop block. To jump out of outer blocks, stay tuned; that’s coming up in a little bit.

Sometimes you’re not ready for the loop to finish, but you’re done with the current iteration. That’s what the next operator is good for. It jumps to the inside of the bottom of the current loop block.^[17] After next, control continues with the next iteration of the loop (much like the “continue” operator in C or a similar language):

# Analyze words in the input file or files
while (<>) {
  foreach (split) {  # break $_ into words, assign each to $_ in turn
    $total++;
    next if /W/;    # strange words skip the remainder of the loop
    $valid++;
    $count{$_}++;    # count each separate word
    ## next comes here ##
  }
}

print "total things = $total, valid words = $valid
";
foreach $word (sort keys %count) {
  print "$word was seen $count{$word} times.
";
}

This one is a little more complex than most of our examples up to this point, so let’s take it step by step. The while loop is reading lines of input from the diamond operator, one after another, into $_; we’ve seen that before. Each time through that loop, another line of input will be in $_.

Inside that loop, the foreach loop is iterating over the return value split. Do you remember the default for split with no arguments?^[18] That splits $_ on whitespace, in effect breaking $_ into a list of words. Since the foreach loop doesn’t mention some other control variable, the control variable will be $_. So, we’ll see one word after another in $_.

But didn’t we just say that $_ holds one line of input after another? Well, in the outer loop, that’s what it is. But inside the foreach loop, it holds one word after another. It’s no problem for Perl to reuse $_ for a new purpose; this happens all the time.

Now, inside the foreach loop, we’re seeing one word at a time in $_. $total is incremented, so it must be the total number of words. But the next line (which is the point of this example) checks to see whether the word has any nonword characters—anything but letters, digits, and underscores. So, if the word is Tom's, or if it is full-sized, or if it has an adjoining comma, quote mark, or any other strange character, it will match that pattern and we’ll skip the rest of the loop, going on to the next word.

But let’s say that it’s an ordinary word, like fred. In that case, we count $valid up by one, and also $count{$_}, keeping a count for each different word. So, when we finish the two loops, we’ve counted every word in every line of input from every file the user wanted us to use.

We’re not going to explain the last few lines. By now, we hope you’ve got stuff like that down already.

Like last, next may be used in any of the five kinds of loop blocks: for, foreach, while, until, or the naked block. Also, if loop blocks are nested, next works with the innermost one. We’ll see how to change that at the end of this section.

The third member of the loop control triad is redo . It says to go back to the top of the current loop block, without testing any conditional expression or advancing to the next iteration. (If you’ve used C or a similar language, you’ve never seen this one before. Those languages don’t have this kind of operator.) Here’s an example:

# Typing test
my @words = qw{ fred barney pebbles dino wilma betty };
my $errors = 0;

foreach (@words) {
  ## redo comes here ##
  print "Type the word '$_': ";
  chomp(my $try = <STDIN>);
  if ($try ne $_) {
    print "Sorry - That's not right.

";
    $errors++;
    redo;  # jump back up to the top of the loop
  }
}
print "You've completed the test, with $errors errors.
";

Like the other two operators, redo will work with any of the five kinds of loop blocks, and it will work with the innermost loop block when they’re nested.

The big difference between next and redo is that next will advance to the next iteration, but redo will redo the current iteration. Here’s an example program that you can play with to get a feel for how these three operators work:^[19]

foreach (1..10) {
  print "Iteration number $_.

";
  print "Please choose: last, next, redo, or none of the above? ";
  chomp(my $choice = <STDIN>);
  print "
";
  last if $choice =~ /last/i;
  next if $choice =~ /next/i;
  redo if $choice =~ /redo/i;
  print "That wasn't any of the choices... onward!

";
}
print "That's all, folks!
";

If you just press return without typing anything (try it two or three times), the loop counts along from one number to the next. If you choose last when you get to number four, the loop is done, and you won’t go on to number five. If you choose next when you’re on four, you’re on to number five without printing the “onward” message. And if you choose redo when you’re on four, you’re back to doing number four all over again.

When you need to work with a loop block that’s not the innermost one, use a label. Labels in Perl are like other identifiers—made of letters, digits, and underscores, but they can’t start with a digit—however, since they have no prefix character, labels could be confused with the names of builtin function names, or even with your own subroutines’ names. So, it would be a poor choice to make a label called print or if. Because of that, Larry recommends that they be all uppercase. That not only ensures that the label won’t conflict with another identifier but it also makes it easy to spot the label in the code. In any case, labels are rare, only showing up in a small percentage of Perl programs.

To label a loop block, just put the label and a colon in front of the loop. Then, inside the loop, you may use the label after last, next, or redo as needed:

LINE: while (<>) {
  foreach (split) {
    last LINE if /_ _END_  _/;  # bail out of the LINE loop
    ...;
  }
}

For readability, it’s generally nice to put the label at the left margin, even if the current code is at a higher indentation. Notice that the label names the entire block; it’s not marking a target point in the code.^[20]

In that previous snippet of sample code, the special __END__ token marks the end of all input. Once that token shows up, the program will ignore any remaining lines (even from other files).

It often makes sense to choose a noun as the name of the loop.^[21] That is, the outer loop is processing a line at a time, so we called it LINE. If we had to name the inner loop, we would have called it WORD, since it processes a word at a time. That makes it convenient to say things like “(move on to the) next WORD" or "redo (the current) LINE“.

Unlike what happens in C (and similar languages), the value of a short-circuit logical operator is the last part evaluated, not just a Boolean value. This provides the same result, in that the last part evaluated is always true when the whole thing should be true, and it’s always false when the whole thing should be false.

But it’s a much more useful return value. Among other things, the logical OR operator is quite handy for selecting a default value:

my $last_name = $last_name{$someone} || '(No last name)';

If $someone is not listed in the hash, the left side will be undef, which is false. So, the logical OR will have to look to the right side for the value, making the right side the default.^[22] We’ll see other uses for this behavior later.

When Larry was deciding which operators to make available in Perl, he didn’t want former C programmers to be left wishing for something that C had and Perl didn’t, so he brought over all of C’s operators to Perl.^[23] That meant bringing over C’s most confusing operator: the ternary ?: operator. While it may be confusing, it can also be quite useful.

The ternary operator is like an if-then-else test, all rolled into an expression. It is called a “ternary” operator because it takes three operands. It looks like this:

expression ? if_true_expr : if_false_expr

First, the expression is evaluated to see whether it’s true or false. If it’s true, the second expression is used; otherwise, the third expression is used. Every time, one of the two expressions on the right is evaluated, and one is ignored. That is, if the first expression is true, then the second expression is evaluated, and the third is ignored. If the first expression is false, then the second is ignored, and the third is evaluated as the value of the whole thing.

In this example, the result of the subroutine &is_weekend determines which string expression will be assigned to the variable:

my $location = &is_weekend($day) ? "home" : "work";

And here, we calculate and print out an average—or just a placeholder line of hyphens, if there’s no average available:

my $average = $n ? ($total/$n) : "-----";
print "Average: $average
";

You could always rewrite any use of the ?: operator as an if structure, often much less conveniently and less concisely:

my $average;
if ($n) {
  $average = $total / $n;
} else {
  $average = "-----";
}
print "Average: $average
";

Here’s a trick you might see, used to code up a nice multiway branch:

my $size =
  ($width < 10) ? "small"  :
  ($width < 20) ? "medium" :
  ($width < 50) ? "large"  :
                  "extra-large"; # default

That is really just three nested ?: operators, and it works quite well, once you get the hang of it.

Of course, you’re not obliged to use this operator. Beginners may wish to avoid it. But you’ll see it in others’ code, sooner or later, and we hope that one day you’ll find a good reason to use it in your own programs.

These three operators that we’ve just seen—&&, ||, and ?:—all share a peculiar property: depending upon whether the value on the left side is true or false, they may or may not evaluate an expression. Sometimes the expression is evaluated, and sometimes it isn’t. For that reason, these are sometimes called partial-evaluation operators, since they may not evaluate all of the expressions around them. And partial-evaluation operators are automatically control structures.^[24]

It’s not as if Larry felt a burning need to add more control structures to Perl. But once he had decided to put these partial-evaluation operators into Perl, they automatically became control structures as well. After all, anything that can activate and deactivate a chunk of code is a control structure.

Fortunately, you’ll notice this only when the controlled expression has side effects, like altering a variable’s value or causing some output. For example, suppose you ran across this line of code:

($a < $b) && ($a = $b);

Right away, you should notice that the result of the logical AND isn’t being assigned anywhere.^[25] Why not?

If $a is really less than $b, the left side is true, so the right side will be evaluated, thereby doing the assignment. But if $a is not less than $b, the left side will be false, and thus the right side would be skipped. So that line of code would do essentially the same thing as this one, which is easier to understand:

if ($a < $b) { $a = $b; }

Or maybe you’ll be maintaining a program, and you’ll see a line like this one:

($a > 10) || print "why is it not greater?
";

If $a is really greater than ten, the left side is true, and the logical OR is done. But if it’s not, the left side is false, and this will go on to print the message. Once again, this could (and probably should) be written in the traditional way, probably with if or unless.

If you have a particularly twisted brain, you might even learn to read these lines as if they were written in English. For example: check that $a is less than $b, and if it is, then do the assignment. Check that $a is more than ten, or if it’s not, then print the message.

It’s generally former C programmers or old-time Perl programmers who most often use these ways of writing control structures. Why do they do it? Some have the mistaken idea that these are more efficient. Some think these tricks make their code cooler. Some are merely copying what they saw someone else do.

In the same way, the ternary operator may be used for control. In this case, we want to assign $c to the smaller of two variables:

($a < $b) ? ($a = $c) : ($b = $c);

If $a is smaller, it gets $c. Otherwise, $b does.

There is another way to write the logical AND and logical OR operators. You may wish to write them out as words: and and or.^[26] These word-operators have the same behaviors as the ones written with punctuation, but the words are much lower on the precedence chart. Since the words don’t “stick” so tightly to the nearby parts of the expression, they may need fewer parentheses:

$a < $b and $a = $b;  # but better written as the corresponding if

Then again, you may need more parentheses. Precedence is a bugaboo. Be sure to use parentheses to say what you mean, unless you’re sure of the precedence. Nevertheless, since the word forms are very low precedence, you can generally understand that they cut the expression into big pieces, doing everything on the left first, and then (if needed) everything on the right.

Despite the fact that using logical operators as control structures can be confusing, sometimes they’re the accepted way to write code. We’ll see a common use of the or operator starting in the next chapter.

So, using these operators as control structures is part of idiomatic Perl—Perl as she is spoken. Used properly, they can make your code more powerful; otherwise they can make your code unmaintainable. Don’t overuse them.^[27]