#!perl -w
use strict;
my $x=1;
my $y=2;
my @a=qw(1 2 3);
my @b=qw(7 8 9);

for my $pos(0..2) {
    print "$x:$a[$pos] $y:$b[$pos]\n";
}
[download]

The qw operator will see those arrays as a single element each. seperate with white space. You don't want a nested loop, you want to look at both arrays in a single loop over an index. I'll assume they are the same length.

my $x = 1;
my $y = 2;
my @a = qw(1 2 3);
my @b = qw(7 8 9);
for (0 .. $#a) {
    print "$x:$a[$_] $y: $b[$_]\n";
}
[download]

And in the spirit of TIMTOWTDI, the Perl6 inspired ...

sub zip {
    my ($ref1, $ref2) = @_;
    my @zip;
    while (@$ref1 || @$ref2) {
        push @zip => shift @$ref1 || undef;
        push @zip => shift @$ref2 || undef;
    }
    return @zip;
}

my $x = 1;
my $y = 2;

my @a=qw(1 2 3);
my @b=qw(7 8 9);

my @zip = zip(\@a, \@b);
while (my ($item, $element) = splice @zip => 0, 2) {
    print "$x: $item $y: $element\n";
}
[download]

Better written as:

for zip(@a,@b) -> $item, $element {
    say "$x: $item $y: $element";
}
[download]

But you'll have to wait a bit for that syntax to work :)

Just for my own edification, do you need to do "shift @$ref1 || undef"? shift will return undef if there are no elements in the array.

thor

Feel the white light, the light within
Be your own disciple, fan the sparks of will
For all of us waiting, your kingdom will come

No, it's not necessary. I was just being silly when I threw that together. I didn't give it too much thought.

Cheers,
Ovid

New address of my CGI Course.

my $x=1;
my $y=2;
my @a = qw(1 2 3);
my @b = qw(7 8 9);
my $count = 0;
foreach (@a) {
     print "$x:$_ $y:$b[$count];\n";
     $count++
}
[download]

There are more than enough Ways To Do It already presented - I just want to point out that the first three Ways were all assuming that the two arrays were of the same size. What happens when the arrays are different lengths depends on which solution you use. Ovid's solution was the most work, but if it is possible that the arrays are different sizes, that solution is the most robust, handling all cases quite well. Note that in that solution, the shorter array, if there is one, will be treated as if it were filled with undef's - which your code would have to handle, e.g.,

printf "%s:%s %s:%s\n",
  $x, defined $item ? $item : '<undef>',
  $y, defined $element ? $element : '<undef>';
[download]

Well, the first reply above was explicitly coded to the OP's questions and the second said it assumed equal length, so they were at least thinking about it but the undef handling is a good point. TIMTOWDI is fun and good practice. How about this? Handles different sized arrays and prints undefs nicely, too.

use strict;
my @a = qw( 1 2 3 );
my @b = qw( 7 8 9 10 );
my ($x, $y) = (1, 2);

for (my $i = 0; $i < @a || $i < @b;  ) {
    printf( "$x: %s $y: %s\n", 
            map { defined $_ ? $_ : 'undef' } ( $a[$i], $b[$i++] ) );
}
[download]

update: side effect -- will extend the shorter array with undefs. Could copy @a and @b before handing to the loop if this was a concern.

-xdg

Code written by xdg and posted on PerlMonks is public domain. It is provided as is with no warranties, express or implied, of any kind. Posted code may not have been tested. Use of posted code is at your own risk.

print map
{
    "$x:" . ($a[$_] ? $a[$_] : "undef") . " " .
    "$y:" . ($b[$_] ? $b[$_] : "undef") . ";" .
    "\n"
}
(0..($#a < $#b ? $#b : $#a));
[download]

Hi, Just try this easy

my $x=1;
my $y=2;
my @a=qw(1 2 3);
my @b=qw(7 8 9);
 
for my $y(0..$#a) {
    print "$x:$a[$y] $y:$b[$y]\n";
}
[download]

The output is
1:1 2:7
1:2 2:8
1:3 2:9

Regards,

Gubendran.L

Hi This is also another method try.

my $x=1;
my $y=2;
my @a=qw(1 2 3);
my @b=qw(7 8 9);
 
my $i=0;
for (@a){
    print "$x:$a[$i] "; 
    print "$y:$b[$i] "; 
    print "\n";          
    $i++;
}
[download]