Comment comparer deux hachages en Perl sans utiliser Data :: Compare?

Question

Comment comparer deux hachages en Perl sans utiliser Data :: Compare?

Answer 1

La meilleure approche diffère selon vos objectifs. L'élément FAQ mentionné par Sinan est une bonne ressource: How do I test whether two arrays or hashes are equal?. Au cours du développement et du débogage (et bien sûr lors de l'écriture de tests unitaires), j'ai trouvé Test::More utile lors de la comparaison de tableaux, de hachages et de structures de données complexes. Un exemple simple:

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'); 

Sortie:

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

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

FAQ Perl et les réponses font partie de votre distribution Perl. Vous pouvez voir la version de cette réponse qui est venu avec votre perl en exécutant:

$ perldoc -q equal

dans votre terminal.

Answer 3

Comparez n'est pas une phrase assez détaillée quand on parle de hash. Il existe plusieurs façons de comparer les hachages:

Ont-ils le même nombre de clés?

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

Les clés sont-elles identiques dans les deux hachages?

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"; 
    } 
} 

Ont-ils les mêmes clés et les mêmes valeurs dans les deux hachages?

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"; 
    } 
} 

Sont-ils isomorphes (je vais laisser celui-ci au lecteur que je ne veux pas particulièrement d'essayer sa mise en œuvre à partir de zéro)?

Ou une autre mesure d'égale?

Et, bien sûr, ce code ne traite que des hachages simples. L'ajout de structures de données complexes le rend encore plus complexe.

Answer 4

rapide, sale, et je suis sûr pas efficace:

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

Pour comparer:

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; 
} 

Création de hachage sans clés en double:

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 Voir cette réponse: https://stackoverflow.com/a/2011443/2606517 La commande de clés provient d'une structure de données interne.

Answer 7

Test::Deep::NoTest a les mêmes fonctionnalités.