The first is create the hashes outside of the sub and pass them into the sub by reference. There would be no need to return the references since the hashes would already be modified. Just start using them after the sub is finished.

The second is even lazier. Create the hashes outside of the sub but at a scope level the sub can see. Modify the hashes inside the sub so when it finishes - you can start using them.

sub routine
{
   my ($hashref1, $hashref2) = @_;

   # don't convert them back to hashes
   # work with the refs instead, so you won't have to 
   # set @_ at the end
}

my %first, %second;

routine(\%first, \%second);
[download]

That being the case, your snippet is pretty much how its done. Try not to get too hung up on the idea that your hash is known by reference rather than by name. There's really not much difference in how you write your code; you just dereference the references, that's all.

my ( $first, $second ) = routine();
print "$_\n" for keys %{$first};
print "$first->{Key1}\n";
# etc.....
[download]

If you start out using a reference to an anonymous hash, never naming your hash in the first place, you'll never need to worry about copying it back and forth between named hashes and referenced hashes.

In my opinion, the thing to do is return hashrefs, and use them directly. I don't see how laziness affects your decision on this either way, unless you don't want to type a few extra syntax characters. If that's the reason, I fear you've given in to the wrong kind of laziness...

That said, if you insist on using "real" hashes, then what you've got is probably the simplest and most straightforward way to do so. Why fight it? 8^)

There is a technique mentioned in perlsub for dealing with this. Although it may be seen as old-fashioned, it still works fine, and allows you to deal with "real hash" syntax inside and outside the sub without resorting to global vars or en masse copying of data.

#! perl -sw
use strict;

sub getRefs{ 
    my( %h1, %h2 ); 
    @h1{ qw[the quick brown fox] } = (1..4); 
    @h2{ 'a'..'z' } = 1 .. 26; 
    return \%h1, \%h2; 
}

{ 
    our( %glob1, %glob2 );
    local( *glob1, *glob2 ) = getRefs(); 
    print "$_ $glob1{ $_ }\n" for keys %glob1; 
    print "$_ $glob2{ $_ }\n" for keys %glob2; 
}

__DATA__
the 1
fox 4
brown 3
quick 2
w 23
r 18
a 1
x 24
d 4
j 10
y 25
u 21
k 11
h 8
g 7
f 6
t 20
i 9
e 5
n 14
v 22
m 13
s 19
l 12
c 3
p 16
q 17
b 2
z 26
o 15
[download]

What you do is assign the returned hashref to (localised) glob. You can then access the has via that glob name using standard hash variable syntax instead hashref syntax. It does simplify the syntax without the need to copy and avoiding the risks of global vars.