Perl control structures

Short description: None

The basic control structures of Perl are similar to those used in C and Java, but they have been extended in several ways.

## Contents

* 1 Loops
* 1.1 Loop control keywords
* 2 Conditional statements
* 3 Statement modifiers
* 4 goto
* 5 External links

## Loops

In the following, label is an optional identifier terminated by a colon, and block is a sequence of one of more Perl statements surrounded by braces. All looping constructs except for the C-style `for`-loop can have a `continue` block that is executed after each iteration of the loop body, before the loop condition is evaluated again.

label for ( expr1 ; expr2 ; expr3 ) block

This is the so-called C-style `for` loop. The first expression is evaluated prior to the first loop iteration. The second expression is evaluated prior to each iteration and the loop is terminated if it evaluates to false. The third expression is evaluated after each iteration, prior to deciding whether to perform the next. This `for` loop is the only looping construct that can not have a `continue` block, but expr3 is functionally equivalent.

label for var ( list ) block
label for var ( list ) block continue block
label foreach var ( list ) block
label foreach var ( list ) block continue block

In `foreach`, var is a scalar variable that defaults to `$_` if omitted. For each element of list, var is aliased to the element, and the loop body is executed once. The keywords `for` and `foreach` are synonyms and are always interchangeable.

label while ( expr ) block
label while ( expr ) block continue block
label until ( expr ) block
label until ( expr ) block continue block

The `while` loop repeatedly executes the loop body as long as the controlling expression is true. The condition is evaluated before the loop body. `until` is similar, but executes the loop body as long as the condition is false.

label block
label block continue block

The label block construct is a bit of an oddity: Perl treats a bare block - with or without a label - as a loop that is executed once. This means that the loop control keywords can be used to restart the block or to exit it prematurely; a bare block can also have a `continue` block.

### Loop control keywords

Perl provides three loop control keywords that all accept an optional loop label as an argument. If no label is specified, the keywords act on the innermost loop. Within nested loops, the use of labels enables control to move from an inner loop to an outer one, or out of the outer loop altogether. The loop control keywords are treated as expressions in Perl, not as statements like in C or Java.

* The `next` keyword jumps directly to the end of the current iteration of the loop. This usually causes the next iteration of the loop to be started, but the `continue` block and loop condition are evaluated first.
* The `last` keyword immediately terminates execution of the loop identified by the label. The `continue` block is not executed.
* The `redo` keyword restarts the current iteration of the loop identified by the label. Neither the `continue` block nor the loop condition is evaluated.

## Conditional statements

if ( expr ) block
if ( expr ) block else block
if ( expr ) block elsif ( expr  ) block ... else block

unless ( expr ) block
unless ( expr ) block else block
unless ( expr ) block elsif ( expr  ) block ... else block

where block is a sequence of one of more Perl statements surrounded by braces.

The controlling expressions are evaluated in a Boolean context: The numeric value 0, the strings "" and "0", and the undefined value `undef` are false, all other values are true. This means that the strings "0.0", "00", "-0", and "0 but true" are all true, even though their value would be converted to 0 in a numeric context; values like these are sometimes used when a successful operation needs to return 0.

Evaluating an empty array in scalar context yields `undef`, which is false. Therefore, the following example prints "a is empty":

my @a=(); unless (@a) { print "a is empty" }

## Statement modifiers

Perl also provides variants of the loop and conditional constructs that work on a simple statement (an expression evaluated for its side-effects) instead of a block:

statement if expr;
statement unless expr;
statement while expr;
statement until expr;
statement for list;
statement foreach list;

The `while` and `until` modifiers test the controlling expression before executing the statement, just like their loop counterparts. However, they are not considered actual loops, so the loop control keywords `next`, `last` and `redo` cannot be used with them. They have special semantics when combined with the `do` keyword:

do block while expr;
do block until expr;

In these constructs, the condition is tested after the block is executed, so the block always executes at least once.

These modifiers cannot be nested, so the following is illegal

statement if expression for list;         #ERROR

and should be written as one of:

( expression ) and ( statement ) for list;
for ( list ) { statement if expression }
do { statement if expression } foreach list;

## goto

There are two forms of goto in Perl:

goto label

and

goto &subroutine

The first form is generally deprecated, and is only used in rare situations. For example, when attempting to preserve error status in `$?`, some modules will use goto like this:

open(A, "<", $filea) or goto fail;
open(B ,">", $fileb) or goto fail;
print B <A> or goto fail;
close A or goto fail;
close B or goto fail;
return 1;
fail: $reason = "In copy: $?"; return 0;

The second form is called a tail call, and is used to enhance the performance of certain kinds of constructs where Perl's default stack management would perform non-optimally. For example:

sub factorial {
my $n = shift;
my $total = shift(@_) || 1;
if ($n > 1) {
@_ = ($n-1,$total*$n);
goto &factorial;
} else {
return $total;

This form is also used to create aliases for subroutines with minimal overhead. This can help reduce "Out of Memory" errors (or high memory usage in general) found often in repeating the same subroutine.

## External links

Perl Programming/Flow control at Wikibooks

0.00

(0 votes)

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Perl_control_structures&oldid=4203740"