In the first form, often referred to as a "string eval", the return value of EXPR is parsed and executed as if it were a little Perl program. 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 means, that in particular, any outer lexical variables are visible to it, and any package variable settings or subroutine and format definitions remain afterwards.
Note that the value is parsed every time theeval executes. If EXPR is omitted, evaluates$_. This form is typically used to delay parsing and subsequent execution of the text of EXPR until run time.
If the"unicode_eval" feature is enabled (which is the default under ause 5.16 or higher declaration), EXPR or$_ is treated as a string of characters, souse utf8 declarations have no effect, and source filters are forbidden. In the absence of the"unicode_eval" feature, will sometimes be treated as characters and sometimes as bytes, depending on the internal encoding, and source filters activated within theeval exhibit the erratic, but historical, behaviour of affecting some outer file scope that is still compiling. See also theevalbytes operator, which always treats its input as a byte stream and works properly with source filters, and thefeature pragma.
Problems can arise if the string expands a scalar containing a floating point number. That scalar can expand to letters, such as"NaN" or"Infinity"; or, within the scope of ause locale, the decimal point character may be something other than a dot (such as a comma). None of these are likely to parse as you are likely expecting.
In the second form, the code within the BLOCK is parsed only once--at the same time the code surrounding theeval 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 (see below), while also providing the benefit of checking the code within BLOCK at compile time.
The final semicolon, if any, may be omitted from the value of EXPR or within the BLOCK.
In both forms, the value returned is the value of the last expression evaluated inside the mini-program; a return statement may be also used, just as with subroutines. The expression providing the return value is evaluated in void, scalar, or list context, depending on the context of theeval itself. Seewantarray for more on how the evaluation context can be determined.
If there is a syntax error or runtime error, or adie statement is executed,eval returnsundef in scalar context or an empty list in list context, and$@ is set to the error message. (Prior to 5.16, a bug causedundef 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 likelast orgoto can bypass the setting of$@. Beware that usingeval 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 usingno warnings 'all'. Seewarn,perlvar, andwarnings.
Note that, becauseeval traps otherwise-fatal errors, it is useful for determining whether a particular feature (such assocket orsymlink) is implemented. It is also Perl's exception-trapping mechanism, where thedie operator is used to raise exceptions.
If you want to trap errors when loading an XS module, some problems with the binary interface (such as Perl version skew) may be fatal even witheval unless$ENV{PERL_DL_NONLAZY} is set. Seeperlrun.
If the code to be executed doesn't vary, you may use the eval-BLOCK form to trap run-time errors without incurring the penalty of recompiling each time. The error, if any, is still returned in$@. Examples:
# make divide-by-zero nonfataleval { $answer = $a / $b; }; warn $@ if $@;# same thing, but less efficienteval '$answer = $a / $b'; warn $@ if $@;# a compile-time erroreval { $answer = }; # WRONG# a run-time erroreval '$answer ='; # sets $@Using theeval {} form as an exception trap in libraries does have some issues. Due to the current arguably broken state of__DIE__ hooks, you may wish not to trigger any__DIE__ hooks that user code may have installed. You can use thelocal $SIG{__DIE__} construct for this purpose, as this example shows:
# a private exception trap for divide-by-zeroeval { local $SIG{'__DIE__'}; $answer = $a / $b; };warn $@ if $@;This is especially significant, given that__DIE__ hooks can calldie again, which has the effect of changing their error messages:
# __DIE__ hooks may modify error messages{ local $SIG{'__DIE__'} = sub { (my $x = $_[0]) =~ s/foo/bar/g; die $x }; eval { die "foo lives here" }; print $@ if $@; # prints "bar lives here"}Because this promotes action at a distance, this counterintuitive behavior may be fixed in a future release.
With aneval, you should be especially careful to remember what's being looked at when:
eval $x; # CASE 1eval "$x"; # CASE 2eval '$x'; # CASE 3eval { $x }; # CASE 4eval "\$$x++"; # CASE 5$$x++; # CASE 6Cases 1 and 2 above behave identically: they run the code contained in the variable $x. (Although case 2 has misleading double quotes making the reader wonder what else might be happening (nothing is).) Cases 3 and 4 likewise behave in the same way: they run the code'$x', which does nothing but return the value of $x. (Case 4 is preferred for purely visual reasons, but it also has the advantage of compiling at compile-time instead of at run-time.) Case 5 is a place where normally youwould like to use double quotes, except that in this particular situation, you can just use symbolic references instead, as in case 6.
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:
# 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}eval BLOCK doesnot count as a loop, so the loop control statementsnext,last, orredo cannot be used to leave or restart the block.
Aneval '' executed within a subroutine defined in theDB package doesn't see the usual surrounding lexical scope, but rather the scope of the first non-DB piece of code that called it. You don't normally need to worry about this unless you are writing a Perl debugger.
Perldoc Browser is maintained by Dan Book (DBOOK). Please contact him via theGitHub issue tracker oremail regarding any issues with the site itself, search, or rendering of documentation.
The Perl documentation is maintained by the Perl 5 Porters in the development of Perl. Please contact them via thePerl issue tracker, themailing list, orIRC to report any issues with the contents or format of the documentation.