my %hash;
for my $key (@array2){
  $hash{$key}++;
}

for my $key (@array1){
  print "Fail: %key \n" unless $hash{$key};
}
[download]

for my $key (@array2){
  $hash{$key}++
  print "Fail $key" unless grep($key, @array1);
}
[download]

my $hash;
while (@array1){
  my $var1 = shift @array1;
  my $var2 = shift @array2;
  
  if($var1 == $var2){
    $hash{$var1}++;
  } else {
    print "Key mismatch array1 value $var1 != $var2 (array2 value)";
  }
}
[download]

Ah OK I understand why it's happening now. I can stick a check in for the array length prior to running this to avoid the fatal error you are on about. Is there anyway to do this without a destructive process on the arrays ?

Use my compare2(), or List::Compare or Array::Compare.

#!/usr/bin/perl -w

use strict;

my @a = qw(a b c e);
my @b = qw(a b c d g);

compare1 (\@a,\@b);
compare2 (\@a,\@b);

sub compare1 
{
   my ($aref, $bref) = @_;
   
   my %a = map{$_=>0}@$aref;
   my %b = map{$_=>0}@$bref;
   
  foreach (keys %a)
   {
     $a{$_}++ if (exists ($b{$_})); 
   }
   
   foreach (keys %b)
   {
      $b{$_}++ if (exists $a{$_});   
   }
   
   foreach (keys %a)
   {
      print "$_ does not exist in B\n" if !$a{$_};
   }
   
   foreach (keys %b)
   {
      print "$_ does not exist in A\n" if !$b{$_};   
   }
}

sub compare2
{
   my ($aref, $bref) = @_;
   my @a = @$aref;
   my @b = @$bref;
   
   while (@a || @b)
   {
      my ($compa, $compb) = (shift @a, shift @b);
      $compa = 'undefined' if (!defined($compa)); 
      $compb = 'undefined' if (!defined($compb));
      if ($compa ne $compb)
      {  
         print "$compa and $compb do not match\n";
      } 
   }
}

__END__
e does not exist in B
g does not exist in A
d does not exist in A

e and d do not match
undefined and g do not match
[download]

Thanks for the information. I wanted to avoid using modules becuase I don't learn anything by doing it that way.

Perl is a "get the job done" kind of S/W tool and many of the Perl modules do help. They aren't all good or wise to use in all situations. However, when they do some "grunt work" for you so that you can think about bigger problems, I figure that is just fine. But when 5 lines of code does all you need and exactly what you need, then that's a different story.

I tried this and get an uninitalized value error in the print

Are you sure the warnings comes from that line? The line you've shown produces "Use of uninitialized value in concatenation" (and not print), so maybe a different line is to blame?

Also I can recommend to use perl 5.10 or newer, it often tells you which variable was actually undefined.

That said your piece of code can produce such warnings when @array1 contains undef elements - what do you want to do in that case?

Unfortunately I am unable to upgrade to Perl 5.10 at the moment so need to find a solution for Perl 5.8.8
I'm confused as to why the code produces the concatenation error as you've discovered.
The question is how do I get it to print both sides of the mismatch and I admit I hadn't catered for undef elements. Can you advise me on how to cater for both of those issues using the code posted ?

Can you advise me on how to cater for both of those issues using the code posted ?

You can always use defined to check if an element is not undef, and do whatever you want with that information.

Perl 6 - links to (nearly) everything that is Perl 6.

If the array elements match up by index, why not compare them iterating over the arrays?

for my $i (0..$#array1) {
    if ($array1[$i] eq $array2[$i]) {
        ...
    }
}
[download]