perl-5.34.0
eval EXPR
eval BLOCK
eval

eval in all its forms is used to execute a little Perl program, trapping any errors encountered so they don't crash the calling program.

��í�勐��綣���� eval ������絨������� Perl ��勉����㏍�違�í����с����������勉��������絎�茵���������� ��㊨�������������⓾�勉����í�若�������í�������������勉�с����若�喝�冴����������㏍�違�í����� ��壔�í����激�ャ�������������壔�������障��������

Plain eval with no argument is just eval EXPR, where the expression is understood to be contained in $_. Thus there are only two real eval forms; the one with an EXPR is often called "string eval". In a string eval, the value of the expression (which is itself determined within scalar context) is first parsed, and if there were no errors, executed as a block within the lexical context of the current Perl program. This form is typically used to delay parsing and subsequent execution of the text of EXPR until run time. Note that the value is parsed every time the eval executes.

綣���違�ŝ����� eval ��壠����� eval EXPR ��с��綣���� $_ �� ��˨�障����⓾����������勉�������☀�������������障����� 緇���c�☗�������˨�壚����ゃ�������� eval 綵√�������������障��: EXPR ��勉����勉�壔����違����違�����絖���� eval���(string eval) �����若�違����障����� ������絖���� eval�����с�壔�� 綣���勐��(��������ʃ昆��鴻�˨�í�潟�潟����㏍�鴻����勌賢��ф浦絎���������障��)��壔�障�������若�鴻�������� �����í�若����ŝ�������� Perl �����㏍�違�í����勉�㋘�㏍�激�˨�˨�潟�潟����㏍�鴻����勌賢��勉����㏍����壔������� 絎�茵���������障����� �����勐就��壚源��� EXPR ��勉����㏍�鴻����勉����若�鴻��絎�茵����絎�茵������˨�障� ���綮吟����������勉�̥�������障����� 菴������������ゃ�� eval ���絎�茵������������������˨����若�鴻�����������������羈���������⓾��������������

The other form is called "block eval". It is less general than string eval, but the code within the BLOCK is parsed only once (at the same time the code surrounding the eval itself was parsed) and executed within the context of the current Perl program. This form is typically used to trap exceptions more efficiently than the first, while also providing the benefit of checking the code within BLOCK at compile time. BLOCK is parsed and compiled just once. Since errors are trapped, it often is used to check if a given feature is available.

������筝���ゃ�勐��綣���壔�������㏍����� eval��������若�違����障����� ��������壩��絖���� eval ��祉�î����㋜����с�壔�������障����������� BLOCK ��������勉�潟�若����壚��綺⓾����������若�鴻����� (��潟�若����� ��蚊�� eval ��ʃ昆��������若�鴻����������勉�������������鴻�с��) �憜���� Perl �����㏍�違�í����勉�潟�潟����㏍�鴻����у��茵���������障����� �����勐就綣���壠�後�������˨�夌⓬筝���勐就綣���������合�������˩��紊���������í����������障��; ��障�� BLOCK ��������勉�潟�若����壔�潟�潟����ゃ�������˨����с����壔�������������������ñ�鴻�����箴������障����� BLOCK ��壚��綺⓾����������若�劫����潟�潟�潟����ゃ�˨�������障����� �����í�若�壔����í�������������⓾����勉�с�������違����遺��������������罘���純����ñ���櫝�純����� �����с����壔�������������˩戎��������障�����

In both forms, the value returned is the value of the last expression evaluated inside the mini-program; a return statement may also be used, just as with subroutines. The expression providing the return value is evaluated in void, scalar, or list context, depending on the context of the eval itself. See wantarray for more on how the evaluation context can be determined.

��í�<����勐就綣���с�����菴������������ゃ�壔����������㏍�違�í����勐�������ф��緇���̬��箴<�������� 茵◐憗�勐�ゃ�с��; ��泣����˨�若����潟�����罕����return ������篏帥����障����� 菴������ゃ�������〠��箴����������茵◐憗�壔��eval ��ʃ昆��勉�潟�潟����㏍�鴻���� 箴�絖������☎�≦�鴻�祉�鴻�˨�í�祉�ŝ�鴻����勉�������������勉�潟�潟����㏍�鴻����ц��箴<�������障����� 荅�箴<�潟�潟����㏍�鴻����勖浦絎���号����˨�ゃ����⓾�勤¼膣違�� wantarray ��� �����с����⓾��������������

If there is a syntax error or runtime error, or a die statement is executed, eval returns undef in scalar context, or an empty list in list context, and $@ is set to the error message. (Prior to 5.16, a bug caused undef to be returned in list context for syntax errors, but not for runtime errors.) If there was no error, $@ is set to the empty string. A control flow operator like last or goto can bypass the setting of $@. Beware that using eval neither silences Perl from printing warnings to STDERR, nor does it stuff the text of warning messages into $@. To do either of those, you have to use the $SIG{__WARN__} facility, or turn off warnings inside the BLOCK or EXPR using no warnings 'all'. See warn, perlvar, and warnings.

罕���������í�若��絎�茵������í�若����榊��������������die ������絎�茵���������������� eval ��壔�鴻�˨�í�潟�潟����㏍�鴻����с�� undef ������ ��ŝ�鴻����潟�潟����㏍�鴻����с�夌Ã��ŝ�鴻�����荐㊤����������� $@ ��˨����í�若�<����祉�若�吾��荐㊤����������障����� (5.16 篁ュ����с�壔�������違�˨����c�⓾����ŝ�鴻����潟�潟����㏍�鴻����ф����������í�若�勖����˨� undef ���菴������⓾����障�����������絎�茵������í�若�勖����˨� 菴������⓾����障�������с��������) �����í�若����ŝ�������違��$@ ��夌Ã���絖������̬┃絎���������障����� last ��� goto ��勉�������ŝ����㏍�弱�九勝羲�膊�絖��� $@ ��勤┃絎���������帥�с����障����� eval ������STDERR ��̬⑥�����<����祉�若�吾��茵◐ず��������ŝ����勛�������� 茘☗����<����祉�若�吾�� $@ �����主����������勛����с�壚戎�����ŝ����с�������������� �����勉�������ɾ�◒����с�壔��$SIG{__WARN__} 罘���純��篏帥�������� no warnings 'all' ���篏帥�c�� BLOCK ��� EXPR ��勐�������с�勤⑥������ ��ŝ����˨�����綽�荀������������障����� warn, perlvar, warnings ��������с����⓾��������������

Note that, because eval traps otherwise-fatal errors, it is useful for determining whether a particular feature (such as socket or symlink) is implemented. It is also Perl's exception-trapping mechanism, where the die operator is used to raise exceptions.

eval ��壔����翫�順�������í�若����ŝ����������ŝ����勉�� �����í����������������������с�������勉�с�� (socket ��� symlink ��������c��) ��劫����勖����純�� 絎�茖���������⓾�������������� 茯帥�鴻����������˩戎��������������с��������������羈���������⓾�������������� die 羲�膊�絖����箴�紊������榊����������������勉����������違����������壔�障����� Perl ��勌��紊�������罘���純����������������������с����障�����

Before Perl 5.14, the assignment to $@ occurred before restoration of localized variables, which means that for your code to run on older versions, a temporary is required if you want to mask some, but not all errors:

Perl 5.14 �����������с�壔��$@ ��吾�勌撮��ャ�壔�㏍�若�˨��������������紊���違� 緇ï鍵��勐����̬儀��������勉�с���𡉴�������若�吾�с�潟�у��茵������������翫����壔�������⓾�с�壔�ŝ�鋇������������ �����í�若�������鴻�壔����������翫����˨�壚�����紊���違��綽�荀���с��:

 # alter $@ on nefarious repugnancy only
 {
    my $e;
    {
      local $@; # protect existing $@
      eval { test_repugnancy() };
      # $@ =~ /nefarious/ and die $@; # Perl 5.14 and higher only
      $@ =~ /nefarious/ and $e = $@;
    }
    die $e if defined $e
 }

There are some different considerations for each form:

��������������勐��綣���˨�ゃ����⓾����違�ŝ�c�������勌����������������障��: