I think you're asking about a hash of hashes? In that case, here's one way:

my %hash1 = ( foo => 'bar' );
my %hash2 = ( quz => 'baz' );
$hash1{somekey} = \%hash2;

use Data::Dumper;
print Dumper(\%hash1);
print Dumper( $hash1{somekey}{quz} );
__END__
$VAR1 = {
          'foo' => 'bar',
          'somekey' => {
                         'quz' => 'baz'
                       }
        };
$VAR1 = 'baz';
[download]

See also perlreftut and perlref.

Update: On re-reading your question, are you just asking for how to copy %hash2 into %hash1? Below, in "Case 1", the contents of %hash1 are preserved, but if there are duplicate keys in %hash1 and %hash2 then the values from %hash2 will replace those from %hash1. In "Case 2", the contents of %hash1 are simply replaced by %hash2. There are other ways to do this depending on what your needs are.

use Data::Dump;

my %hash1 = ( foo => 'bar' );
my %hash2 = ( quz => 'baz' );

# Case 1
%hash1 = (%hash1, %hash2);
# OR
$hash1{$_} = $hash2{$_} for keys %hash2;
dd \%hash1;  # { foo => "bar", quz => "baz" }

# Case 2
%hash1 = %hash2;
dd \%hash1;  # { quz => "baz" }
[download]

many way are possible (see docs linked by haukex), normally I use HoH created with the contained hash as anonymous one:

my %container_hash;

$container_hash{ holder_key } = { anonymous => 'hash', created_by => '
+braces' };
[download]

L*

Hi Nansh,

I'm hoping this node where I was trying to deal with a 3D hash (hash of hashes of hashes) is also helpful if you start dealing with more complex data structures, and especially if you start making use of slices to manipulate them. Actually, the entire thread is full of good information from lots of monks and I go back to it myself for a refresher every now and again when I'm doing such things because I sometimes have trouble correctly dereferencing what I want out of complex data structures (I have the link as a comment in several pieces of code I've written).

Another link that may offer some insight on the question of "one hash in another hash" (if that's your question) is the Perl Data Structures Cookbook (perldsc).

One thing to keep in mind as you study this aspect of Perl is the notion of references, as discussed in the two perldoc pages you were given earlier.   Read these slowly and carefully, because “references” are used a lot when dealing with hashes.   (In fact, a so-called “hashref” is more-common than an actual variable that is a hash.   References are very versatile.   The contents of a hash are often references, this being the actual mechanism that gives us “hash of hashes” and other arbitrarily-complex data structures.)

A reference is a value that “refers to” another piece of data ... a piece of data which might be “anonymous” in that the only way to reach it is through a reference.   More than one reference can be made to the same piece of data, and your troubles will begin if you don’t realize that this is what Perl is actually doing.   This can lead to confusion like:   “Why did $b also change, when I only meant to change $a?”   (Answer: “because both variables are references to the same piece of data ... whether you intended for them to be or not.”)   If there is any one thing that confused me the most when I was getting started with this language, this was probably it.