A basic if statement looks like if ( EXPRESSION ) BLOCK:

if ( EXPRESSION ) {
    # 0 or more statements
}

An expression might have a simple boolean operation in there. For example, the following guarantees that $x will not be less than $y by swapping their values if $x < $y evaluates as true.

if ( $x < $y ) {
    ( $y, $x ) = ( $x, $y );
}

You can even put compound conditionals in there if you like:

if ( $x < $y && $y > 10 ) {
    # do something
}

That works because the < and > operators have a higher precedence than the && operator (see chapter 4). However, many programmers prefer parentheses to be explicit:

if ( ( $x < $y ) && ( $y > 10 ) ) {
    # do something
}

Optionally, you can use the and, or, xor and not forms of various boolean operations because those have the lowest precedence of all operations and you don’t have to memorize the precedence order:

if ( $x < $y and $y > 10 ) {
    # do something
}

It reads nicer, too. Just remember the gold rule of precedence: when in doubt consider using parentheses to force precedence. Even if you get it right another programmer reading your code might not.

if ( x == y )
    x++;

if ( x == y )
    x++;
    y++;

Because this is Perl, we’re not limited to simple boolean constructs in if statements. The expression inside of the parentheses in the if statement is evaluated in scalar context and the result is then evaluated as true or false (this is sometimes referred to as “boolean context”). Consider the following:

if (@names) {
    # do something
}

As you may recall, an array evaluated in scalar context returns the number of elements in the array. In the case of if (@names) BLOCK, if the @names array is empty, the if block will not execute. This works for hashes, too:

if (%names) {
    # will not execute if %names is empty
}

my %hash1 = ( foo => 1, bar => 2, baz => 3 );
my %hash2;
my $scalar1 = %hash1;
my $scalar2 = %hash2;
print "$scalar1 - $scalar2";

if ( my $customer = get_customer($id) ) {
    # only executed if $customer evaluates to true
}

Sometimes you want to take a different action depending on whether or not a value is true or false. You can follow the if block with an else block.

if ( $temperature > 0 ) {
    print "The temperature is above freezing: $temperature\n";
}
else {
    print "The temperature is not above freezing. Exiting the program.";
    exit;
}

Or if you want to test other conditions if the first if has failed, you can use an elsif block.

if ( $temperature >= 100 ) {
    print "It's boiling in here!\n";
    cool_things_down($temperature);
}
elsif ( $temperature < 0 ) {
   print "It's freezing in here!. Exiting.\n";
   exit;
}
elsif ( $temperature > 13 and $temperature < 21 ) {
   print "It's perfect weather for outdoor exercise.  Impromptu holiday!\n";
   exit;
}
else {
   print "The temperature is acceptable. Proceed.\n";
}

The final else is optional:

if ( $customer_is_male ) {
    redirect_to_male_apparel();
}
elsif ( $customer_is_female ) {
    redirect_to_female_apparel();
}

Many (including your author) recommend that a final else block be supplied - even if it does nothing - to make it clear to other programmers who work on your code that you did not make a mistake and overlook a condition. Adding a comment to that else block makes it even more clear.

if ($customer_is_male) {
    redirect_to_male_apparel();
}
elsif ($customer_is_female) {
    redirect_to_female_apparel();
}
else {
    # TODO:  implement redirect_to_unisex_apparel()
}

You can also use multiple elsif statements:

if ( !$color ) {
    print "No color found";
}
elsif ( 'blue' eq $color ) {
    print "#0000FF";
}
elsif ( 'green' eq $color ) {
    print "#00FF00";
}
elsif ( 'red' eq $color ) {
    print "#FF0000";
}
else {
   print "I don't know what to do with color ($color)";
}

Long if/elsif/else chains should be avoided, if possible, because they start to make to code harder to read. For example, with the above code, it’s better to use a hash:

my %color_code_for = (
    blue  => '#0000FF',
    green => '#00FF00',
    red   => '#FF0000',
);
if ( !$color ) {
    print "No color found";
}
elsif ( my $code = $color_code_for{$color} ) {
    print $code;
}
else {
   print "I don't have a code for the color '$color'";
}

With using the hash, if you want to support new color codes, you can just add a new entry to the hash rather than create new elsif blocks for every color.

my %color_code_for = (
    black => '#000000',
    blue  => '#0000FF',
    green => '#00FF00',
    red   => '#FF0000',
    white => '#FFFFFF',
);
if ( !$color ) {
    print "No color found";
}
elsif ( my $code = $color_code_for{$color} ) {
    print $code;
}
else {
   # print "I don't know what to do with color ($color)";
   print "I don't have a code for color ($color)";
}

if ( $temperature >= 100 ) {
    print "It's boiling in here!\n";
    cool_things_down($temperature);
} elsif ( $temperature > 0 ) {
    print "The temperature is acceptable. Proceed.\n";
} else {
   print "It's freezing in here!. Exiting.\n";
   exit;
}

if ( $temperature > 0 )
{
    print "The temperature is above freezing: $temperature\n";
}
else
{
    print "The temperature is not above freezing. Exiting the program.";
    exit;
}

Of course, as already seen, you can also reverse the sense of a condition with the ! or not operators:

if ( !$allowed ) {
    print "You can't do that!";
}
if ( not $found ) {
   print "I didn't find it!";
}

Perl also has a rather curious unless statement. It’s the opposite of the if statement. The above statements can be rewritten as follows:

unless ( $allowed ) {
    print "You can't do that!";
}
unless ( $found ) {
   print "I didn't find it!";
}

As with the if statement, you can use elsif and else, but as you might imagine, it can be confusing:

unless ($condition) {
    # ...
}
elsif ( $some_other_condition ) {
    # ...
}
else {
    # ...
}

The use of the unless check is strongly discouraged in all but the simplest cases. The logic gets confusing and many developers will cheerfully fantasize about using pliers to extract your fingernails if you abuse the unless statement.

As with many other programming languages, Perl also provides a ternary operator as a “shortcut” for an if else statement. The ternary operator’s syntax looks like this:

VALUE = CONDITION ? IFTRUE : IFFALSE

You can write this:

my $max = ( $num1 < $num2 ) ? $num2 : $num1;

That’s the same as writing:

my $max;
if ( $num1 < $num2 ) {
    $max = $num2;
}
else {
    $max = $num1;
}

But as you can see, the ternary operator is much more compact. Also note that with the ternary operator, you don’t need to predeclare the $max variable because the ternary operator does not introduce a new scope.

You can also chain ternary operators:

my $max = ( $num1 < $num3 and $num2 < $num3 ) ? $num3
        : ( $num1 < $num2 )                   ? $num2
        :                                       $num1;

With good formatting this construct is very easy to read and it has the advantage of the final “else” being required and it’s a syntax error if you omit it. The only caution is to be careful about your logic because it is easy to get wrong.

A for loop is used to iterate over every element in an array or list. A basic for loop in Perl looks like this:

for my $number (@numbers) {
    print "$number\n";
}

There’s also a foreach version:

foreach my $number (@numbers) {
    print "$number\n";
}

In Perl, for and foreach are identical. There is no difference aside from the spelling. Your author likes foreach because he feels it reads better, but honestly, it’s a matter of personal preference.

The for/foreach loop is one builtin which assigns to the $_ by default. If you don’t specify a variable name, $_ is assumed. The following prints the numbers 5, 6, and 7.

my @numbers = ( 5, 6, 7 );
foreach (@numbers) {
    print "$_\n";
}

When combined with builtins which operate on $_ by default, it can shorten your code a bit. The following will remove newlines from each element and, if the element evaluates as true, prints the element.

foreach (@names) {
    chomp;
    if ($_) {
        print;
    }
}

By contrast, here’s the same code using a variable (remember that the foreach here could be written as for):

foreach my $name (@names) {
    chomp $name;
    if ($name) {
        print $name;
    }
}

Whichever method you prefer, just be aware that it’s very common to see experienced Perl developers know when the $_ variable is used and take advantage of this fact.

One important thing to remember about for loops is that the variable used to designate each element, whether it’s $_ or a named variable, is an alias to the element in question. This allows you to modify an array in place. For example, if you want all elements in an array that are less than zero to be set to zero, you can take advantage of aliasing:

my @numbers = ( -7, -5, -1, 0, 3, 6, 29 );
foreach my $number (@numbers) {
    if ( $number < 0 ) {
        $number = 0;
    }
}
print join ',', @numbers;

That code snippet will print 0,0,0,0,3,6,29. If you want to manipulate the value but not change the original array, just assign the element to a new variable. This is one case where the $_ default can be clearer.

my @numbers = ( -7, -5, -1, 0, 3, 6, 29 );
foreach (@numbers) {
    my $number = $_; # don't use an alias
    if ( $number < 0 ) {
        $number = 0;
    }
}
print join ',', @numbers;

Running that will show you that the array has escaped unchanged.

for my $number (1) {
    $number++;
}

Modification of a read-only value attempted at ...

The for loops is useful for arrays, but we can use them with anything that returns a list.

my %economic_description = (
    libertarians => 'Anarchists with jobs',
    anarchists   => 'Libertarians without jobs',
    randroids    => 'Closet libertarians',
    democrats    => 'the tax and spend party',
    republicans  => 'the tax cut and spend party',
);
foreach (sort keys %economic_description) {
    my $description = lc $economic_description{$_};
    $_              = ucfirst;
    print "$_ are $description.\n";
}

And that allows you to offend just about everyone by printing:

Anarchists are libertarians without jobs.
Democrats are the tax and spend party.
Libertarians are anarchists with jobs.
Randroids are closet libertarians.
Republicans are the tax cut and spend party.

Note that even though we have the $_ = ucfirst line in there, this code does not change the hash keys, even though the for loop aliases its arguments. This is because keys() (like the sort() function in the loop) returns a new list.

Range operators, when used in list context, also return a list.

for my $number ( -10 .. 10 ) {
    $number++;
    print $number;
}

That prints the numbers from -9 to 11. Note that even though it may appear that we have numeric literals here and thus $number++ should throw a Modification of read-only value error, we don’t have that problem. This is because the range operator returns a list. If the values of the list are not assigned to anything, they are anonymous variables. This means that they can be changed like any other variable, even though it looks strange.

perl -MDevel::Peek -e 'Dump(1)'

SV = IV(0x100827d10) at 0x100827d20
  REFCNT = 1
  FLAGS = (IOK,READONLY,pIOK)
  IV = 1

perl -MDevel::Peek -e 'Dump(1..1)'

SV = IV(0x100802f98) at 0x100802fa8
  REFCNT = 1
  FLAGS = (IOK,pIOK)
  IV = 1

Of course, there’s also the C-style for loop, with the syntax:

for (EXPRESSION ; EXPRESSION ; EXPRESSION) BLOCK

This, for example, prints the numbers 0 through 9:

for ( my $i = 0; $i < 10; $i++ ) {
    print "$i\n";
}

For those not familiar with this style of loop, the three semicolon separated expressions correspond to loop initialization, the loop test and the loop change.

Note that all three of these expressions are optional. The following is almost equivalent to the previous code, except that the $i variable is no longer lexically scoped to the for loop.

my $i = 0;
for ( ;$i < 10; ) {
    $i++;
    print "$i\n";
}

In fact, you can even omit that loop test with a last() command. We’ll cover that a bit later.

C-style for loops are not very popular in Perl and they’re often not needed. For example, sometimes you need the index of an array, so you do this:

for ( my $i = 0; $i < @array; $i++ ) {
    print "$i: $array[$i]\n";
}

But that’s more cleanly written and commonly seen like this:

for my $i ( 0 .. $#array ) {
    print "$i: $array[$i]\n";
}

The special $# syntax at the front of the array name means “the index of the last element of an array”. So if an array is 4 elements long, $#array will return 3.

if ( $#array ) {
    # do something with array
}

#!perl -l
print "$#array\n";
@array = ('fail!');
print "$#array\n";
push @array, 'not fail!';
print "$#array\n";

if (@array) { ... }

One time when a C-style for loop comes in handy is when you must iterate over a range of numbers that are not easily generated by the range operator. The following prints a vertical sine wave in your terminal:

for ( my $i = 0 ; $i <= 25 ; $i += .25 ) {
    my $amplitude = int( 40 + 35 * sin($i) );
    print " " x $amplitude;
    print ".\n";
}

You could write this without the C-style for loop, but you might find it harder to understand.

for my $i ( 0 .. 100 ) {
    $i = $i / 4;
    my $amplitude = int( 40 + 35 * sin($i) );
    print " " x $amplitude;
    print ".\n";
}

Or perhaps the variable increment is set within the program:

for ( my $i = 7; $i < 10; $i += $user_choice ) {
    print "$i\n";
}

Which you prefer in any context is just a matter of preference.

Try it out: Finding duplicate array elements

Example 5.1

Sometimes an array has repeated elements you want to remove and preserving the order of the array is important. Using a hash and a for loop makes this easy. We’ll also use a simple trick to find unique elements when you don’t care about the order.

1. Type the following program into your editor as example_5_1_unique.pl.

   #!/usr/bin/perl
   use strict;
   use warnings;
   use diagnostics;
   my @array = ( 3, 4, 1, 4, 7, 7, 4, 1, 3, 8 );
   my %unordered;
   @unordered{@array} = undef;
   foreach my $key (keys %unordered) {
      print "Unordered: $key\n";
   }
   my %seen;
   my @ordered;
   foreach my $element (@array) {
       if ( not $seen{$element}++ ) {
           push @ordered, $element;
       }
   }
   foreach my $element (@ordered) {
      print "Ordered: $element\n";
   }

   example_5_1_unique.pl available for download at Wrox.com.

2. Run the program with perl example_5_1_unique.pl and you should see something similar to the following:

   Unordered: 8
   Unordered: 1
   Unordered: 4
   Unordered: 3
   Unordered: 7
   Ordered: 3
   Ordered: 4
   Ordered: 1
   Ordered: 7
   Ordered: 8

How it works

We’ll look at the unordered code first because it may look a bit strange.

my @array = ( 3, 4, 1, 4, 7, 7, 4, 1, 3, 8 );
my %unordered;
@unordered{@array} = undef;
foreach my $key (keys %unordered) {
   print "Unordered: $key\n";
}

The line @unordered{@array} = undef is using a hash slice as described in Chapter 3, Variables. Because we don’t care about the values and because hashes cannot have unique keys, the right side of the assignment operator is not important. We now have an array with the keys 1, 3, 4, 7, and 8. However, as hashes do not have an order, printing the keys shows an apparent random order.

You could, of course, sort they keys:

foreach my $key ( sort { $a <=> $b } keys %unordered ) {
   print "Unordered: $key\n";
}

But that merely prints the keys in ascending numeric order, not in the order of the original array. We’ll see how we did that next. The following puts together many of the concepts you’ve already learned.

my %seen;
my @ordered;
foreach my $element (@array) {
    if ( not $seen{$element}++ ) {
        push @ordered, $element;
    }
}
foreach my $element (@ordered) {
   print "Ordered: $element\n";
}

The key to this is the not $seen{$element}++ expression. The $seen{$element}, when first encountered, has an undefined value. Perl interprets this value as 0 and the ++ postfix operator increments it by 1. However, because it’s the postfix ++ and not the prefix ++, the increment operation happens after the value is returned, thus ensuring that not $seen{$element}++ is effectively “not 0”, which evaluates as true. The next time that $element has a previously seen value, the $seen{$element} already has a value of 1 or higher, thus causing the not $seen{$element}++ to be the equivalent of “not 1” (or a higher number). Since not 1 evaluates as false, the if block will not get executed after the first time the $element is seen.

This is a common idiom in Perl and is well worth studying and practicing.

$seen{$element}++;
$seen{$element} += 1;
$seen{$element} = $seen{$element} + 1;

If you enable warnings, you'll be notified of an uninitialized value
whenever you treat undef as a string or a number.  Well, usually.
Boolean contexts, such as:
    my $a;
    if ($a) {}
are exempt from warnings (because they care about truth rather than
definedness).  Operators such as "++", "--", "+=", "-=", and ".=",
that operate on undefined left values such as:
    my $a;
    $a++;
are also always exempt from such warnings.

{
    no warnings 'uninitialized';
    $seen{$element} = $seen{$element} + 1;
}

$seen{$element} ||= 0;
$seen{$element} = $seen{$element} + 1;

Try it out: Splitting an array

Example 5.2

Sometimes you want to split up an array into separate arrays based on the data in the array. We’ll walk through an array of numbers, creating two new arrays with positive and negative numbers, skipping zero.

1. First, type the following program and save it as example_5_2_arrays.pl.

   #!perl
   use strict;
   use warnings;
   use diagnostics;
   my @numbers = ( -1, 3, 8, -17, 42, 0, 13, -3 );
   my ( @negative, @positive );
   foreach my $number (@numbers) {
       if ( $number < 0 ) {
           push @negative, $number;
       }
       elsif ( $number > 0 ) {
           push @positive, $number;
       }
       else {
           # skip zero
       }
   }
   print "Negative: @negative\nPositive: @positive\n";

   example_5_2_arrays.pl available for download at Wrox.com.

2. Run the code with perl example_5_2_arrays.pl. You should have the following output:

   Negative: -1 -17 -3
   Positive: 3 8 42 13

How it works

At this point, things should be fairly clear. We walk through the @numbers array and push each element on the corresponding @negative or @positive array, depending on whether it is negative or positive. The trailing else block is not required, but it is a nice hint to future programmers that we did not accidentally skip the number zero.

Programmers often try to use while or until loops with lists instead of iterators or boolean conditions. You can do this but it is fraught with danger and should be avoided. Here are several ways you can fail spectacularly.

my $total = 0;
while ( my $price = shift @orders ) {
    $total += $price;
}
print $total;

Most of the time, that’s going to work just fine. Until you have a sale item with a price of zero.

my @orders = (5,5,0,5);
my $total = 0;
while ( my $price = shift @orders ) {
    $total += $price;
}
print $total;

That will print 10 instead of the (probably) desired 15. So you decide to get clever and make sure the price is defined:

my @orders = ( 5, 5, 0, undef, 5 );
my $total = 0;
while ( defined( my $price = shift @orders ) ) {
    $total += $price;
}
print $total;

That’s also going to fail because we’ve managed to sneak an undefined value into the array. If you need to use a while loop here, do it like this:

my @orders = ( 5, 5, 0, undef, 5 );
my $total = 0;
while (@orders) {
    my $price = shift @orders;
    $total += $price;
}
print $total;

If you insist upon using a while/until loop here (perhaps because you want the array empty at the end), you should still consider rewriting with a for loop.

my $total = 0;
for my $price (@orders) {
    $total += $price;
}
@orders = ();

As you can see, the for loop is shorter and easier to read.

When you’re working with loops, it’s often useful to have fine-grained control over how the loops behave. The last(), next(), redo() and continue() builtins help with this. The last() builtin will automatically exit a loop. For example, to find the first perfect square (a square number that is the square of an integer) in an array, you could do the following:

my @numbers = ( 3, 7, 9, 99, 25 );
my $first;
for my $number (@numbers) {
    my $root = sqrt($number);
    if ( int($root) == $root ) {
        $first = $number;
        last;
    }
}
if ( defined $first ) {
    print "The first perfect square in the array is $first\n";
}
else {
    print "No perfect square found in array\n";
}

That will exit the loop when $number equals 9 and it will print:

The first perfect square in the array is 9

It’s very handy when you want to process a loop until you reach a desired condition and then terminate the loop.

The next() statement is useful when you want to skip the processing of some elements. We could use this to rewrite the above code to find all perfect squares in a loop.

my @numbers = ( 3, 7, 9, 99, 25 );
my @perfect_squares;
for my $number (@numbers) {
    my $root = sqrt($number);
    if ( int($root) != $root ) {
        next;    # skip the rest of the loop BLOCK
    }
    print "Found perfect square: $number\n";
    push @perfect_squares, $number;
}

The continue statement is not common, but it’s useful it you have a block of code that must be executed every time through a loop, before the loop check occurs again. The syntax looks like this:

for   (EXPRESSION) BLOCK continue BLOCK
while (EXPRESSION) BLOCK continue BLOCK

Regardless of a next or last statement in the loop body, the continue will always execute after the last statement in the loop body is executed.

use strict;
use warnings;
my @numbers = ( 3, 7, 9, 99, 25 );
my @perfect_squares;
for my $number (@numbers) {
    my $root = sqrt($number);
    if ( int($root) != $root ) {
        next;    # skip the rest of the loop BLOCK
    }
    print "Found perfect square: $number\n";
    push @perfect_squares, $number;
}
continue {
    print "Processed $number\n";
}

That example will print:

Processed 3
Processed 7
Found perfect square: 9
Processed 9
Processed 99
Found perfect square: 25
Processed 25

The redo statement is even less common. What it does is redo the body of the loop without testing the condition or executing the continue block. It’s a bit confusing to people and even the perldoc -f redo documentation sheds little light on the matter. It’s used seldom enough that we won’t mention further, aside from using it in one of the exercises at the end of this chapter.

When we listed examples of the for/foreach/while/until syntax, we omitted labels. Labels can be very useful for cleaning up code. A label is a bare identifier followed by a colon. The next, last, and redo builtins take an optional label as an argument. If that label is present, control jumps to that label. They can be used to make your code a bit more self-documenting:

NUMBER: foreach my $number (@numbers) {
    # lots of code
    if ($some_condition) {
        next NUMBER;
    }
    # more code
}

However, their real power lies in controlling the behavior of next, last and redo when using nested loops. Let’s say that you have two arrays of strings, @strings1 and @strings2 and you want to find any strings in the first array that are substrings of any strings in the second array. Here’s one way of writing that:

my @strings1 = qw( aa bb cc dd ee );
my @strings2 = qw(
  an
  intelligent
  robber
  needs
  a
  good
  ladder
);
my @found;
DOUBLED_LETTER: foreach my $double (@strings1) {
    foreach my $word (@strings2) {
        if ( index($word, $double) != -1 ) {
            push @found, $double;
            next DOUBLED_LETTER;
        }
    }
}
print "@found";

That prints bb dd ee. If the next DOUBLED_LETTER statement was not present, we would continue searching for words containing the doubled letter, even though it was already found. If the arrays were very large, this could be extremely inefficient.

The allowed modifiers are:

STATEMENT if      EXPR;
STATEMENT unless  EXPR;
STATEMENT while   EXPR;
STATEMENT until   EXPR;
STATEMENT for     LIST;
STATEMENT foreach LIST;

Unlike the normal usage of these keywords, parentheses are optional around the EXPR or LIST. For example:

print "We have a valid user: $user\n" if $user;

When using a for/foreach loop, $_ is aliased to the variable. The following prints the numbers 1 through 5 on successive lines.

my @array = ( 1 .. 5 );
print "$_\n" foreach @array;

The while and until loops behave similarly. Note that the EXPR is evaluated before the statement. Thus, the following prints 9 through 0, not 10 to 1.

my $countdown = 10;
print "$countdown\n" while $countdown--;

Note that the STATEMENT may be a compound statement. The example from perldoc perlsyn is the following:

go_outside() and play() unless $is_raining;

That reads nicely, but it does have a subtle trap. The play() subroutine will not be called if go_outside() returns false. You can replace the and with a comma if you want to avoid this:

go_outside(), play() unless $is_raining;

Statement modifiers should be used sparingly. It’s recommended that you use them when the emphasis is to be placed on the statement and not on the modifier.

print "Using config data" if $config;

For the preceding code, printing Using config data is the expected behavior and is what the programmer should focus on when skimming code. The if $config modifier is easily overlooked. If if $config is a normal condition that the programmer should be more aware of, avoid using the modifier.

if ($config) {
    print "Using config data";
}

Use of keyword (EXPRESSION or LIST) BLOCK versus a statement modifier is largely a matter of preference, but if you have a compound statement or the condition is what needs the emphasis, avoid the statement modifier.

We won’t cover the do builtin (perldoc -f do) much in this book, as the common uses for it belonged to Perl version 4, which should have been put to death when Perl 5 was released in 1994, but there is one form of the do builtin which is still very much in use:

do BLOCK

This form of do executes the statements in the block, return the value of the last executed expression. It is most commonly used with a while or until statement modifier. The grammar looks like:

do BLOCK while EXPRESSION;
do BLOCK until EXPRESSION;

For example:

my $factorial = 1;
my $counter   = 1;
do {
   $factorial *= $counter++;
} while $counter <= 5;
print $factorial;

The do/while, do/until syntax has two major differences between while and until statements. First, it guarantees that the BLOCK will be executed at least once. Second, it’s not really a loop. Many people mistakenly think it’s a loop, but it’s just a standard do BLOCK statement followed by a statement modifier. As a result, next, last, redo and continue statements do not apply.

while (1) {
    last if $counter < 0;
    if ( rand() < .5 ) {
        $counter--;
    }
}

use strict;
use warnings;
my $counter = 2;
do {
    last if $counter < 0;
    # do something else
    $counter--;
} while 1;

Can't "last" outside a loop block at program.pl line 6 (#1)

(F) A "last" statement was executed to break out of the current block,
except that there's this itty bitty problem called there isn't a current
block.  Note that an "if" or "else" block doesn't count as a "loopish"
block, as doesn't a block given to sort(), map() or grep().  You can
usually double the curlies to get the same effect though, because the
inner curlies will be considered a block that loops once.  See
perlfunc/last.

use strict;
use warnings;
my $counter = 2;
do {{
    last if $counter < 0;
    # do something else
    $counter--;
    print $counter,$/l
}} while 1;

The syntax of given/when looks like this:

given (EXPRESSION) BLOCK

And BLOCK is composed of zero or more when statements:

when (EXPRESSION) BLOCK

Those can be followed by a default BLOCK statement. The previous switch statement can be written in Perl as follows:

use 5.010;
my $number = 1;
given ($number) {
    when(0) { print "The number is 0"; }
    when(1) { print "The number is 1"; }
    when(2) { print "The number is 2"; }
    default { print "The number is unexpected"; }
}

If you read the code aloud, it actually reads much better than the switch version. For some languages, the switch statement can only operate on integers (part of the historical discussion we’re side-stepping). In Perl, the given keyword assigns the value of EXPRESSION to $_ and the EXPRESSION in when (EXPRESSION) BLOCK tests the value of $_. Thus, you can do things like this:

given ($number) {
    when ($_ < 0) {
        print "The number is negative";
    }
    when ($_ > 0) {
        print "The number is positive";
    }
    default {
        print "The number is 0";
    }
}

If you actually want the when statement to test subsequent when statements, you can use the continue keyword.

given ($word) {
    when ( lc $_ eq scalar reverse $_ ) {
        print "'$word' is a palindrome\n";
        continue;
    }
    when ( length($_) > 10 ) {
        print "The length of '$word' is greater than 10 characters\n";
    }
}

for ($number) {
    when ($_ < 0) {
        print "The number is negative";
    }
    when ($_ > 0) {
        print "The number is positive";
    }
    default {
        print "The number is 0";
    }
}

Don’t use this module.

Added in Perl version 5.7.2 and removed in Perl version 5.13.1, the Switch module allowed you to write switch statements in Perl:

use Switch;
switch ($val) {
    case 1          { print "number 1" }
    case "a"        { print "string a" }
    case [1..10,42] { print "number in list" }
    case (\@array)  { print "number in list" }
    case /\w+/      { print "pattern" }
    case qr/\w+/    { print "pattern" }
    case (\%hash)   { print "entry in hash" }
    case (\&sub)    { print "arg to subroutine" }
    else            { print "previous case not true" }
}

Unfortunately, this was implemented as something known as a “source filter”. Source filters rewrite your code before it’s compiled, but due to the heuristic nature of Perl’s parser, they’re considered extremely unreliable. In fact, the Switch module, which generally being useful, has a variety of bugs and limitations that, while obscure, are nonetheless difficult to work around.

Switch was eventually removed from the Perl core as its functionality is replaced with the given/when statement. Your author strongly recommends that you do not use the Switch module.