my $neu=();
for(keys %A){
  $neu{$_}=exists $B{$_} ? $B{$_} : $A{$_};
  }

#!/usr/bin/perl

use strict;
use warnings;

sub hash_update
{
    my ($x, $y) = @_;
    
    my $tx = ref $x;
    my $ty = ref $y;
    my $retval;
   
    die "Can not update due to different object type! ($tx != $ty)" unless $tx eq $ty;
   
    if($tx eq "ARRAY")
    {
        $retval = [];
        for my $i (0 .. _min(scalar(@{$x}), scalar(@{$y}))-1)
        {
            die "Array element was not expected!" unless ref $x->[$i];
            push @{$retval}, hash_update($x->[$i], $y->[$i]);
        }       ; 
    }
    elsif($tx eq "HASH")
    {
        $retval = {};
        for my $k (keys %{$x})
        {
            $retval->{$k} = exists $y->{$k} ? hash_update($y->{$k}, $x->{$k}) : $x;
        }
    }
    elsif($x ne "SCALAR")
    {
        $retval = $x;
    }

    return $retval;
}

sub _min
{
    return $_[0] < $_[1] ? $_[0] : $_[1]; 
}

#!/Perl/bin/perl

use strict;
use warnings;
use Data::Dumper qw/Dumper/;
$Data::Dumper::Sortkeys = 1;

$HASH::Update::beiArrayMitUngleichenElementenAlterDatensatz = 0;

my $alt = {
    key1 => "Ich bin immer noch da",
    key2 => "Ich werde ersatzlos gestrichen",
    key3 => { 
        "key3-1" => "Ich bin immer noch da"
    },
    key4 => [qw(Ich werde ersatzlos gestrichen)],
    key7 => [qw(Ich bin immer noch da)],
    key8 => ['alt', 'scalar', {'alt_hash' => 'alt_value'}, ],
};

my $neu = {
    key1 => "Ich werde überschrieben",
    key3 => { 
        "key3-1" => "Ich werde überschrieben", 
        "key3-2" => "Ich bin neu dazugekommen"
    },
    key5 => "Ich bin neu dazugekommen",
    key6 => [qw (Ich bin neu dazu gekommen)],
    key7 => [qw (Ich werde überschrieben)],
    key8 => [qw(neu scalar scalar)],
};

sub hash_update {
    # $_[0] = alt; $_[1] = neu;
    #my $alt = shift;
    #my $neu = shift; # alles in der Referenz ändern!
    
    # Für Rekursion: stimmen die übergebenen Datenstrukturen nicht überin
    # so wird in der neuen Datensturkur nichts geändert.
    return unless ref $_[0] eq ref $_[1];
    
    # Ist es ein Skalar? Ein Array? Ein Hash?
    
    if( ref $_[1] eq "HASH" ) {
        # Es ist ein Arschloch - äh, nein, ein Hash.
        # Alle Werte im neuen Hash sollen mit den Werten aus
        # dem alten Hash geupdated werden, wenn sie dort mit
        # dem gleichen Schlüssel und in gleicher Form
        # (Datenstruktur) vorliegen.
        
        foreach my $s_neu ( keys %{$_[1]} ) {
            # Gibt es den Schlüssel im alten Hash?
            if( exists $_[0]->{$s_neu}
               # ist es die Gleiche Datenstruktur?
               # Wenn nicht soll die neue übernommen werden.
               and ref $_[0]->{$s_neu} eq ref $_[1]->{$s_neu} ) {
                
                # Rekursuion...
                #print "hash: rekursion mit $s_neu\n";
                hash_update($_[0]->{$s_neu}, $_[1]->{$s_neu});
                
            }
        }
        
    }elsif( ref $_[1] eq "ARRAY" ) {
        # Es ist ein Array. Durchlaufe alle Einträge ud prüfe, ob die
        # alte Datenstruktur mit der neuen übereinstimmt.
        
        # Ist die Datenstruktur gleich, dann Rekursion mit allen Elementen.
        if( compare_arrays($_[0], $_[1]) ) {
            # öhm, scalar @{$_[0]} ???
            print "array-comp: " . scalar @{$_[0]} . " => " . scalar @{$_[1]} . "\n";
            for( my $c = 0; $c < scalar @{$_[0]}; $c++ ) {
                hash_update($_[0]->[$c], $_[1]->[$c]);
            }
        }else{
        
            print "array-comp: " . scalar @{$_[0]} . " => " . scalar @{$_[1]} . "\n";
            # Entscheide anhand der gesetzten Umgebungsvariablen ob bei
            # ungleicher Anzahl von Elementen der alte oder der neue Eintrag
            # genommen werden soll.
            if( $HASH::Update::beiArrayMitUngleichenElementenAlterDatensatz ) {
                $_[1] = $_[0];
            }
            
        }
        
        # ???
        # Ist die Datenstruktur partiell gleich, dann solange Rekursion wie
        # gleich, ansonsten altes belassen + neues hinzufügen???
        # zu faul...
        
    }else{
        # Es ist ein Skalar. Existiert der Wert in der alten Datenstruktur
        # wird er übernommen.
        #print "$_[0] => $_[1]\n";
        $_[1] = $_[0];
    }

} # /hash_update

# Funktion zum Vergleichen zweier Arrays auf Äquivalenz
# vgl. perlfaq4, "How do I test whether two arrays or hashes are equal?"
sub compare_arrays {
    my ($first, $second) = @_;
    no warnings;  # silence spurious -w undef complaints
    return 0 unless @$first == @$second;
    for (my $i = 0; $i < @$first; $i++) {
        # heir "ref" hinzugefügt, weil ich wissen will, ob die
        # Datenstruktur gleich ist, nicht der Inhalt.
        return 0 if ref $first->[$i] ne ref $second->[$i];
    }
    return 1;
}

hash_update($alt, $neu);
print Dumper( $neu );