En Perl, ¿hay una forma integrada de comparar dos matrices para la igualdad?

Está la función is_deeply() de Test::More, que también mostrará exactamente dónde difieren las estructuras, o la función eq_deeply () de Test::Deep, que no requiere un arnés de prueba (y solo devuelve true o false).

No está incorporado, pero hay Array::Compare.

Esta es una de las operaciones que queda fuera del núcleo de Perl por lo que creo que son razones didácticas that es decir, si estás tratando de hacerlo, probablemente hay algo mal. El ejemplo más ilustrativo de esto, creo, es la ausencia de una función core read_entire_file; básicamente, proporcionar esa función en el núcleo llevaría a la gente a pensar que es una buena idea hacer eso, pero en cambio, Perl está diseñado de una manera que suavemente le empuja hacia el procesamiento de archivos línea a línea, que generalmente es mucho más eficiente y por lo demás una mejor idea, pero los programadores novatos rara vez se sienten cómodos con él y necesitan un poco de aliento para llegar allí.

Lo mismo se aplica aquí: probablemente hay una manera mucho mejor de hacer la determinación que está tratando de lograr comparando dos matrices. No necesariamente, pero probablemente. Así que Perl te está empujando a pensar en otras formas de lograr tu objetivo.

Perl 5.10 le da el operador smart match.

use 5.010;

if( @array1 ~~ @array2 )
{
    say "The arrays are the same";
}

De lo contrario, como usted ha dicho, usted tendrá top roll su propio.

Mientras esté usando perl 5.10 o posterior, puede usar el operador smart match.

if (@array1 ~~ @array2) {...}

La solución más simple es más rápida:

#!/usr/bin/perl

use strict;
use warnings;

use Array::Compare;
use Benchmark qw( cmpthese );
use List::AllUtils qw( each_arrayref );

my @x = 1 .. 1_000;
my @y = map { "$_" } 1 .. 1_000;

my $comp = Array::Compare->new;

cmpthese -2, {
    iterator => sub { my $r = elementwise_eq(\(@x, @y)) },
    my_comp => sub { my $r = my_comp(\(@x, @y)) },
    array_comp => sub { my $r = $comp->compare(\(@x, @y)) },
};

@x = 1 .. 20, map { rand } 1 .. 1_000;
@y = 1 .. 20, map { rand } 1 .. 1_000;

cmpthese -2, {
    iterator => sub { my $r = elementwise_eq(\(@x, @y)) },
    my_comp => sub { my $r = my_comp(\(@x, @y)) },
    array_comp => sub { my $r = $comp->compare(\(@x, @y)) },
};

sub elementwise_eq {
    my ($xref, $yref) = @_;
    return unless  @$xref == @$yref;

    my $it = each_arrayref($xref, $yref);
    while ( my ($x, $y) = $it->() ) {
        return unless $x eq $y;
    }
    return 1;
}

sub my_comp {
    my ($xref, $yref) = @_;
    return unless  @$xref == @$yref;

    my $i;
    for my $e (@$xref) {
        return unless $e eq $yref->[$i++];
    }
    return 1;
}

Y resulta en perl 5, version 14, subversion 2 (v5.14.2) built for x86_64-linux-gnu-thread-multi:

             Rate   iterator array_comp    my_comp
iterator   1544/s         --       -67%       -80%
array_comp 4697/s       204%         --       -41%
my_comp    7914/s       413%        68%         --
               Rate   iterator array_comp    my_comp
iterator    63846/s         --        -1%       -75%
array_comp  64246/s         1%         --       -75%
my_comp    252629/s       296%       293%         --

Para comprobar la igualdad de dos matrices pruebe esto. En el código dado, si %eq_or_not tiene algún valor entonces ambos arrays no son iguales de lo contrario son iguales.

my @array1 = ("part1", "part2", "part3", "part4");
my @array2 = ("part1", "PART2", "part3", "part4");

my %eq_or_not;

@eq_or_not{ @array1 } = undef;
delete @eq_or_not{ @array2 };

Esta pregunta se ha convertido en un recurso muy útil. ++ for the benchmarks and discussion.

Como otros han señalado, la función smart match tuvo problemas y se está eliminando gradualmente en su forma actual. Hay alternativas que son "menos inteligentes" (y así evitar los problemas) y que son pequeños, bastante rápido y no tienen demasiadas dependencias no CENTRALES.

• Smart::Match
• match::simple (y match::smart)
• Scalar::In

Puedes encontrar enlaces a algunas discusiones bastante buenas sobre la historia del futuro de ~~ mirando un par de entradas de blog por @brian d foy, y el archivo de correo p5p hilos de 2011 y 2012 de @rjbs.

Comparar matrices puede ser simple y divertido!

use v5.20;   
use match::smart; 
my @x = (1, 2, 3);       
my @y = qw(4 5 6);    
my @z = qw(4 5 6);   
say \@x |M| \@y ? "[\@x] and [\@y] match": "no match";  
say \@y |M| \@z ? "[\@y] and [\@z] match": "no match";

__END__                              
@y and @z match, @x and @y do not

... especialmente divertido si la matriz es simple. Pero una matriz puede ser algo complicado, y a veces quieren diferentes tipos de información de los resultados de la comparación. Para eso, Array::Compare puede hacer la comparación más fácil.

Si la carcasa es la única diferencia, simplemente puede usar:

if (lc "@array1" eq lc "@array2") {...}

Mientras que "@array1" devuelve lo mismo que join ( " ", @array1 )

Si el orden y los valores duplicados no importan, sino solo la igualdad de los valores (es decir, la comparación de conjuntos), podría usar Set::Scalar.

Sobrecarga operadores comunes como == o !=.

my @array1 = ("part1", "part2", "part3", "part4");
my @array2 = ("part1", "PART2", "part3", "part4");

if ( Set::Scalar->new(@array1) == Set::Scalar->new(@array2) ) {...}

Alternativamente, también hay Algorithm::Diff y List::Compare.

Data::Cmp es otra opción reciente. La función cmp_data() funciona de manera similar al operador cmp (ver perlop para cmp uso).

Ejemplo:

use 5.10;
use Data::Cmp qw/cmp_data/;

my @array1 = ("part1", "part2", "part3", "part4");
my @array2 = ("part1", "PART2", "part3", "part4");
my @array3 = ("part1", "PART2", "part3", "part4");

# sample usage 
say "1 & 2 are different" if cmp_data(\@array1, \@array2) ;
sat "2 & 3 are the same" unless cmp_data(\@array2, \@array3) ;

También es posible comparar hashes y estructuras de datos anidadas más complicadas (dentro de lo razonable). Para un solo módulo sin dependencias no básicas, Data::Cmp es bastante "inteligente" ;-) ... errm quiero decir "útil".

Se podría usar la función grep en un contexto escalar ( http://perldoc.perl.org/functions/grep.html#grep-BLOCK-LIST )

(0 eq (grep {arra array1 [ne_] ne ne array2 [ _ _ ]} 0..$#array1)) if arra#array1 eq arra#array2;

HIH.

Si el único criterio es "son equivalentes o no?"y no la pregunta más compleja, "son equivalentes o no, y si son distintos, ¿cómo?"hay formas mucho más rápidas/feas de hacerlo. Por ejemplo, rompa la totalidad de cada matriz en dos escalares y compárelos.

Por ejemplo

my @array1 = ("part1", "part2", "part3", "part4");
my @array2 = ("part1", "PART2", "part3", "part4");

my $smash1 = join("", @array1);
my $smash2 = join("", @array2);

if ($smash1 eq $smash2)
{
  # equal
}
else
{
  #unequal
}

Sí, probablemente acabo de hacer llorar a Larry Wall.