Only scalars can be passed as arguments, so either need to pass a reference (like in the first and second snippet), or flatten the hash into a list of scalars (like in the third snippet).

One usually passes a reference to the hash which saves Perl from copying the entire hash:

sub function {
   my ($hash_ref) = @_;

   foreach (keys %$hash_ref) {
      ...
   }
}

function(\%hash);
[download]

sub function {
   our %hash; local *hash = \$_[0];

   foreach (keys %hash) {
      ...
   }
}

function(\%hash);
[download]

sub function {
   my %hash = @_;

   foreach (keys %hash) {
      ...
   }
}

function(%hash);
[download]

Would this do it?

my %hash = @_;
[download]

#!/bin/perl5

use strict;
use warnings;

my %hash = (
  one => 1,
  two => 2,
);

my_sub(%hash);

sub my_sub{
  my %hash = @_;
  for my $key (keys %hash){
    print "$key -> $hash{$key}\n";
  }
}
[download]

update: added snippet

.

As wfsp has said, you can just assign @_ and this will treat the passed list of parameters as a set of key and value pairs. Note that an odd number of params will result in a run time exception.

But, you often want to perform some (often elementary) validation on the input parameters, before casting them to a hash, such as checking that the keys are what you expect. Params::Validate is what I tend to use to do this, though there are other CPAN modules which do similar things. There are plenty of examples of how to use it in the docs.

my $foo = CalcFoo( { bar => 'abc', baz => 'def' } );

sub CalcFoo
{
  my $href = $_[0];

  my $foo;
  if ( defined $href->{bar} and defined $href->{baz} )
  {
    $foo = $href->{bar} . $href->{baz};
  }
  else
  {
    print "Error: pls define bar and baz\n";
  }
  return $foo;
}
[download]

Requiring the named arguments to be specified inside a hash ensures that any mismatch, such as:

$line = padded({text=>$line, cols=>20..21, centered=>1, filler=>$SPACE
+});
[download]

will be reported (usually at compile time) in the caller’s context:

Odd number of elements in anonymous hash at demo.pl line 42
[download]

Passing those arguments as raw pairs:

$line = padded(text=>$line, cols=>20..21, centered=>1, filler=>$SPACE)
+;
[download]

would cause the exception to be thrown at run time, and from the line inside the subroutine where the odd number of arguments were unpacked and assigned to a hash:

- j

sub name {
  # this puts the passed list into a hash
  my %arg = @_;
  # this transfers values to variables and removes the keys
  my ($key1, $key2) = delete @arg{qw(key1 key2)};
  # this determines if any keys are leftover
  croak 'Illegal arguments' if %arg;
}
[download]

#make hash
my %junk = (
  one=>'123123',
  two=>'dsf4f3'
)

# send reference
&printvals(\%junk);

sub printvals {
  my $junk=$_[0];
  #dereference these guys
  print $$junk{one} . $$junk{two};
}
[download]