$are_equal = compare_arrays(\@frogs, \@toads);

sub compare_arrays {
    my ($first, $second) = @_;
    no warnings;  # silence spurious -w undef complaints
    return 0 unless @$first == @$second;
    for (my $i = 0; $i < @$first; $i++) {
        return 0 if $first->[$i] ne $second->[$i];
    }
    return 1;
}
[download]

Note that compare_arrays returns as soon as it can determine the equality - immediately if the refs point at the same array. If not, it returns as soon as it finds the first difference.

Update: Misread it as $first == $second zigdon is correct

Don't you mean that it returns as soon as it can determine the arrays are different? Immediately if the arrays are not of the same length!

-- Dan

Update: In deference to Arien's concerns.

if ( do{ local$"=''; @array1 == @array2 and "@array1" eq "@array2"} ) 
+{ 
    print 'They are the same', $/; 
}
[download]

Which of course will also break if you have two arrays,

my @a = ( 'onetwo','', 'three');
my @b = ( 'one', 'two', 'three' );
[download]

And as with any shortcuts, you need to know your data before you apply them. If your not comforable with that, don't use it.

Update more:

I'll spell it out for those unable or unwilling to make the mental leap for themselves.

If your data is wholey numeric, then use $"=<any non-numeric-char>.

If your data consists of wholey alpha data use a non-alpha char.

If your data consists of mixed alpha-numeric then use a non-alpha-numeric.

If your data can contain any char in the range 32-127, cosider using a control character (eg."\cA").

If your data can contain any 7-bit char, use an 8-bit char. 128-255.

If there is simply no character that your data does not contain, then you need to compare element-by-element. These cases are very rare. In almost all normal sets of data it is possible to find a single char that you can get away with using, and eq testing of the stringyfied arrays is a simple, and efficient way of performing this kind of test on small datasets.

That doesn't necessarily work as intended if the values of one or more elements in either array contain the list separator $":

my @array1 = qw(one two three);
my @array2 = ("one" . $" . "two", "three");

if ("@array1" eq "@array2") {
    print 'They are the same', $/;   # no, they are NOT
}
[download]

The updated code is still flawed, consider:

my @array1 = qw(one two three);
my @array2 = qw(onetwo three);

if ( do{ local $" = ''; "@array1" eq "@array2"} ) {
    print 'They are the same', $/;   # no, they are NOT
}
[download]

This second update still isn't the way to do it... I took out the local $" (which should be no problem as the value of $" shouldn't matter anyway). Consider:

my @array1 = ("one", "two" . $" . "three");
my @array2 = ("one" . $" . "two", "three");

if ( do{ @array1 == @array2 and "@array1" eq "@array2"} ) { 
    print 'They are the same', $/;    # no, they are NOT
}
[download]

Stringifying would only work if it is guaranteed that $" doesn't occur as a substring of one or more values of either array.

— Arien

my $ary1 = join(/\0/, sort(@array1));
my $ary2 = join(/\0/, sort(@array2));
if ($ary1 eq $ary2) {....}
[download]

But of course if you do a sort first then you loose the position of the elements in the array. If the position of the elements is not significant, this is a good solution.

CountZero

"If you have four groups working on a compiler, you'll get a 4-pass compiler." - Conway's Law

use Data::Dumper;
...
(Dumper(@a) eq Dumper(@b))?print "same":print "different";
[download]

sub array_eq {
    my($ar1, $ar2) = @_;
    @$ar1 == @$ar2 or return 0;
    return !grep { $ar1->[$_] ne $ar2->[$_] } 0 .. $#$ar1;
}

print array_eq (['one', 'two', 'three'], ['three', 'one', 'two']) ?   
+ 'the same' : 'different';
[download]