Do you know about the ref function? You can use it to tell what kind of data is referenced, affecting how you handle it.

Here's a very quick-and-dirty subroutine show_this() that uses ref to recursively inspect the contents of your hash. As such, it's a primitive replacement for Data::Dumper:

#!/usr/bin/perl -w
#
use strict;
use warnings;
use Data::Dumper;

my %singleLevelHash = ();

my %multiLevelHash = (
    'firstSampleKey' => 'SampleValue',
    'secondSampleKey' => {
    'secondLevelSampleKey' => { 
        'thirdLevelSampleKeyOne'   => 'thirdLevelSampleValue',
        'thirdLevelSampleKeyTwo'   => 'thirdLevelSampleValue',
        'thirdLevelSampleKeyThree' => 'thirdLevelSampleValue',
    }
    }
);

# print Dumper \%multiLevelHash;
show_this(\%multiLevelHash);

# foreach my $firstSampleKey ( sort keys %multiLevelHash ) {
#     print $firstSampleKey . "\n";
#     foreach my $secondLevelSampleKey ( sort keys $multiLevelHash{$fi
+rstSampleKey} ) {
#     print $secondLevelSampleKey . "\n";
#     }
# }


sub show_this {
    my ($x) = @_;

    if (ref $x eq "") {
        printf "  Value: '%s'\n", $x;
    } elsif (ref $x eq 'SCALAR') {
        printf "  SCALAR ref:  '%s'\n", $$x;
    } elsif (ref $x eq 'HASH') {
        print "  HASH ref '$x':\n";
        foreach my $key (keys %$x) {
            my $val = $x->{$key};
            print "  $key:  ";
            show_this($val);
        }
    } elsif (ref $x eq 'ARRAY') {
        print "  ARRAY re '$x':\n";
        foreach my $val (@$x) {
            show_this($val);
        }
    }
}
[download]

Hopefully that gives you an idea how to interpret a HASH ref, differently from a scalar value. Hint -- the solution is in the block:

    foreach my $key (keys %$x) {
        ...
    }
[download]

Hello golux,

Thank you for your time and effort reading and replying to my post. I will try to play around with your suggesting to find my solution.

I was not aware of the ref function, thanks for pointing this out.

Seeking for Perl wisdom...on the process of learning...not there...yet!

#! perl -slw
use strict;
use Data::Dump qw[ pp ];

sub dumpIt {
    my $r = shift;
    my $d = shift() // 1;
    die "'$r' not a hashref" unless ref $r eq 'HASH';
    print "{" if $d == 1;
    for( keys %$r ) {
        if( ref $r->{ $_ } ) {
            print chr(9) x $d, "$_ => {";
            dumpIt( $r->{ $_ }, $d + 1 );
            print chr(9) x $d, "}";
        }
        else {
            print chr(9) x $d, "$_ => $r->{ $_ }";
        }
    }
    print "}" if $d == 1;
}

my %multiLevelHash = (
    'firstSampleKey' => 'SampleValue',
    'secondSampleKey' => {
        'secondLevelSampleKey' => {
            'thirdLevelSampleKeyOne'   => 'thirdLevelSampleValue',
            'thirdLevelSampleKeyTwo'   => 'thirdLevelSampleValue',
            'thirdLevelSampleKeyThree' => {
                'fourthLevelSampleKey' => 'fourthLevelSampleValue',
            }
        }
    }
);

dumpIt( \%multiLevelHash );

__END__
C:\test>junk90
{
        firstSampleKey => SampleValue
        secondSampleKey => {
                secondLevelSampleKey => {
                        thirdLevelSampleKeyTwo => thirdLevelSampleValu
+e
                        thirdLevelSampleKeyThree => {
                                fourthLevelSampleKey => fourthLevelSam
+pleValue
                        }
                        thirdLevelSampleKeyOne => thirdLevelSampleValu
+e
                }
        }
}
[download]

Hello BrowserUk,

Thank you for your time and effort. I will try to experiment with your solution a little bit to become familiar. I was not aware that you can call the same subroutine inside the actual subroutine.

Again thank you for your time and effort reading my question and replying.

Seeking for Perl wisdom...on the process of learning...not there...yet!

Hello thanos1983,

I was not aware that you can call the same subroutine inside the actual subroutine.

This is a very important concept in computer science called recursion. It’s one of the key elements of the functional programming paradigm (think Lisp, Scheme, Haskell, ...), but is by no means limited to that paradigm. In fact, it’s something every programmer needs to know. Here are some references:

• Wikipedia, Recursion_(computer_science)
• DigitalKitty, Recursion: The Towers of Hanoi problem (Monastery Tutorial)
• Gabor Szabo (szabgab), “Understanding Recursive Subroutines — Traversing a Directory Tree,” online
• Jonathan Bartlett, “Mastering Recursive Programming,” online
• Mark Jason Dominus, Higher-Order Perl, “Chapter 1: Recursion and Callbacks,” online

Hope that helps,

Athanasius <°(((>< contra mundum

Iustus alius egestas vitae, eros Piratica,

I was not aware that you can call the same subroutine inside the actual subroutine.

You may want to have a look at recursion, which Perl supports.