PERL -- hash in argument / return / reuse - perl

Question

I wish to fill a hash table successively by applying a function several times. The function takes a hash reference in argument, fills it, and returns it. The hash is taken again in argument by the function.
It seems that the hash is not filled at all.
Here is my code :
Can someone tell me where might be the error please ?
sub extractMLResult {
my (%h1, %h2, %h3, %h4, $param) = #_;
my $h1= shift;
my $h2= shift;
my $h3= shift;
my $h4=shift;
$params= shift;
# read csv file, split it, fill hashes with values
$h1->{$key1}{$key2}{'p'}=$val1;
# ... do the same for the other hashes ...
return (%$h1, %$h2, %$h3, %$h4);
}
my %myhash = ();
my %h1= ();
my %h2= ();
my %h3= ();
my %h4= ();
$myhash{'a'}{'x'}=1;
$myhash{'b'}{'y'}=1;
if (exists $myhash{'a'}){
(%h1, %h2, %h3, %h4) = extractMLResult(\%h1, \%h2, \%h3, \%h4, 'a');
}
if (exists $myhash{'b'}){
(%h1, %h2, %h3, %h4) = extractMLResult(\%h1, \%h2, \%h3, \%h4, 'b');
}

Answer 1

my declares variables in the lexical scope. So the instant you exit your 'if' clause, %$h1 etc. vanishes again.
Also, you're doing some strange things with the assigning, which I don't think will be working thew way you think - you're deferencing your hash-references, and as such returning a list of values.
Those will all be going into %$h1 because of the way list assignments work.
But on the flip side - when you're reading in myfunction your assignment probably isn't doing what you think.
Because you're calling myfunction and passing a list of values, but you're doing a list assignment for %h1. That means all your arguments are 'consumed':
#!/usr/bin/env perl
use strict;
use warnings;
use Data::Dumper;
sub myfunction {
my (%h1, %h2, %h3, %h4, $param) = #_;
print Dumper \%h1;
print Dumper \%h2;
}
# launch function :
my %h1 = ( a => "test" );
my %h2 = ( b => "wibble" );
myfunction ( \%h1, \%h2 );
As you will see - your arguments are all consumed by the assignment to %h1 and none are left for the rest of your assignments.
More importantly - your code doesn't even compile, because if you do this:
my (%$h1, %$h2, %$h3, %$h4) = myfunction (\%h1, \%h2, \%h3, \%h4, "a");
You get:
Can't declare hash dereference in "my"
So perhaps give us some sample code that actually illustrates the problem - and runs, with some sample data?
Edit: With the more code - the problem is right here:
sub extractMLResult {
my (%h1, %h2, %h3, %h4, $param) = #_;
Because that's not doing what you think it's doing. Because %h1 is a hash, and it's assigned in a list context - all the arguments of #_ are inserted into it. So %h2, %h3, %h4, $param will always be empty/undefined.
You don't indicate whether you're actually using %h1 though, which just means it's confusing nonsense - potentially.
But this bit:
my $h1= shift;
my $h2= shift;
my $h3= shift;
my $h4_parents = shift;
Ok, so you're extracting some hash references here, which is perhaps a little more sane. But naming the same as the hashes is confusing - there's NO relationship between $h1 and %h1, and you'll confuse things in your code if you do that. (Because $h1{key} is from %h1 and nothing to do with $h1 in turn).
But the same problem exists in return:
(%h1, %h2, %h3, %h4) = extractMLResult(\%h1, \%h2, \%h3, \%h4, 'a');
Because your return:
return (%$h1, %$h2, %$h3, %$h4);
This return will give you back an unrolled list containing all the elements in the hashes. But given the way you're packing the hashes, they'll probably be a partially unrolled list, containing hash-references.
But then, they'll all be consumed by %h1 again, in the assignment.
You would need to:
return ( $h1, $h2, $h3, $h4);
And then in your function:
( $h1_ret, $h2_ret, $h3_ret, $h4_ret ) = extractMLResult(\%h1, \%h2, \%h3, \%h4, 'a');
And then unpack:
%h1 = %$h1_ret;
Or just stick with working with references all the way through, which is probably clearer for all concerned.

Answer 2

You are passing hash references into your subroutine. This is a good idea. But inside your subroutine, you are treating your parameters as hashes (not hash references). This is a bad idea.
A hash is initialised from a list. It should be a list with an even number of elements. Each pair of elements in the list will become a key/value pair in the hash.
my %french => ('one', 'un', 'two', 'deux', 'three', 'trois');
We often use the "fat comma" to emphasise the link between keys and values.
my %french => (one => 'un', two => 'deux', three => 'trois');
This means that hash initialisation is a greedy operation. It will use up all of any list that it is given. You cannot initialise two hashes in the same statement:
my (%french, %german) = (one => 'un', two => 'deux',
three => 'drei', four => 'vier');
This doesn't work, as all of the pairs will end up in %french, leaving nothing to populate %german.
This is the same mistake that you are making when extracting the parameters within your subroutine. You have this:
my (%h1, %h2, %h3, %h4, $param) = #_;
Nothing will end up in %h2,%h3,%h4or$paramas the assignment to%his greedy and will take all of the data values from#_` - leaving nothing for the other variables.
But, as you are passing hash references, your code shouldn't look like that. A hash reference is a scalar value (that's pretty much the point of them) so it is stored in a scalar variable.
What you want is this:
# Note, scalars ($), not hashes (%)
my ($h1, $h2, $h3, $h4, $param) = #_;
This should get you started. Note also, that you'll now need to deal with hash references ($h1->{key}) rather than hashes ($h1{key}).
And, please, always include both use strict and use warnings.