for my $element (@array) {
    print $element, "\n";
}
[download]

And, for completeness, iterating over indices:

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

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

Further to choroba's reply: For even more complete completeness, if you're dealing with array references:

for my $element (@$arrayref) {
    print $element, "\n";
    }

for my $i (0 .. $#$arrayref) {
    print "$i: $arrayref->[$i]\n";
    }
[download]

Update: Digioso: I quite agree with your preference for using explicitly named variables rather than default names (or none at all) in the interests of readability and maintainability. I disagree that the C-style for-loop serves these interests, quite apart from the lurking demon Offbyone.

Well, many things may bring the same results. :) The C-Style Loop also allows to do something like this:

for($i = $#sizes; $i >= 0 ; --$i)
{
    print $sizes[$i];
}
[download]

I haven't tested it yet whether this also works:
for my $i ($#$arrayref .. 0)

And you can also do this:

for(my $i = 0; $i <= #$arrayref; $i+=2)
{
 print "$i: $arrayref->[$i]\n";
}
[download]

Yes, you could do instead:

for my $i (0 .. $#$arrayref)
{
    print "$i: $arrayref->[$i]\n";
    $i++;
}
[download]

But here you have to be aware that $i is incremented by 1 by the loop itself and then again by 1 through $i++. Makes it a bit more difficult to read imho.
I guess in the end it's what you prefer. :)

for my $i ($#$arrayref .. 0) { ... } does not work (initial value of a range must be <= than its terminal value) but

c:\@Work\Perl\monks>perl -wMstrict -le
"my $arrayref = [ qw(uno dos tres quatro cinco) ];
 ;;
 for my $i (reverse 0 .. $#$arrayref) {
   print qq{$i: $arrayref->[$i]};
   }
"
4: cinco
3: quatro
2: tres
1: dos
0: uno
[download]

does and is more readable (again, IMHO).

Having a strange step might be handled by something like

c:\@Work\Perl\monks>perl -wMstrict -le
"my $arrayref = [ qw(uno dos tres quatro cinco) ];
 ;;
 for my $i (grep { $_ % 2 == 0 } 0 .. $#$arrayref) {
   print qq{$i: $arrayref->[$i]};
   }
"
0: uno
2: tres
4: cinco
[download]

which I would tend to favor. The only problem with this kind of loop range expression is that the complete  0 .. $#$arrayref range is built as an intermediate list, so if you're dealing with a large range of any kind you may chew up a lot of memory. The Perl compiler knows enough to optimize a  for my $n (0 .. MAX) { ... } loop to the equivalent C-style for-loop, so no potentially huge list is ever generated; it can't do that trick for  for my $n (grep { whatever } 0 .. MAX) { ... } or similar blocks.

(Another interesting candidate for this sort of thing might be List::MoreUtils::indexes or one of its cousins; also see List::Util.)

---

Give a man a fish:  <%-{-{-{-<

foreach my $line (@$array_ref)
{
   print $line;
}
[download]

I write and lot of C code (and also ASM). I can tell you that the very, very most common error in programming is the "off by one" error. The  foreach() syntax avoids that possibility. There are a lot of programs out there that sometimes break in mysterious ways due to memory allocation errors and other issues related to the "off by one" problem. the foreach() syntax avoids this problem.

You early instruction will serve you well. There is just a different way to do it in Perl than in C.