perl-5.34.0
exists EXPR

Given an expression that specifies an element of a hash, returns true if the specified element in the hash has ever been initialized, even if the corresponding value is undefined.

��������激�ヨ��膣����腓冴��茵◐憗��筝����������������絎����������荀�膣���������������激�ャ��絖������������違�� ���������絲上����������ゃ����ɱ��臂í�с��������菴������障�����

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

exists may also be called on array elements, but its behavior is much less obvious and is strongly tied to the use of delete on arrays.

exists ��奝�������勤��膣����絲障����⓾����若�喝�冴����障�������������勖�壔����������壔�壔������� 筝����腆冴�с�����������絲障����� delete ��勌戎������綣激� 腟���潟�ゃ����⓾����障�����

WARNING: Calling exists on array values is strongly discouraged. The notion of deleting or checking the existence of Perl array elements is not conceptually coherent, and can lead to surprising behavior.

茘☗��: ��������勐�ゃ��絲障����� exists �����若�喝�冴����������壠七�� ����ィ絅���с����� Perl ��勰�����荀�膣���������ゃ��������絖�������茯帥�鴻�����������荐�羈���壩��綽窮����˩��莢˨����⓾����������� 薊������鴻����壔�����������綣����莎激����������������������障�����

    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 only 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. Note that a subroutine that does not exist may still be callable: its package may have an AUTOLOAD method that makes it spring into existence the first time that it is called; see perlsub.

綣���違�������⓾�泣����˨�若����潟�勐�����������絎������������翫����� ���絎������������泣����˨�若����潟��絎h����������⓾��������(�����������ɱ��臂í�с��) ������菴������障����� exists ��� defined ��勉�������̬�������������⓾�������泣����˨�若����喝���� 絎h����������⓾�勉�˨�⓾�潟�������ャ����障�������� 絖���������ŝ����泣����˨�若����潟�с����若�喝�冴���櫝�純�������������ŝ�����������羈���������⓾�����������: ��������宴�若�吾�� AUTOLOAD ��<�純�������������c�⓾����⓾�������������若�喝�冴������������� 絖�������篏������冴����������������障�����; perlsub ��������с����⓾��������������

    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:

���腟������ʋ��篏������������激�ャ����������� key ��˨�����罎�膣≪�障���� ��泣����˨�若����喝����с�������������壔��EXPR ��˨�壚算�����勤�������ɱ�����臀勉�������������с����障��:

    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 most deeply nested array or hash element 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 here:

������羞宴�������鴻�������������������������激�ャ�勤��膣���壔�������勐�������������鴻����������������с� 絖������������������˨�壔�ŝ����障��������������筝㏍�勉����勉�壠�������������������˨�ŝ����障����� 緇���c�� $ref->{"A"} ��� $ref->{"A"}->{"B"} ��壚��荐���� $key �� 絖������������鴻����������������˨����c�☗�������������������˨�ŝ����障����� ��������壔����√�井��膊�絖����篏帥�������������������с�壔��篁ヤ����勉�������ŝ����勉����˨����í����с�с�� 莎激�������障�����

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

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

exists ��勐����違�������⓾�泣����˨�若����喝����с�ŝ����泣����˨�若���� ��若�喝�冴�����篏帥�������������í�若�˨�ŝ����障�����

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