Write Predictable Perl Control Flow with perlsyn

Perl's syntax bends further than most languages allow, and that flexibility is how a careless if or foreach hides a bug for months. This guide builds a small set of control-flow patterns that compile locally and keep their scope, loop behaviour and conditions visible. The examples use Perl v5.38.2, as reported by the installed perlsyn(1) manual page dated 14 September 2026. Allow about 20 minutes if you are reading the syntax as you go.

You need a shell and the installed perl interpreter. Everything here runs as an ordinary user. It creates only temporary files under /tmp if you choose to save a script. No elevated privileges are needed.

1. Start with a statement and a block

Perl is free-form, so indentation helps people but does not define the program. A simple statement is an expression evaluated for its side effect, and it normally ends with a semicolon. A final statement in a block may drop that semicolon, but keeping it makes later edits less surprising.

use strict;
use warnings;

my $name = 'Ada';
print "Hello, $name\n";

Save that as /tmp/perlsyn-demo.pl, then check its syntax without running it:

$ perl -c /tmp/perlsyn-demo.pl
/tmp/perlsyn-demo.pl syntax OK

perl -c compiles the file and stops before executing it, a useful checkpoint after changing braces, declarations or loop headers. If you see an error, fix the first reported line before chasing later messages.

2. Make conditional scope explicit

Compound conditionals operate on blocks, so the braces are part of the syntax. That avoids the dangling-else ambiguity you get in some C-like languages:

my $temperature = 7;

if ($temperature < 0) {
    print "freezing\n";
} elsif ($temperature < 10) {
    print "cold\n";
} else {
    print "mild\n";
}

Run it to check the result:

$ perl /tmp/perlsyn-demo.pl
cold

Use unless only when its negative condition is genuinely clearer. It can have else and elsif, but several negative branches force readers to mentally flip each test, and a plain if often says the same thing more directly.

Declarations have a confusing timing rule: subroutine declarations take effect at compile time, while a lexical declaration such as my also has a run-time effect as the statement sequence executes. Keep declarations near the start of a scope unless there is a clear reason not to. A name declared inside a block is gone once that block ends.

3. Use postfix modifiers for one short action

A simple statement may carry one modifier right before its terminating semicolon, compact and useful when the action and condition fit on one readable line:

print "backup needed\n" if $needs_backup;
warn "not ready\n" unless $ready;

The modifier changes when the statement runs, not its position in the source. The same form works with while, until, for and foreach. This, for example, prints each item using the default topic variable $_:

print "item: $_\n" for qw(alpha beta gamma);

Do not hide a multi-step operation behind a long postfix line. Use a block when readers need to see several actions, or when loop control such as next and last matters. A postfix do block runs once before its while or until condition is even tested, handy for reading input but easy to miss during maintenance.

4. Choose the loop form deliberately

Use a C-style loop when you need an explicit initialiser, condition and increment. Use for or its synonym foreach when visiting values:

for my $number (2, 4, 6) {
    print "$number\n";
}

With no iterator variable supplied, Perl uses $_. With one supplied, that variable is an alias to each list item rather than an unrelated copy, which means this deliberately changes the array:

my @numbers = (1, 2, 3);
for my $number (@numbers) {
    $number *= 10;
}
print "@numbers\n";

$ perl /tmp/perlsyn-demo.pl
10 20 30

That aliasing is convenient for an in-place edit and a common distraction when the loop was only meant to inspect values. Use a separate calculated value when mutation is not the job. Do not add or remove elements from an array while a foreach loop is walking it either: the manual warns this can confuse the iteration.

5. Control nested loops with labels

next skips to the next iteration, redo repeats the current one without retesting the condition, and last leaves the loop entirely. Without a label, each applies to the innermost enclosing loop, so label the loop whenever the intended target is not obvious:

OUTER: for my $left (1, 2) {
    for my $right (1, 2, 3) {
        next OUTER if $left == $right;
        print "$left:$right\n";
    }
}

Here next OUTER skips the rest of the inner loop and starts the next outer iteration. A label also guards against future nesting changes silently breaking a plain next or last. Do not rely on a loop's return value either: perlsyn describes it as unspecified and subject to change.

6. Avoid the modifier declaration trap

The installed manual explicitly warns that my, state or our combined with a conditional or loop modifier has undefined behaviour. Do not write this:

my $value if $condition;

Depending on version and execution history, $value may end up undefined, retain an earlier value, or behave differently in a future release. Declare first, then assign in an ordinary block:

my $value;
if ($condition) {
    $value = 'set';
}

Run perl -c again after moving declarations or braces. Compilation success only proves the syntax is accepted, not that a condition is logically correct, so run a small test with representative values too.