Comment puis-je comparer deux ensembles de références de hachage à l'aide de Perl?

Question

J'ai donc deux fichiers avec des informations similaires.

EXEMPLES

TEST.TXT
1 = 1
2 = 2
3 = 3

test_2.txt
1 = 1
2 = 4
3 = 5
4 = 4
5 = 5
6 = 6

Maintenant, je veux imprimer chaque clé de hachage et les valeurs.

my %hash1; 
my $scalar_value1; 
my $scalar_value2; 
my $file = "/test/test.txt"; 
open (TEST, "<$file") or die "$!"; 
while (TEST) { 
      ($scalar_value1, $scalar_value2) = split('='); 
      $hash1{$scalar_value1}{'value1'} = $scalar_value1; 
      $hash1{$scalar_value1}{'value2'} = $scalar_value2; 
     } 
close TEST; 

foreach my $scalar_value1 (sort keys %hash1) { 
     print "$hash1{$scalar_value1}{'value1'} | $hash1{$scalar_value1}{'value2'}"; 
} 


my %hash2; 
my $scalar_value_1_2; 
my $scalar_value_2_2; 
my $file_2 = "/test/test2.txt"; 
open (TEST_2, "<$file_2") or die "$!"; 
while (TEST_2) { 
      ($scalar_value_1_2, $scalar_value_2_2) = split('='); 
      $hash1{$scalar_value_1_2}{'value_1_2'} = $scalar_value_1_2; 
      $hash1{$scalar_value_1_2}{'value_2_2'} = $scalar_value_2_2; 
     } 
close TEST_2; 

foreach my $scalar_value_1_2 (sort keys %hash1) { 
     print "$hash1{$scalar_value_1_2}{'value1_2'} | $hash1{$scalar_value_1_2}{'value1_2'}"; 
}  

Maintenant, comment puis-je comparer les deux hash pour produire une nouvelle valeur en fonction de si oui ou non le premier hachage contenait une clé semblable?

if ($hash1{$scalar_value_1_2}{'value1_2} eq $hash1{$scalar_value1}{'value1'}) { 
    my $scalar_value_2_2; = $hash1{$scalar_value1}{'value2'}; 
    print "YES MATCH: $scalar_value_2_2\n"; 
} else { 
    print "N0 MATCH: $scalar_value_2_2\n"; 
} 

Answer 1

J'ai réécrit votre programme pour plus de clarté. "chomp" est important d'inclure pour supprimer une nouvelle ligne.

use strict; 
use warnings; 
sub read_hash { 
    my $fname = shift; 
    open (my $fh, "<",$fname) or die "$!"; 
    my %hash; 
    while (<$fh>) { 
     chomp; 
     my ($key,$value)=split /=/; 
     $hash{$key}=$value; 
    } 
    return %hash; 
} 

my %hash1=read_hash("test.txt"); 

foreach my $key (sort keys %hash1) { 
     print "$key = $hash1{$key}\n"; 
} 

my %hash2=read_hash("test1.txt"); 

foreach my $key (sort keys %hash2) { 
     print "$key = $hash2{$key}\n"; 
} 


#------------------------ 

foreach my $key (sort keys %hash2) { 
     if (exists $hash1{$key}) { 
      print "$key exists in first hash\n"; 
     } else { 
      print "$key does not exist in first hash\n"; 
     } 
} 

Answer 2

Cela ressemble à un simple problème d'intersection. Voici une version remaniée du code en utilisant le travail d'Alexandr.

use strict; 
use warnings; 
sub read_hash { 
    my $fname = shift; 
    open (my $fh, "<",$fname) or die "$!"; 
    my %hash; 
    while (<$fh>) { 
     chomp; 
     my ($key,$value)=split /=/; 
     $hash{$key}=$value; 
    } 
    # let's retrun the reference here. With big hashes, you want to avoid copying 
    return \%hash; 
} 

my $h1=read_hash("test.txt"); 
my $h2=read_hash("test1.txt"); 

map {print "$_ = $h1->{$_}\n"} sort keys %$h1; 
map {print "$_ = $h2->{$_}\n"} sort keys %$h2; 

map {print "key from h1 $_ exists in h2\n" if exists $h2->{$_} } sort keys %$h1; 

# if you just want to take out the items from $h2 that also exists in $h1. 
my %h3 = map {$_=>$h2->{$_} if exists $h2->{$_}} keys %$h1; 

Notez que le programme utilise map pour faire l'itération de la liste. La dernière utilisation de la carte crée un hachage qui contient l'intersection des clés des deux hachés. Afin d'optimiser le code, je passerais en revue le hachage qui a moins de nombre de clés. Notez également que les méthodes ci-dessus ne vérifie pas la valeur des clés. Il compare seulement les clés elles-mêmes.

Espérons que cela aide.