如何检查密钥是否存在于深度Perl哈希中？

Question

如果我understand correctly，调用if (exists $ref->{A}->{B}->{$key}) { ... }将弹出$ref->{A}和$ref->{A}->{B}存在，即使它们在if之前不存在！

这似乎是非常不想要的。那么我应该如何检查一个“深”散列键是否存在？

Answer 1

这是更好的使用有点像autovivification模块关闭该功能，或者使用Data::Diver。然而，这是我希望程序员知道如何独立完成的简单任务之一。即使你不在这里使用这种技术，你也应该知道它的其他问题。这实质上就是Data::Diver在你剥离它的界面时所做的。

这很容易，一旦你得到了行走数据结构的技巧（如果你不想使用一个模块来为你做）。在我的示例中，我创建了一个check_hash子例程，该子例程需要检查密钥的散列引用和数组引用。它一次检查一个级别。如果钥匙不在那里，它什么都不会返回。如果密钥存在，它会将散列修剪为路径的那一部分，并用下一个键再次尝试。诀窍是$hash始终是要检查的树的下一部分。我把exists放在eval中，以防下一个级别不是散列引用。如果路径末尾的散列值是某种错误值，那么这个技巧就不会失败。这里的任务的重要部分：

sub check_hash { 
    my($hash, $keys) = @_; 

    return unless @$keys; 

    foreach my $key (@$keys) { 
     return unless eval { exists $hash->{$key} }; 
     $hash = $hash->{$key}; 
     } 

    return 1; 
    } 

不要被所有的代码吓到下一个位。重要的部分就是check_hash子程序。一切是测试和演示：

#!perl 
use strict; 
use warnings; 
use 5.010; 

sub check_hash { 
    my($hash, $keys) = @_; 

    return unless @$keys; 

    foreach my $key (@$keys) { 
     return unless eval { exists $hash->{$key} }; 
     $hash = $hash->{$key}; 
     } 

    return 1; 
    } 

my %hash = (
    a => { 
     b => { 
      c => { 
       d => { 
        e => { 
         f => 'foo!', 
         }, 
        f => 'foo!', 
        }, 
       }, 
      f => 'foo!', 
      g => 'goo!', 
      h => 0, 
      }, 
     f => [ qw(foo goo moo) ], 
     g => undef, 
     }, 
    f => sub { 'foo!' }, 
    ); 

my @paths = (
    [ qw(a b c d ) ], # true 
    [ qw(a b c d e f) ], # true 
    [ qw(b c d)  ], # false 
    [ qw(f b c)  ], # false 
    [ qw(a f)   ], # true 
    [ qw(a f g)  ], # false 
    [ qw(a g)   ], # true 
    [ qw(a b h)  ], # false 
    [ qw(a)   ], # true 
    [ qw()    ], # false 
    ); 

say Dumper(\%hash); use Data::Dumper; # just to remember the structure  
foreach my $path (@paths) { 
    printf "%-12s --> %s\n", 
     join(".", @$path), 
     check_hash(\%hash, $path) ? 'true' : 'false'; 
    } 

下面是输出（减去数据转储）：

a.b.c.d  --> true 
a.b.c.d.e.f --> true 
b.c.d  --> false 
f.b.c  --> false 
a.f   --> true 
a.f.g  --> false 
a.g   --> true 
a.b.h  --> true 
a   --> true 
      --> false 

现在，你可能希望有一些其他的检查，而不是exists。也许你想检查所选路径的值是否为真，或者是一个字符串，或另一个散列引用，或其他。只要您确认路径存在，就提供正确的检查。在这个例子中，我传递了一个子程序引用，它将检查我离开的值。我可以检查东西我喜欢：

#!perl 
use strict; 
use warnings; 
use 5.010; 

sub check_hash { 
    my($hash, $sub, $keys) = @_; 

    return unless @$keys; 

    foreach my $key (@$keys) { 
     return unless eval { exists $hash->{$key} }; 
     $hash = $hash->{$key}; 
     } 

    return $sub->($hash); 
    } 

my %hash = (
    a => { 
     b => { 
      c => { 
       d => { 
        e => { 
         f => 'foo!', 
         }, 
        f => 'foo!', 
        }, 
       }, 
      f => 'foo!', 
      g => 'goo!', 
      h => 0, 
      }, 
     f => [ qw(foo goo moo) ], 
     g => undef, 
     }, 
    f => sub { 'foo!' }, 
    ); 

my %subs = (
    hash_ref => sub { ref $_[0] eq ref {} }, 
    array_ref => sub { ref $_[0] eq ref [] }, 
    true  => sub { ! ref $_[0] && $_[0] }, 
    false  => sub { ! ref $_[0] && ! $_[0] }, 
    exist  => sub { 1 }, 
    foo  => sub { $_[0] eq 'foo!' }, 
    'undef' => sub { ! defined $_[0] }, 
    ); 

my @paths = (
    [ exist  => qw(a b c d ) ], # true 
    [ hash_ref => qw(a b c d ) ], # true 
    [ foo  => qw(a b c d ) ], # false 
    [ foo  => qw(a b c d e f) ], # true 
    [ exist  => qw(b c d)  ], # false 
    [ exist  => qw(f b c)  ], # false 
    [ array_ref => qw(a f)   ], # true 
    [ exist  => qw(a f g)  ], # false 
    [ 'undef' => qw(a g)   ], # true 
    [ exist  => qw(a b h)  ], # false 
    [ hash_ref => qw(a)   ], # true 
    [ exist  => qw()    ], # false 
    ); 

say Dumper(\%hash); use Data::Dumper; # just to remember the structure  
foreach my $path (@paths) { 
    my $sub_name = shift @$path; 
    my $sub = $subs{$sub_name}; 
    printf "%10s --> %-12s --> %s\n", 
     $sub_name, 
     join(".", @$path), 
     check_hash(\%hash, $sub, $path) ? 'true' : 'false'; 
    } 

，其输出：

 exist --> a.b.c.d  --> true 
    hash_ref --> a.b.c.d  --> true 
     foo --> a.b.c.d  --> false 
     foo --> a.b.c.d.e.f --> true 
    exist --> b.c.d  --> false 
    exist --> f.b.c  --> false 
array_ref --> a.f   --> true 
    exist --> a.f.g  --> false 
    undef --> a.g   --> true 
    exist --> a.b.h  --> true 
    hash_ref --> a   --> true 
    exist -->    --> false 

Answer 2

检查每个级别的exist ence在查看最高级别之前。

if (exists $ref->{A} and exists $ref->{A}{B} and exists $ref->{A}{B}{$key}) { 
} 

如果您发现讨厌你总是可以看看上CPAN。例如，有Hash::NoVivify。

Answer 3

您可以使用autovivification编译停用自动创建引用：

use strict; 
use warnings; 
no autovivification; 

my %foo; 
print "yes\n" if exists $foo{bar}{baz}{quux}; 

print join ', ', keys %foo; 

这也是词汇，这意味着它只会关闭它，你在其指定的范围内

Answer 4

很丑陋，但如果$ ref是一个复杂的表达式，您不想在重复存在的测试中使用：

if (exists ${ ${ ${ $ref || {} }{A} || {} }{B} || {} }{key}) { 

Answer 5

请看Data::Diver。例如： -

use Data::Diver qw(Dive); 

my $ref = { A => { foo => "bar" } }; 
my $value1 = Dive($ref, qw(A B), $key); 
my $value2 = Dive($ref, qw(A foo));