Is it possible to assign two variables in Perl foreach loop?

Before 5.40 (5.36 with experimental warnings), it wasn't in the Perl 5 core language, but List::Util has a pairs function which should be close enough (and a number of other pair... functions which may be more convenient, depending on what you're doing inside the loop):

#!/usr/bin/env perl    

use strict;
use warnings;
use 5.010;

use List::Util 'pairs';

my @list = qw(a 1 b 2 c 3);

for my $pair (pairs @list) {
  my ($first, $second) = @$pair;
  say "$first => $second";
}

Output:

a => 1
b => 2
c => 3

The easiest way to use this is with a while loop that calls splice on the first two elements of the array each time,

while (my($var1, $var2) = splice(@array, 0, 2)) {
    ...
}

However, unlike foreach, this continually does a double-shift on the original array, so when you’re done, the array is empty. Also, the variables assigned are copies, not aliases as with foreach.

If you don’t like that, you can use a C-style for loop:

for (my $i = 0; $i < @array; $i += 2) {
     my($var1, $var2) = @array[$i, $i+1];
     ...
}

That leaves the array in place but does not allow you to update it the way foreach does. To do that, you need to address the array directly.

my @pairlist = (
    fee => 1,
    fie => 2,
    foe => 3,
    fum => 4,
);

for (my $i = 0; $i < @pairlist; $i += 2) {
    $pairlist[ $i + 0 ] x= 2;
    $pairlist[ $i + 1 ] *= 2;
}

print "Array is @pairlist\n";

That prints out:

Array is feefee 2 fiefie 4 foefoe 6 fumfum 8

You can get those into aliased variables if you try hard enough, but it’s probably not worth it:

my @kvlist = ( 
    fee => 1,
    fie => 2,
    foe => 3,
    fum => 4,
);

for (my $i = 0; $i < @kvlist; $i += 2) { 
    our  ($key, $value);
    local(*key, $value) = \@kvlist[ $i, $i + 1 ];
    $key   x= 2;
    $value *= 2;
}

print "Array is @kvlist\n";

Which prints out the expected changed array:

Array is feefee 2 fiefie 4 foefoe 6 fumfum 8

Note that the pairs offered by the List::Pairwise module, which were but very recently added to the core List::Util module (and so you probably cannot use it), are still not giving you aliases:

use List::Util 1.29 qw(pairs);

my @pairlist = (
    fee => 1,
    fie => 2,
    foe => 3,
    fum => 4,
);

for my $pref (pairs(@pairlist)) {
    $pref->[0] x= 2;
    $pref->[1] *= 2;
}

print "Array is @pairlist\n";

That prints out only:

Array is fee 1 fie 2 foe 3 fum 4

So it didn’t change the array at all. Oops. :(

Of course, if this were a real hash, you could double the values trivially:

for my $value (values %hash) { $value *= 2 }

The reasons that works is because those are aliases into the actual hash values.

You cannot change the keys, since they’re immutable. However, you can make a new hash that’s an updated copy of the old one easily enough:

my %old_hash = (
    fee => 1,
    fie => 2,
    foe => 3,
    fum => 4,
);

my %new_hash;    
@new_hash{ map { $_ x 2 } keys   %old_hash } = 
           map { $_ * 2 } values %old_hash;

print "Old hash is: ", join(" " => %old_hash), "\n";
print "New hash is: ", join(" " => %new_hash), "\n";

That outputs

Old hash is: foe 3 fee 1 fum 4 fie 2
New hash is: foefoe 6 fiefie 4 fumfum 8 feefee 2

A general algorithm for more than 2 variables:

while( @array ){
  my $var1 = shift @array;
  my $var2 = shift @array;
  my $var3 = shift @array;
  # other variables from @array

  # do things with $var1, $var2, $var3, ...
}

PS: Using a working copy of the array to that it is preserved for use later:

if( my @working_copy = @array ){
  while( @working_copy ){
    my $var1 = shift @working_copy;
    my $var2 = shift @working_copy;
    my $var3 = shift @working_copy;
    # other variables from @working_copy

    # do things with $var1, $var2, $var3, ...
  }
}

PPS: another way is to use indexing. Of course, that is a sure sign that the data structure is wrong. It should be an array of arrays (AoA) or an array of hashes (AoH). See perldoc perldsc and perldoc perllol.

my $i = 0;
while( $i < @array ){
  my $var1 = $array[ $i++ ];
  my $var2 = $array[ $i++ ];
  my $var3 = $array[ $i++ ];
  # other variables from @array

  # do things with $var1, $var2, $var3, ...
}

PPPS: I've been asked to clarify why the data structure is wrong. It is a flatten set of tuples (aka records aka datasets). The tuples are recreated by counting of the number of data for each. But what is the reader constructing the set has a bug and doesn't always get the number right? If, for a missing value, it just skips adding anything? Then all the remaining tuples are shifted by one, causing the following tuples to be grouped incorrectly and therefore, invalid. That is why an AoA is better; only the tuple with the missing data would be invalid.

But an better structure would be an AoH. Each datum would access by a key. Then new or optional data can be added without breaking the code downstream.

While I'm at it, I'll add some code examples:

# example code for AoA
for my $tuple ( @aoa ){
  my $var1 = $tuple->[0];
  my $var2 = $tuple->[1];
  my $var3 = $tuple->[2];
  # etc
}

# example code for AoH
for my $tuple ( @aoh ){
  my $var1 = $tuple->{keyname1};
  my $var2 = $tuple->{key_name_2};
  my $var3 = $tuple->{'key name with spaces'};
  my $var4 = $tuple->{$key_name_in_scalar_variable};
  # etc
}

As of Perl v5.40 this is now built into the language (it was an experimental feature starting int Perl v5.36).

With it, you could write your example code like so:

foreach my($var1, $var2) (@array) {...}

Here's a complete example (of arguable value):

#!/usr/bin/env perl

use 5.040;

my($hashref) = {};

foreach my($key, $value) (qw( foo 1 bar 2 baz 3 )) {
    $hashref->{$key} = $value;
}

foreach my($key, $value) (%$hashref) {
    say "$key: $value";
}

which would produce the following output:

baz: 3
foo: 1
bar: 2

brian d foy has an excellent article on the subject:

https://www.effectiveperlprogramming.com/2024/06/iterate-over-multiple-elements-at-the-same-time/

As of perl-5.40 this is now built into the language.
See below for ways of doing it circa 2015 :-)

Here is a module-less way to "loop" by an arbitrary value ($by) and output the resulting group of elements using an array slice:

#!perl -l
@array = "1".."6"; 
$by = 3; $by--; 

for (my $i = 0 ; $i < @array ; $i += $by ) { 
      print "@array[$i..$i+$by]"; 
      $i++ ;
}

As a one-liner to test (cut and paste to a Unix shell):

perl -E '@array = "1".."6"; $by = 3; $by--; 
      for (my $i = 0 ; $i < @array ; $i += $by ) { 
      say "@array[$i..$i+$by]"; $i++ }'

Output:

1 2 3
4 5 6

If you make $by = 2; it will print pairs of numbers. To get at specific elements of the resulting slice access it as an anonymous array: (e.g. [@array[$i..$i+$by]]->[1]).

See also:

• How do I read two items at a time in a Perl foreach loop?
• Perl way of iterating over 2 arrays in parallel

Some good responses there, including reference to natatime which is quite easy to use. It's easy to implement too - it is essentially a wrapper around the splice solutions mentioned in the responses here.

The following is not the nicest example, but I've been using autobox::Core and made an @array->natatime() "method" ;-) like this:

use autobox::Core ;
sub autobox::Core::ARRAY::natatime {
  my ($self, $by) = @_; 
  my @copy = @$self ;
  my @array ;
  
  push @array, [splice (@copy, 0, $by) ] while @copy ;
  
  if  ( not defined wantarray ) { 
      print "@{ $_ } \n" for @array ;
  } 

  return wantarray ? @array : \@array;      
}

The @copy array is spliced destructively, but $self (which is how the @array in front of the autobox method -> arrow gets passed to the function) is still there. So I can do:

my @dozen = "1" .. "12" ;           # cakes to eat
@dozen->natatime(4)  ;              # eat 4 at time
my $arr_ref = @dozen->natatime(4) ; # make a reference
say "Group 3: @{ $arr_ref->[2] }" ; # prints a group of elements
say scalar @dozen , " cakes left" ; # eat cake; still have it

Output:

1 2 3 4 
5 6 7 8 
9 10 11 12 
Group 3: 9 10 11 12
12 cakes left

One other approach that also uses a CPAN module (I gave this answer elsewhere but it is worth repeating). This can also be done non-destructively, with Eric Strom's excellent List::Gen module:

perl -MList::Gen=":all" -E '@n = "1".."6"; say "@$_" for every 2 => @n'
1 2
3 4
5 6

Each group of elements you grab is returned in an anonymous array so the individual values are in: $_->[0] $_->[1] ... etc.

You mentioned Perl6, which handles multiple looping values nicely:

my @qarr = 1 .. 6;
my ($x, $y, $z) ;
for @qarr -> $x , $y , $z { say $x/$y  ; say "z = " ~ $z }

Output:

0.5
z = 3
0.8
z = 6

For more on the Perl6 approach see: Looping for Fun and Profit from the 2009 Perl6 Advent Calendar, or the Blocks and Statements Synopsis for details. Perhaps Perl 5 will have a similar "loop by multliple values" construct one day - à la perl5i's foreach :-)