Subroutine that returns hash - breaks it into separate variables

Question

I have a subroutine that returns a hash. Last lines of the subroutine:

print Dumper(\%fileDetails);
return %fileDetails;

in this case the dumper prints:

$VAR1 = {
          'somthing' => 0,
          'somthingelse' => 7.68016712043654,
          'else' => 'burst'
}

But when I try to dump it calling the subroutine with this line:

print Dumper(\fileDetailsSub($files[$i]));

the dumper prints:

$VAR1 = \'somthing';
$VAR2 = \0;
$VAR3 = \'somthingelse';
$VAR4 = \7.68016712043654;
$VAR5 = \'else';
$VAR6 = \'burst';

Once the hash is broken, I can't use it anymore. Why does it happen? And how can I preserve the proper structure on subroutine return?

Thanks, Mark.

The answer is in the `\\` that you're mechanically inserting into your Dumper() invocations :-) — Julian Fondren, May 28 '13 at 15:36

score 11 · Accepted Answer · answered May 28 '13 at 15:47

There's no such thing as returning a hash in Perl.

Subroutines take lists as their arguments and they can return lists as their result. Note that a list is a very different creature from an array.

When you write

return %fileDetails;

This is equivalent to:

return ( 'something', 0, 'somethingelse', 7.68016712043654, 'else', 'burst' );

When you invoke the subroutine and get that list back, one thing you can do is assign it to a new hash:

my %result = fileDetailsSub();

That works because a hash can be initialized with a list of key-value pairs. (Remember that (foo => 42, bar => 43 ) is the same thing as ('foo', 42, 'bar', 43).

Now, when you use the backslash reference operator on a hash, as in \%fileDetails, you get a hash reference which is a scalar the points to a hash.

Similarly, if you write \@array, you get an array reference.

But when you use the reference operator on a list, you don't get a reference to a list (since lists are not variables (they are ephemeral), they can't be referenced.) Instead, the reference operator distributes over list items, so

\( 'foo', 'bar', 'baz' );

makes a new list:

( \'foo', \'bar', \'baz' );

(In this case we get a list full of scalar references.) And this is what you're seeing when you try to Dumper the results of your subroutine: a reference operator distributed over the list of items returned from your sub.

So, one solution is to assign the result list to an actual hash variable before using Dumper. Another is to return a hash reference (what you're Dumpering anyway) from the sub:

return \%fileDetails;

...

my $details_ref = fileDetailsSub();
print Dumper( $details_ref );

# access it like this:
my $elem = $details_ref->{something};
my %copy = %{ $details_ref };

For more fun, see:

perldoc perlreftut - the Perl reference tutorial, and
perldoc perlref - the Perl reference reference.

TLP · Answer 2 · 2013-05-28T15:42:15.713

Why not return a reference to the hash instead?

return \%fileDetails;

As long as it is a lexical variable, it will not complicate things with other uses of the subroutine. I.e.:

sub fileDetails {
    my %fileDetails;
    ... # assign stuff
    return \%fileDetails;
}

When the execution leaves the subroutine, the variable goes out of scope, but the data contained in memory remains.

The reason the Dumper output looks like that is that you are feeding it a referenced list. Subroutines cannot return arrays or hashes, they can only return lists of scalars. What you are doing is something like this:

print Dumper \(qw(something 0 somethingelse 7.123 else burst));

score 3 · Answer 3 · edited May 23 '17 at 12:28

Perl functions can not return hashes, only lists. A return %foo statement will flatten out %foo into a list and returns the flattened list. To get the return value to be interpreted as a hash, you can assign it to a named hash

%new_hash = fileDetailsSub(...);
print Dumper(\%new_hash);

or cast it (not sure if that is the best word for it) with a %{{...}} sequence of operations:

print Dumper( \%{ {fileDetailsSub(...)} } );

Another approach, as TLP points out, is to return a hash reference from your function.

score 1 · Answer 4 · answered May 28 '13 at 15:44

You can't return a hash directly, but perl can automatically convert between hashes and lists as needed. So perl is converting that into a list, and you are capturing it as a list. i.e.

Dumper( filedetail() ) # list
my %fd = filedetail(); Dumper( \%fd ); #hash

score 0 · Answer 5 · answered May 28 '13 at 15:44

In list context, Perl does not distinguish between a hash and a list of key/value pairs. That is, if a subroutine returns a hash, what it really returns is an list of (key1, value1, key2, value2...). Fortunately, that works both ways; if you take such a list and assign it to a hash, you get a faithful copy of the original:

my %fileDetailsCopy = subroutineName();

But if it wouldn't break other code, it would probably make more sense to have the sub return a reference to the hash instead, as TLP said.

Subroutine that returns hash - breaks it into separate variables

5 Answers5