use Data::Dumper;
my $x;
if (exists $x->{a}->{c}) {
  print "c exists\n";
} else {
  print "c doesn't exists\n";
}
print Dumper($x);
__END__
c doesn't exist
$VAR1 = {
          'a' => {}
        };
[download]

No, not really. exists never autovivifies, but it doesn't prevent anything else (such as ->) from causing autovivification. In the given example ($x->{a}->{c}), the first -> autovivifies $x and the second -> autovivifies $x->{a}. This occurs independently of exists.

>perl -le"$x->{a}->{c}; print $x; print $x->{a}"
HASH(0x225f18)
HASH(0x226020)
[download]

this is the best answer I read so far. thanks.

If you need to test for existence without autovivification, you'll have to code up a test that goes something like this:

sub my_exists {
  my $struct = shift;
  while (@_) {
    my $key = shift(@_);
    return false unless exists $hash->{$key};
    $hash = $hash->{$key};
  }
  1;
}

my $x = {};
if (my_exists($x, 'a', 'c')) {
  print "c exists\n";
} else {
  print "c doesn't exist\n";
}
print Dumper($x);
[download]

Or download Data::Diver or Hash::NoVivify. ;-)

lodin

nice solution. thanks.

cool!

well, cool that you answered. btu I dislike the behavior a lot. who does not?

No. exists would always return true if it autovivified the element being tested. It will however autovivify any elements the element being tested depends on. Consider:

use strict;
use warnings;

my %hash;

if (exists $hash{top}{dependent}) {
    print "\$hash{top}{dependent} exists\n";
} else {
    print "\$hash{top}{dependent} does not exist\n";
}

if (exists $hash{top}) {
    print "\$hash{top} exists\n";
} else {
    print "\$hash{top} does not exist\n";
}
[download]

Prints:

$hash{top}{dependent} does not exist
$hash{top} exists
[download]

I noticed that from the first example, and my memory of auto-vivification did fade a little. you said "exists would always return true if it autovivified the element being tested", well not entirely true, depends on sequence of events, but that's meaningless argue any way. thanks for taking your time.

If it tested first but autovivified anyway it'd have to be named 'existed' because having made the test you would know that it exists. ;)

---

Perl is environmentally friendly - it saves trees

# instead of: if (exists $x->{a}[0]{c}) {
if (exists ${ ${ $x->{a} || [] }[0] || {} }{c}) {
[download]

I don't know what the application domain is nor how you got bit by this behaviour, but you may find Data::Diver helps.

no, it didn't get me. I was aware of this from start on, so the code was right. just wanted to confirm my understanding, since I haven't perl 4 a while. played with given/when and say, nice little improvement.

That will turn an attempt to autovivify into an exception.

$ perl -MHash::Util=lock_keys -wle 'my %x; lock_keys %x; exists $x{a}{
+b}'
Attempt to access disallowed key 'a' in a restricted hash at -e line 1
+.
[download]

Very useful for debugging.

that also turns lots of other things into an exception, good luck.

that's not a solution, unless the lock on keys is what you happen to want. a solution must be precise.

I've taken advantage of short-circuiting operators to deal with this in the past, like so:
if (exists($x->{a}) && exists($x->{a}->{c}) { #do stuff }

Might get annoying if your hash is particularly deep, though.