if (exists $ref->{A}->{B}->{$key}) { ... }即使在if之前它们不存在，也会创建$ref->{A}和$ref->{A}->{B}！最好使用像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。也许你想检查所选路径上的值是否为true、字符串、另一个哈希引用或其他任何值。只需在验证路径存在后提供正确的检查即可。在这个例子中，我传递了一个子程序引用，将检查我最后使用的值。我可以检查任何我喜欢的东西：
#!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
use strict;
use warnings;
no autovivification;
my %foo;
print "yes\n" if exists $foo{bar}{baz}{quux};
print join ', ', keys %foo;
它也是词法作用域的，这意味着它只会在您指定的作用域内停用它。
在查看顶层之前，请检查每个级别是否存在。
if (exists $ref->{A} and exists $ref->{A}{B} and exists $ref->{A}{B}{$key}) {
}
如果你觉得那很烦人，你可以随时在CPAN上查找。例如，有Hash::NoVivify。
{} 和方括号 [] 之间连续的箭头是不必要的，通常最好将它们省略。 - hobbs&&；仅将 and 用于流程控制。 - ysth&&代替and。在流程控制中，使用and代替&&。 - vol7ron看看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));
虽然不太美观，但如果$ref是一个复杂的表达式，你不想在重复的exists测试中使用：
if ( exists ${ ${ ${ $ref || {} }{A} || {} }{B} || {} }{key} ) {
n-1（其中 n 是哈希表级数）个匿名哈希引用，仅为了避免在目标哈希表中进行自动vivification（你在匿名哈希引用中实现自动vivify）。我想知道与正常代码中多次调用“exist”相比，性能如何。 - Chas. Owens