Perl:从子例程返回hashref

Question

我有一个深度嵌套的哈希结构。嵌套的级别事先是未知的。但是每个级别都有两个属性"instance“和另一个散列”依赖项“。所以它是一种递归形式的哈希。

my $HASH = {
    "top"=> {
        "instance" => "top_instance",
        "dependencies" => {
            "sub_block1" => {
                "instance" => "sub_block1_instance",
                "dependencies" => {}
            },
            "sub_block2" => {
                "instance" => "sub_block2_instance",
                "dependencies" => {
                    "sub_block3" => {
                        "instance" => "sub_block3_instance",
                        "dependencies" => {}
                    }
                }
            }
        }
    }
};

我有一个子例程，它接受用户定义的字符串，并从指定的层次结构返回散列的内部片段。

例如，如果用户指定"sub_block2"，则子例程应返回此散列：

{
    "sub_block2" => {
        "instance" => "sub_block2_instance",
        "dependencies" => {
            "sub_block3" => {
                "instance" => "sub_block3_instance",
                "dependencies" => {}
            }
        }
    }
}

这是我的子例程：

sub get_starting_point {
    my $string = shift;
    my $config = shift;
    foreach my $key (keys %$config) {
        if($key ne $string) {
            # if current key is not what user asked for, recurse into next level of hierarchy
            if (exists $$config{$key}{dependencies}) {
                &get_starting_point($$config{$key}{dependencies});
            }
        } else {
            # we found the key, return the hash under this hierarchy
            my $tempHash = {$key => $$config{$key}};
            print ref($tempHash); # correctly prints HASH
            print Dumper($tempHash); # correctly prints out the sub-hash
            return $tempHash; # I am expecting this return value to be a hash-ref
        }
    }
}

正如您所看到的，这是一个递归函数，它不断深入哈希，直到它遇到一个与参数匹配的键，并返回该键下的完整子哈希值。

这就是我调用这个子例程的方式。

my $subHash = get_starting_point("sub_block2",$HASH);
print ref($subHash); # is not a ref
print Dumper($subHash); # prints nothing

我做错了什么！？！？

编辑:使用我的确切问题更新了问题。看起来像是我之前用过的一个简单的例子，就像预期的那样。

Answer 1

您将返回foreach计算的值(由于它是sub的最后一个语句)。这并不奇怪，这不是一个参考。

&get_starting_point($$config{$key}{dependencies});

应该是

my $rv = get_starting_point($config->{$key}{dependencies});
return $rv if $rv;

并在末尾添加return undef;，而不是依赖foreach返回错误的内容。

sub get_starting_point {
    my $string = shift;
    my $config = shift;
    for my $key (keys %$config) {
        if ($key eq $string) {
            return { $key => $config->{$key} };
        }

        if ($config->{$key}{dependencies}) {
           my $rv = get_starting_point($config->{$key}{dependencies});
           return $rv if $rv;
        }
    }

    return undef;
}

备注：

• 请不要使用&作为子调用的前缀。你知道这是做什么的吗？
• 大多数人发现$config->{$key}比you更具可读性。

Answer 2

唉哟。我假设递归函数中的"return“语句立即中断递归并返回值。因此，当递归尽可能深入，并开始返回时，就没有什么可返回的了。

我通过在子例程外部设置一个全局变量来解决这个问题，而在子例程中，我只是将这个全局变量设置为子哈希。

这就是我的目的！