Using foreach on a hash passed to a subroutine

[carcassonne]

Hi monks,

I'm stumped by what seems to be a very basic thing. Using a hash ref inside a subroutine. I've tried several syntaxes but none worked so far, with results ranging from syntax errors to 'not a HASH reference' and such.

Here is the problem in a nutshell.

The idea is to be able to work on different parts of a large hash whose some of its 'subhashes' so to speak have the same structure. The result of that work is placed inside a hash taht contains already unit data, passed along to the subroutine. The work has to do with the interface sections of different types of units.

my %myUnitIfs;
processInterfaceData(\$config{units}{myUnit}{interfaces}, \%myUnitIfs)
+;

This would eventually be called on other units, with diffrenet new hashes to collect output:

processInterfaceData(\$config{units}{yourUnit}{interfaces}, \%yourUnit
+Ifs);
processInterfaceData(\$config{units}{anotherUnit}{interfaces}, \%anoth
+erUnitIfs);

And here I've tried: $h, %$h, and many other variations.

sub processInterfaceData
{
  my ($h, $nh) = @_;
  print "$key\n"
   foreach my $key (keys %{$h});
}

Pray tell, how one is to write the reference inside the subroutine so that elements of the hash are properly accessed ? - Thanks !

[Jenda]

Assuming $config{units}{yourUnit}{interfaces} is a reference to a hash, then \$config{units}{yourUnit}{interfaces} is a reference to a reference to a hash. So you'd have to use ...(keys %{$$h}). I guess you want to drop the backslash.

[carcassonne]

Thanks all. As pointed out the problem was not in the subroutine but in the nature of the passed parameter. Thanks also for the examples.

[bart]

A hash of hashes already contains hash references, so you probably just have to pass $config{units}{myUnit}{interfaces}. Because now, it looks like you're actually passing a scalar reference to a scalar containing a hash reference.

[Anonymous Monk]

References quick reference

#!/usr/bin/perl --

use strict;
use warnings;

use Data::Dumper;

my %one = ( a => { b => { c => { d => { 6 } } } } );

print Dumper( \%one, $one{a}{b}{c} );

my $none = $one{a}{b}{c} ;
for my $k( keys %$none ){
    $none->{"$k$k"} = "$k$k";
}

print Dumper( \%one);
__END__
$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => {
                                              '6' => undef
                                            }
                                   }
                          }
                 }
        };
$VAR2 = $VAR1->{'a'}{'b'}{'c'};
$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'dd' => 'dd',
                                     'd' => {
                                              '6' => undef
                                            }
                                   }
                          }
                 }
        };

[cdarke]

If you are offended by subroutine prototypes then look-away now.

This is an occasion where a prototype would have helped (OK, so there aren't that many of them):
Update: Doh! No it wouldn't, sorry.

use strict;
use warnings;

sub processInterfaceData (\%\%)
{
  my ($h, $nh) = @_;

  foreach my $key (keys %{$h}) {
      print "$key\n";
  }
}

my %myUnitIfs;
my %config;
processInterfaceData($config{units}{myUnit}{interfaces}, %myUnitIfs);

Gives:

Type of arg 1 to main::processInterfaceData must be hash (not hash ele
+ment)

It gives the error as the calling line, not the subroutine, at compile time. Alos, because the caller does not specify the \ to indicate the reference, it is less likely for the problem to arise.