How to reuse a variable, which is a reference to a hash? - perl

Question

I'm trying to add a few hashes to the array, reusing the same variable (in my real program, I'm doing this in a loop, that's why reusing the var). This is the code:
my #items;
my %x;
$x{'aa'} = 'bb';
push(#items, \%x);
%x = (); # I think the error is here, I'm not resetting the reference :(
$x{'cc'} = 'dd';
push(#items, \%x);
use Data::Dumper;
print Dumper \#items;
However, what I see is not what I expect:
$VAR1 = [
{
'cc' => 'dd'
},
$VAR1->[0]
];
What do I misunderstand?
ps. This is how it looks in the loop:
my #items;
my %x;
foreach ... {
%x = ();
$x{'aa'} = some_random_number();
push(#items, \%x);
}

Answer 1

Reusing a hash reference that way is not possible, it will always point to the same hash. And if you reset the same hash over and over and add new values to it, of course the beginning of the hash will be deleted.
You are correct that %x = () is the problem, because that is where you delete the content in %x (the 'aa' key).
What you want is to create a new hash reference for each value you want to store.
use strict;
use warnings;
my #items = qw( .... );
foreach ... {
my %x; # use a lexically scoped variable, which will be new each iteration
$x{'aa'} = some_random_number();
push(#items, \%x);
}
Or even:
my %x = (aa => some_random());
Or better yet, use a hash reference right away
my $x = { aa => some_random() };
push #items, $x;
Or again, a bit quicker:
push #items, { aa => some_random() };
{ ... } creates an anonymous hash ref. Reusing variables is not a good idea, hardly ever. Unless you are using so many variables that you are afraid of memory issues. Use the lexical scope and anonymous references to your advantage to encapsulate your code and avoid confusion.
But since you are using different keys, and pushing them onto an array, I feel like you are confused about Perl data structures. You could just use the same hash, if your keys are different:
my %x;
foreach ... {
$x{$key} = some_random_number();
}
You probably want a variable to keep track of the key name there, not a constant.
In the comments you describe a practice of adding values to the hash, and then adding it to the array to start over. This is exactly why you should use a lexically scoped hash. For example:
....
for my $table (#tables) {
my %hash; # <--- new variable for each $table
for my $stuff (#stuff) {
$hash{$stuff} = something();
}
....
push #array, \%hash;
}
If you put an enclosure around the hash, it will be reset automatically, and then use the "same" name space the following iterations, except it will point to a different memory location (a new data reference).
Or if, as you say, you cannot use a loop outside, you can just put a block around the variable.
{ # start of a block
my %hash;
for my $stuff (#stuff) {
$hash{$stuff} = something();
}
....
push #array, \%hash;
} # end of a block
my %hash; # this "%hash" is a different variable from the previous