Re: quick question about hash element access

[Nkuvu]

Something like the following?

#!/usr/bin/perl -w
use strict;

my %test_hash;
$test_hash{'a'}{'b'}{'c'}{'d'} = "Yay";
print get_id("a.b.c.d"), "\n";

sub get_id
{
    my @parts = split /\./, $_[0];
    
    # Currently written to access a global hash
    return $test_hash{$parts[0]}{$parts[1]}{$parts[2]}{$parts[3]};
}

I'm sure other monks can find more efficient (or bulletproof) ways. But this seems to work -- you could probably easily alter it so that it accepts a reference to a particular hash and uses that inside the sub.

Also note that $hash{'a'}{'b'}{'c'} is the same as $hash{'a'}->{'b'}->{'c'}

[argggh]

I suspect the question was not intended to be limited to hash paths of a specific depth. I'd suggest something like this:

sub hpath(\%$) {
    my ($href, $path) = @_;
    while ($path =~ /\G(.+?)\.?/gc) {
        $href = $href->{$1};
    }
    return $href;
}

my %c = (1 => { 2 => { 3 => 4 }});
print hpath(%c, "1.2.3");

Only with error checking, of course. Substitute while  ... with foreach (split(/\./, $path) (and $1 with $_) for slightly different flavor.

[argggh]

(For a another flavor altogether, try reduce:

use List::Util qw(reduce);

my %c = (1 => { 2 => { 3 => 4 }});
print reduce { $a->{$b} } \%c, split(/\./, "1.2.3");

)

[LanceDeeply]

added to your code so it can take a variable length identifier, and accept the hashref.


my %test_hash;
$test_hash{'a'}{'b'}{'c'}{'d'} = "Yay";
print get_id(\%test_hash, "a.b.c.d"), "\n";

sub get_id
{
    my $thingy = shift;
    my @keys = split /\./, shift;
    
    foreach my $key ( @keys )
    {
        $thingy =  $$thingy{$key};
    }
    return $thingy;
    
}

[Nkuvu]

Interesting. But I have a question (not being totally fluent in references).

What exactly does the $thingy = $$thingy{$key} line do? My guess is that it assigns a scalar value referred to by the reference which is contained in $thingy{$key}. But I'm not even sure that sentence makes sense, much less if it's accurate. :)

[LanceDeeply]

you are correct sir-
we are assigning $thingy to the value of whatever is refered to by $thingy{'a'}, in this case, it's the next hashref. this assignment is just repeated a few times till we're all out of keys.

what's bad about this is that it assumes the caller will pass in a valid path. i guess error checking will be left up to OP...

[argggh]

$$thingy{$key} is equal to $thingy->{$key}, so it returns the value corresponding to the key $key in the hash pointed to by the reference $thingy.

[tilly]

I suspect that the key requirement is variable depth of nesting.

(Your solution assumes a fixed depth.)

[Nkuvu]

Hmm, yes, I hadn't thought about that possible requirement. And here I thought I had an easy solution. :)