Scal hashe z tablicami z Hash :: Merge

Question

Próbuję połączyć dwa hashe, które zawierają jedną lub więcej tablic przy użyciu Hash::Merge. Na przykład:

use strict; 
use warnings; 
use feature qw(say); 

use Data::Dump qw(dump); 
use Hash::Merge qw(merge); 

my $h1 = { a => [ { aa => 1 }, 3 ] }; 
my $h2 = { a => [ { bb => 2 } ] }; 

my $hLeft = merge($h1, $h2); 
my $hRight = merge($h2, $h1); 

say " hLeft: " . dump($hLeft); 
say " hRight: " . dump($hRight); 

my $hDesired = { a => [ { aa => 1, bb => 2 }, 3 ] }; 
say "Desired: " . dump($hDesired); 

Daje wyjście:

hLeft: { a => [{ aa => 1 }, 3, { bb => 2 }] } 
hRight: { a => [{ bb => 2 }, { aa => 1 }, 3] } 
Desired: { a => [{ aa => 1, bb => 2 }, 3] } 

Jak mogę uzyskać poprawny wynik używając Hash::Merge?

Answer 1

Zachowanie domyślne dla łączących tablic jest dołączyć je:

sub { [ @{$_[0]}, @{$_[1]} ] }, 

aby uzyskać różne zachowanie, należy użyć Hash::Merge::specify_behavior.

Poniższy rozwiązaniem jest LEFT_PRECEDENT i łączy elementy tablic do elementu:

use strict; 
use warnings; 
use feature qw(say); 

use Data::Dump qw(dump); 
use Hash::Merge qw(merge); 

Hash::Merge::specify_behavior(
    { 'SCALAR' => { 
      'SCALAR' => sub { $_[0] }, 
      'ARRAY' => sub { $_[0] }, 
      'HASH' => sub { $_[0] }, 
     }, 
     'ARRAY' => { 
      'SCALAR' => sub { [ @{ $_[0] }, $_[1] ] }, 
      'ARRAY' => sub { 
       my ($left, $right) = @_; 

       my @merged = @$left; 
       my @to_add = @$right; 

       for (@merged) { 
        last if !@to_add; 
        $_ = Hash::Merge::merge($_, shift @to_add); 
       } 

       return [ @merged, @to_add ]; 
      }, 
      'HASH' => sub { [ @{ $_[0] }, values %{ $_[1] } ] }, 
     }, 
     'HASH' => { 
      'SCALAR' => sub { $_[0] }, 
      'ARRAY' => sub { $_[0] }, 
      'HASH' => sub { Hash::Merge::_merge_hashes($_[0], $_[1]) }, 
     }, 
    }, 
    'My Behavior', 
); 

my $h1 = { a => [ { aa => 1 }, 3 ] }; 
my $h2 = { a => [ { bb => 2 } ] }; 

my $merged = merge($h1, $h2); 
say "Merged: " . dump($merged); 

Wyjścia:

Merged: { a => [{ aa => 1, bb => 2 }, 3] } 

Answer 2

Można to zrobić za pomocą Hash::Merge::specify_behavior:

use warnings; 
use strict; 
use Data::Dump 'dump'; 
use Hash::Merge; 
use feature 'say'; 

Hash::Merge::specify_behavior 
    ({ 
    'SCALAR' => { 
       'SCALAR' => sub { $_[1] }, 
       'ARRAY' => sub { [ $_[0], @{$_[1]} ] }, 
       'HASH' => sub { $_[1] }, 
       }, 
    'ARRAY' => { 
       'SCALAR' => sub { $_[1] }, 
       'ARRAY' => \&mergeArrays, 
       'HASH' => sub { $_[1] }, 
       }, 
    'HASH' => { 
       'SCALAR' => sub { $_[1] }, 
       'ARRAY' => sub { [ values %{$_[0]}, @{$_[1]} ] }, 
       'HASH' => sub { Hash::Merge::_merge_hashes($_[0], $_[1]) }, 
       }, 
    }, 
    'My Behavior', 
); 

my $h1={a=>[{aa=>1},3]}; 
my $h2={a=>[{bb=>2}]}; 

my $hMerge=Hash::Merge::merge($h1,$h2); 
say "hMerge: ".dump($hMerge); 

sub mergeArrays{ 
    my ($a,$b)=@_; 

    my ($na,$nb)=($#$a,$#$b); 
    my @c; 
    if ($na>$nb) { 
     @c=@$a[($nb+1)..$na]; 
     return mergeArrays2($a,$b,\@c,$nb); 
    } else { 
     @c=@$b[($na+1)..$nb]; 
     return mergeArrays2($a,$b,\@c,$na); 
    } 
} 

sub mergeArrays2{ 
    my ($a,$b,$c,$n)=@_; 

    my $r=[]; 
    for my $i (0..$n) { 
     if (ref($a->[$i]) && ref($b->[$i])) { 
      push(@$r,Hash::Merge::_merge_hashes($a->[$i],$b->[$i])); 
     } else { 
      push(@$r,$a->[$i]); 
     } 
    } 
    push(@$r,@$c); 
    return $r; 
} 

wyjściowa:

hMerge: { a => [{ aa => 1, bb => 2 }, 3] }