&callsub(\%hashtopass);

sub callsub {

  my %hashread = %{$_[0]};

  foreach $k (keys(%hashread)) {


  }
}
[download]

You cannot pass the hash as you did without distroying it. It is being flattened into a list. Pass it by reference :

callsub(\%hashtopass);

sub callsub {
     my $hashref = shift;

     foreach my $k (keys %$hashref) {
..
..
[download]

read more about references

You can use

&callsub(%hashtopass); 

sub callsub {
   %hashread = @_;

   foreach $k (keys %hashread) {
       print "$k => $hashread{$k}\n";
   }
}
[download]

but I prefer to use references:

&callsub(\%hashtopass, $otherStuff);

sub callsub {
   my ($hashref, $otherParam) = @_; 
# or: my $hashref = shift; if you prefer that

   foreach my $k (keys %{$hashref}) {
       print "$k => $hashref->{$k}\n";
   }
}
[download]

This way, you can even pass along other parameters.

&callsub(%hashtopass); 

sub callsub {
   %hashread = @_;
[download]

I don't think this is good practice.. what if you decide to pass a scalar along with that and forgot to shift it out before assigning the list to the hash? you might end up with a corrupted list, or worst, a legitimate list with wrong values shooting yourself in the foot.

---

He who asks will be a fool for five minutes, but he who doesn't ask will remain a fool for life.

Chady | http://chady.net/

Yes, that's why I suggested the second approach using references. But I neglected to point out the dangers to the original poster. Thanks!

FWIW, I do like to use it if (and only if...) the function is designed to receive only named parameters. E. g.

sub create {
    my $self = shift;
    my %p = @_;
    
    print "$p{color} p{animal}" for (1..$p{count});
}

$zoo->create(animal => 'camel',
             count  => '10',
             color  => 'green');
[download]

One could opt to create the zoo using a hash reference as in

$zoo->create({animal => 'monkey', ...});

but I guess that is a matter of style.

i want to comment on your use of 'strict programming rules'. the code you provide does not use strict. this, along with warnings (-w on pre-5.006 perls) is your best defense against common programming mistakes. see Use strict warnings and diagnostics or die for more info.

also, you should be careful when using the & sigil. you must understand its behaviour, as it does not perform as you probably expect. if called with no parenthesis, as in &callsub;, the current @_ is passed automatically. also, it will override your prototypes, if you're using them (but you probably shouldn't be). see perlsub for much, much more on that.

~Particle *accelerates*

You can pass the entire hash as a hash reference. This would also make things more efficient. Here is the sample code:

my %hash_outside;
$hash_outside{'first'} = 'first value';
$hash_outside{'second'} = 'second value';

sub blah {
  my %hash = %{ +shift; };
  foreach my $k (keys %hash) {
    print "$k -> " . $hash{$k} . "\n";
  }
}

&blah(\%hash_outside);
[download]

Here you pass a hash reference to the sub by appending a backslash ( \%hash_outside ). First line in the sub dereferences the reference to the hash so you can use it as a normal hash.

You could also look at perlref documentation to find out more about references.

foo (%hash);

sub foo
{
    my %passed_hash = @_;
    # do stuff
}
[download]

...which only workes if the hash is the only argument you have (or the last one..). If it is not, or you have more than one hash to pass, and your subroutine is seen at sompile ime, you can use this elegant solution:

sub foo (\%$);

foo (%hash, $arg);

sub foo (\%$)
{
    my $hash_ref = shift;
    my $passed_arg = shift;

    my $passed_hash = %$hash_ref;

    # do stuff
}
[download]

The second example provides a prototype for the subroutine. How these work can be read in perlsub.. But to give you some clue: It automatically converts the hash into a reference..

Regards,
-octo

Try this:

&callsub(\%hashtopass);

sub callsub
{
    my $hashread = $_[0];

    foreach $k (keys $%hashread)
    {
        .
        .
        .
    }
}
[download]

Check this out for more information: http://www.perldoc.com/perl5.6.1/pod/perlref.html