for a clue, try print ref {qw/1 2 3/}

for an interesting tidbit run perl -we"sub f{{@_}};print ref(f(1,2,3))"
and then perl -we"sub f{return {@_}};print ref(f(1,2,3))"

from perldoc -f each

...There is a single iterator for each hash, shared by all "each", "keys", and "values" function calls in the program; it can be reset by reading all the elements from the hash, or by evaluating "keys HASH" or "values HASH". If you add or delete elements of a hash while you're iterating over it, you may get entries skipped or duplicated, so don't. Exception: It is always safe to delete the item most recently returned by "each()"...

Also note that the order of the values of @array will not stay in the same order they were in, because this is a hash, but of course pairs will stay pairs ;)

update jmcnamara says the above creates an infinate loop; well that it does, but you gotta admit, it's an ingenious way to get random pairs ;)

you're probably better off writing something like

while(my($one,$two)=(shift(@aray),shift(@aray)) ) { ...

#or even
while(my($one,$two) = splice(@aray,0,2) ) { ...
[download]

update: I thought about getting smart, so I tried

my @array = qw/ 1 2 3 4/;

while(my($one,$two) = Each(\@array) ) {
    print "$one = $two \n";
}

sub Each {
  my $r = shift;
  my $counter;

  unless(@$r) {
    warn "empty array";

    return;
  }

  unless($r->[-2] eq $r) {
    push(@$r, $r);
    push(@$r,0);
  }

  $counter = $r->[-1];

  my $one = $counter < scalar(@$r) - 3 ? $r->[$counter] : undef;

  $counter++;

  my $two;
  if( $counter < scalar(@$r) - 2 ) {
    $two = $r->[$counter];
  } else {
    warn "finally gone through it";
    return;
  }

  $r->[-1] = $counter;

  if(2 == @$r) {
    warn "gone trhough it, nothing left to see";

    return;
  }


  return ($one, $two);

}
[download]

F:\dev>perl each.pl
1 = 2
2 = 3
3 = 4
finally gone through it at each.pl line 32.

 

______crazyinsomniac_____________________________ Of all the things I've lost, I miss my mind the most. perl -e "$q=$_;map({chr unpack qq;H*;,$_}split(q;;,q*H*));print;$q/$q;"

One other side effect of the single iterator is that you can't use nested each loops on the same hash. Try this:

use strict;

my %hash = (FOO => 'foo', BAR => 'bar', FUBAR => 'fubar');
my ($key1, $val1);
my ($key2, $val2);

while (($key1, $val1) = each %hash)
{
    print "OUTER: $key1=$val1\n";

    while (($key2, $val2) = each %hash)
    {
        print "  INNER: $key2=$val2\n";
    }
}
[download]

This bit me once where a not-so-good design had me iterating through the same hash nested, but pretty far apart so it wasn't obvious. Imagine that the inner loop above is really several calls away in another package and you get the idea.

for (my $i = 0; $i < $#array; $i+=2)
{
    my ($first, $second) = @array[$i, $i+1];

    # Do stuff here ...
}
[download]

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

Why do some people speak Perl with a C accent? {grin} A more native Perl solution:

my @copy = @array;
while (my ($first, $second) = splice @copy, 0, 2) {
  # do stuff
}
[download]

Your code has many potential "off by one" locations. Yes, it's possible to get it exactly right, but much safer to let Perl deal with the edges than for me to keep computing the edges. Call it defensive programming.

-- Randal L. Schwartz, Perl hacker