¿Cómo comparo dos hashes en Perl sin usar Data :: Compare?

Question

¿Cómo comparo dos hash en Perl sin utilizar Data :: Compare?

Answer 1

El mejor enfoque es diferente de acuerdo a sus propósitos. El elemento de preguntas frecuentes mencionado por Sinan es un buen recurso: How do I test whether two arrays or hashes are equal?. Durante el desarrollo y la depuración (y, por supuesto, al escribir pruebas unitarias), he encontrado que Test::More es útil al comparar matrices, hashes y estructuras de datos complejas. Un ejemplo sencillo:

use strict; 
use warnings; 

my %some_data = (
    a => [1, 2, 'x'], 
    b => { foo => 'bar', biz => 'buz' }, 
    j => '867-5309', 
); 

my %other_data = (
    a => [1, 2, 'x'], 
    b => { foo => 'bar', biz => 'buz' }, 
    j => '867-5309x', 
); 

use Test::More tests => 1; 
is_deeply(\%other_data, \%some_data, 'data structures should be the same'); 

Salida:

1..1 
not ok 1 - data structures should be the same 
# Failed test 'data structures should be the same' 
# at _x.pl line 19. 
#  Structures begin differing at: 
#   $got->{j} = '867-5309x' 
#  $expected->{j} = '867-5309' 
# Looks like you failed 1 test of 1. 

Answer 2

Ver How do I test whether two arrays or hashes are equal?

FAQ de Perl y respuestas son parte de ti distribución de Perl. Puede ver la versión de esta respuesta que viene con su perl ejecutando:

$ perldoc -q equal

en su terminal.

Answer 3

comparar no es una frase bastante detallada cuando se habla de valores hash. Hay muchas maneras de comparar los hashes:

¿Tienen el mismo número de llaves?

if (%a == %b) { 
    print "they have the same number of keys\n"; 
} else { 
    print "they don't have the same number of keys\n"; 
} 

¿Las teclas son las mismas en ambos hashes?

if (%a != %b) { 
    print "they don't have the same number of keys\n"; 
} else { 
    my %cmp = map { $_ => 1 } keys %a; 
    for my $key (keys %b) { 
     last unless exists $cmp{$key}; 
     delete $cmp{$key}; 
    } 
    if (%cmp) { 
     print "they don't have the same keys\n"; 
    } else { 
     print "they have the same keys\n"; 
    } 
} 

¿Tienen las mismas teclas y los mismos valores en ambos hashes?

if (%a != %b) { 
    print "they don't have the same number of keys\n"; 
} else { 
    my %cmp = map { $_ => 1 } keys %a; 
    for my $key (keys %b) { 
     last unless exists $cmp{$key}; 
     last unless $a{$key} eq $b{$key}; 
     delete $cmp{$key}; 
    } 
    if (%cmp) { 
     print "they don't have the same keys or values\n"; 
    } else { 
     print "they have the same keys or values\n"; 
    } 
} 

¿Son isomorfos (I saldrán de éste hasta el lector como yo particularmente no quiero probar la aplicación desde cero)?

o alguna otra medida de la igualdad?

Y, por supuesto, este código sólo se ocupa de los hashes simples. Agregar estructuras de datos complejas lo hace aún más complejo.

Answer 4

rápida, sucio, y estoy seguro de que no eficiente:

use strict; 
use warnings; 

use Data::Dumper; 

sub compare ($$) { 
    local $Data::Dumper::Terse = 1; 
    local $Data::Dumper::Indent = 0; 
    Dumper(shift) eq Dumper(shift); 
} 

my %a = (foo => 'bar', bar => [ 0 .. 3 ]); 
my %b = (foo => 'bar', bar => [ 0 .. 3 ]); 
my %c = (foo => 'bar', bar => [ 0 .. 4 ]); 

print Dumper compare \%a, \%b; 
print Dumper compare \%a, \%c; 

Answer 5

Para comparar:

sub HashCompare { 
    my ($a, $b) = @_; 
    my %rhash_1 = %$a; 
    my %rhash_2 = %$b; 

    my $key   = undef; 
    my $hash_2_line = undef; 
    my $hash_1_line = undef; 

    foreach $key (keys(%rhash_2)) { 
    if (exists($rhash_1{$key})) { 
    if ($rhash_1{$key} ne $rhash_2{$key}) { 
    print "key $key in $file_1 = $rhash_1{$key} & $rhash_2{$key} in $file_2\n"; 
     } 
     } 
    } 
    else { 
     print "key $key in $file_1 is not present in $file_2\n"; 

      #next; 
     } 
    } 

    foreach my $comp_key (keys %rhash_1) { 
     if (!exists($rhash_2{$comp_key})) { 
      print MYFILE "key $comp_key in $file_2 is not present in $file_1\n"; 
     } 
    } 
    return; 
} 

Creación de hash sin duplicados de las llaves:

sub CreateHash { 
    my (@key_val_file) = @_; 
    my $key_count  = 1; 
    my %hash_key_val =(); 
    my $str4   = undef; 

    local $/ = undef; 

    foreach my $each_line (@key_val_file) { 
      @key_val = split(/,/, $each_line); 
      if (exists($hash_key_val{$key_val[0]})) { 
        $key_count = $key_count + 1; 
        $str4  = $key_val[0] . " occurence-" . $key_count; 
        $hash_key_val{$str4} = $key_val[1]; 
       } 
       else { 
        $hash_key_val{$key_name} = $key_val[1]; 
       } 
      } 
     } 

     $key_count = 1; 

    close FILE; 

    return %hash_key_val; 
} 

Answer 6

@zakovyrya Ver esta respuesta: https://stackoverflow.com/a/2011443/2606517 El orden de las claves proviene de una estructura de datos interna.

Answer 7

Test::Deep::NoTest tiene la misma funcionalidad.