Perl5 リファレンス

       exists EXPR
               Given an expression that specifies a hash element
               or array element, returns true if the specified
               element in the hash or array has ever been
               initialized, even if the corresponding value is
               undefined.  The element is not autovivified if it
               doesn't exist.

                   print "Exists\n"    if exists $hash{$key};
                   print "Defined\n"   if defined $hash{$key};
                   print "True\n"      if $hash{$key};

                   print "Exists\n"    if exists $array[$index];
                   print "Defined\n"   if defined $array[$index];
                   print "True\n"      if $array[$index];

               A hash or array element can be true only if it's
               defined, and defined if it exists, but the reverse
               doesn't necessarily hold true.

               Given an expression that specifies the name of a
               subroutine, returns true if the specified
               subroutine has ever been declared, even if it is
               undefined.  Mentioning a subroutine name for
               exists or defined does not count as declaring it.

                   print "Exists\n"    if exists &subroutine;
                   print "Defined\n"   if defined &subroutine;

               Note that the EXPR can be arbitrarily complicated
               as long as the final operation is a hash or array
               key lookup or subroutine name:

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

                   if (exists $ref->{A}->{B}->[$ix])   { }
                   if (exists $hash{A}{B}[$ix])        { }

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

               Although the deepest nested array or hash will not
               spring into existence just because its existence
               was tested, any intervening ones will.  Thus
               `$ref->{"A"}' and `$ref->{"A"}->{"B"}' will spring
               into existence due to the existence test for the
               $key element above.  This happens anywhere the
               arrow operator is used, including even:

                   undef $ref;
                   if (exists $ref->{"Some key"})      { }
                   print $ref;             # prints HASH(0x80d3d5c)

               This surprising autovivification in what does not
               at first--or even second--glance appear to be an
               lvalue context may be fixed in a future release.

               See the Pseudo-hashes: Using an array as a hash
               entry in the perlref manpage for specifics on how
               exists() acts when used on a pseudo-hash.

               Use of a subroutine call, rather than a subroutine
               name, as an argument to exists() is an error.

                   exists ⊂        # OK
                   exists &sub();      # Error