The explanation here is that $x is bound to the first array item (1) in the first iteration, and to the second array item (which is then 3) in the second iteration. At that time there's no third item in the array anymore, and the body of the loop is executed only twice (as you can see from your debugging output).

It becomes a bit clearer if you also print out $x in the loop body.

Use a while loop instead of a for loop:

@a = 1 .. 10;;

while( defined( my $x = shift @a ) ) { 
    print $x 
};;
1
2
3
4
5
6
7
8
9
10

print scalar @a;;
0
[download]

If any part of LIST is an array, foreach will get very confused if you add or remove elements within the loop body, for example with splice. So don't do that.

In Perl, the foreach loop causes $x to become each thing in the array successively without: a)modifying the size of @arr (the $x value can be use to modify a value in @arr); b) needing a subscript and c)perhaps more importantly, you don't have to worry about the ending condition being: i<=max or i<max! "off-by-one" is a VERY common error.

If you want to keep track of how many x's there have been processed so far, then something like this is a better way to go because the looping construct doesn't depend upon the $count value, meaning that you won't "overflow" the array bounds even if your count should have started at 0 instead of 1 or maybe a --$count vs $count++ boo-boo:

my @arr =(10,11,12);
my $count =1;
foreach my $x (@arr)
{
   print $count++," $x\n";
}
#prints
#1 10
#2 11
#3 12
[download]

while (@tokens)
{
   my ($x, $y) = splice(@tokens,0,2);
   .....use $x and $y to do something...
   ..next loop causes another pair of $x, $y to be
     used if there are any left in @tokens
}
[download]

#!/usr/bin/perl -w
use strict;

my @arr = ( 11, 12, 13, 14 );

while (@arr)
{
   my $x = shift(@arr);
   print "this item=$x #left in arr ".@arr."\n";
}
=prints
this item=11 #left in arr 3
this item=12 #left in arr 2
this item=13 #left in arr 1
this item=14 #left in arr 0
=cut
[download]

The problem is you're trying to iterate over an array that you're changing. You enter your loop and set $x to 1 (which occupies index 0). You then shift '1' out and lower the indices of all remaining elements. When you hit the beginning of the loop again, $x is set to 3 because it's now in index 1. You then shift 2 out and your loop exits because there's nothing at index 2 (or index 1 for that matter).

my @arr = ( 1, 2, 3 );

for my $x ( shift @arr ) {
  #do some stuff
}
[download]

Edit: What the hell was I thinking when I wrote that? I meant to write the while loop that BrowserUk wrote below. Please do not use my answer. It doesn't work.

my @a = ( 1 .. 4, undef, 6 .. 10 );

while (@a) {
  my $x = shift @a;
  say defined $x ? $x : 'undef';
}
[download]

use warnings;
use strict;

use Data::Dumper;

my @arr = ( 1, 2, 3 );

for (my $i = scalar @arr - 1; $i >= 0; $i --)  {
        my $a = pop @arr;
        print "$a\n";
        print Dumper(\@arr); 
}

print Dump(@arr);
[download]

for my $x (@{[]} = @arr) {
    ...
}
[download]

FWIW, adding an empty list also makes a copy of the elements (on the internal stack) to iterate over:

for my $x ((), @arr)  {
    ...
}
[download]