do {
        $line = <STDIN>;
        ...
    } until $line  eq ".\n";

   do {{
      next if $x == $y;
      # coś tu robi
   }} until $x++ > $z;

   LOOP: {
           do {
              last if $x = $y**2;
              # coś tu robi
           } while $x++ <= $z;
   }

Instrukcje złożone

    if (!open(FOO)) { die "Can't open $FOO: $!"; }
    die "Can't open $FOO: $!" unless open(FOO);
    open(FOO) or die "Can't open $FOO: $!";     # FOO lub giń!
    open(FOO) ? 'hi mom' : die "Can't open $FOO: $!";
                        # to ostatnie trochę egzotyczne

Instrukcja while wykonuje swój blok tak długo, jak wyrażenie jest prawdziwe (jego wartością nie jest łańcuch pusty, 0 czy ``0"). ETYKIETA jest opcjonalna, a jeśli jest obecna, składa się z identyfikatora, za którym następuje dwukropek. ETYKIETA identyfikuje pętlę dla instrukcji kontroli pętli, czyli next, last i redo. Jeśli pominięto ETYKIETĘ, instrukcje kontroli pętli odnoszą się do najbardziej wewnętrznej otaczającej pętli. Może to wymagać dynamicznego przeglądania wstecz stosu wywołań w czasie wykonania, aby znaleźć odpowiednią ETYKIETĘ. Takie desperackie zachowania dają zwykle ostrzeżenia przy włączonej fladze -w.

Jeśli istnieje BLOK continue, to jest on zawsze wykonywany tuż przed kolejną analizą warunku, podobnie jak trzeci element pętli for w C. Można tego używać do zwiększania zmiennej sterującej pętli, nawet gdy pętla jest właśnie kontynuowana instrukcją next (która jest z kolei podobna do instrukcji continue z C).

Kontrola pętli

    LINE: while (<STDIN>) {
        last LINE if /^$/;      # zakończ po obsłużeniu nagłówka
        ...
    }

Na przykład, podczas przetwarzania pliku takiego, jak /etc/termcap. Jeśli twoje wiersze wejściowe mogą się kończyć lewymi ukośnikami, wskazującymi kontynuację, możesz chcieć z wyprzedzeniem pobrać następny rekord.

    while (<>) {
        chomp;
        if (s/\\$//) {
            $_ .= <>;
            redo unless eof();
        }
        # teraz przetwórz $_
    }

    LINE: while (defined($line = <ARGV>)) {
        chomp($line);
        if ($line =~ s/\\$//) {
            $line .= <ARGV>;
            redo LINE unless eof(); # nie eof(ARGV)!
        }
        # teraz przetwórz $line
    }

    LINE: while (<STDIN>) {
        while (s|({.*}.*){.*}|$1 |) {}
        s|{.*}| |;
        if (s|{.*| |) {
            $front = $_;
            while (<STDIN>) {
                if (/}/) {      # koniec komentarza?
                    s|^|$front{|;
                    redo LINE;
                }
            }
        }
        print;
    }

    # zainspirowane przez :1,$g/fred/s//WILMA/
    while (<>) {
       ?(fred)?     && s//WILMA $1 WILMA/;
       ?(barney)?   && s//BETTY $1 BETTY/;
       ?(homer)?    && s//MARGE $1 MARGE/;
    } continue {
       print "$ARGV $.: $_";
       close ARGV   if eof();    # reset $. (nr wiersza)
       reset        if eof();    # reset ?wzorca?
    }

Instrukcje sterujące pętli nie współpracują z if ani unless, gdyż nie są one pętlami. Możesz jednak podwoić nawiasy by je nimi uczynić.

    if (/wzorzec/) {{
       next if /fred/;
       next if /barney/;
       # coś tu robi
    }}

Pętle for

    $i = 1;
    while ($i < 10) {
        ...
    } continue {
        $i++;
    }

Poza zwykłymi pętlami po indeksach tablic, for daje wiele innych zastosowań. Oto przykład, zapobiegający problemowi, który napotyka się testując jawnie EOF na interaktywnym deskryptorze pliku, co powoduje, że program wygląda jakby się zawiesił.

    $on_a_tty = -t STDIN && -t STDOUT;
    sub prompt { print "yes? " if $on_a_tty }
    for ( prompt(); <STDIN>; prompt() ) {
        # zrób coś
    }

Pętle foreach

    foreach my $elem (@elements) {
        $elem *= 2;
    }

    SWITCH: {
        $abc = 1, last SWITCH  if /^abc/;
        $def = 1, last SWITCH  if /^def/;
        $xyz = 1, last SWITCH  if /^xyz/;
        $nothing = 1;
    }

lub

    SWITCH: {
        /^abc/ && do { $abc = 1; last SWITCH; };
        /^def/ && do { $def = 1; last SWITCH; };
        /^xyz/ && do { $xyz = 1; last SWITCH; };
        $nothing = 1;
    }

    SWITCH: {
        /^abc/      && do {
                            $abc = 1;
                            last SWITCH;
                       };

        /^def/      && do {
                            $def = 1;
                            last SWITCH;
                       };

        /^xyz/      && do {
                            $xyz = 1;
                            last SWITCH;
                        };
        $nothing = 1;
    }

    SWITCH: {
        /^abc/ and $abc = 1, last SWITCH;
        /^def/ and $def = 1, last SWITCH;
        /^xyz/ and $xyz = 1, last SWITCH;
        $nothing = 1;
    }

    if (/^abc/)
        { $abc = 1 }
    elsif (/^def/)
        { $def = 1 }
    elsif (/^xyz/)
        { $xyz = 1 }
    else
        { $nothing = 1 }

    SWITCH: for ($where) {
                /In Card Names/     && do { push @flags, '-e'; last; };
                /Anywhere/          && do { push @flags, '-h'; last; };
                /In Rulings/        && do {                    last; };
                die "unknown value for form variable where: `$where'";
            }

    $amode = do {
        if     ($flag & O_RDONLY) { "r" }
        elsif  ($flag & O_WRONLY) { ($flag & O_APPEND) ? "a" : "w" }
        elsif  ($flag & O_RDWR)   {
            if ($flag & O_CREAT)  { "w+" }
            else                  { ($flag & O_APPEND) ? "a+" : "r+" }
        }
    };

        print do {
            ($flags & O_WRONLY) ? "write-only"          :
            ($flags & O_RDWR)   ? "read-write"          :
                                  "read-only";
        };

W większości tego typu przypadków, zazwyczaj dużo, dużo lepszym pomysłem jest używanie strukturalnych mechanizmów kontroli przepływu next, last lub redo, zamiast zwracać się ku goto. Dla niektórych zastosowań, para eval{} i die(), służąca do przetwarzania wyjątków może być też rozsądnym wyjściem.

POD: Osadzona dokumentacja

    % perl
    # line 200 "bzzzt"
    eval qq[\n#line 2001 ""\ndie 'foo']; print $@;
    __END__
    foo at - line 2001.

    % perl
    eval qq[\n#line 200 "foo bar"\ndie 'foo']; print $@;
    __END__
    foo at foo bar line 200.

    % perl
    # line 345 "goop"
    eval "\n#line " . __LINE__ . ' "' . __FILE__ ."\"\ndie 'foo'";
    print $@;
    __END__
    foo at goop line 345.

INFORMACJE O TŁUMACZENIU

man --locale=C 1 perlsyn