Perl control structures

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

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 -loop can have a   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  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  loop is the only looping construct that can not have a   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, 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  and   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  loop repeatedly executes the loop body as long as the controlling expression is true. The condition is evaluated before the loop body. 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  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  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   block and loop condition are evaluated first.
 * The  keyword immediately terminates execution of the loop identified by the label. The   block is not executed.
 * The  keyword restarts the current iteration of the loop identified by the label. Neither the   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  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, 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  and   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,   and   cannot be used with them. They have special semantics when combined with the  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: 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: 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.