PerlDoc Perl-Funktion eval

Jede einzelne Perl-Funktion hat es in sich, nachlesen lohnt immer.

eval ​EXPR
eval ​BLOCK
eval ​ ​ ​ ​In ​the ​first ​form, ​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 ​the ​"eval" ​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 ​a ​"use ​5.16" ​or ​higher ​declaration), ​EXPR ​or ​$_ ​is ​treated
 ​ ​ ​ ​ ​ ​ ​ ​as ​a ​string ​of ​characters, ​so ​"use ​utf8" ​declarations ​have ​no
 ​ ​ ​ ​ ​ ​ ​ ​effect, ​and ​source ​filters ​are ​forbidden. ​In ​the ​absence ​of ​the
 ​ ​ ​ ​ ​ ​ ​ ​"unicode_eval" ​feature, ​the ​string ​will ​sometimes ​be ​treated ​as
 ​ ​ ​ ​ ​ ​ ​ ​characters ​and ​sometimes ​as ​bytes, ​depending ​on ​the ​internal
 ​ ​ ​ ​ ​ ​ ​ ​encoding, ​and ​source ​filters ​activated ​within ​the ​"eval" ​exhibit
 ​ ​ ​ ​ ​ ​ ​ ​the ​erratic, ​but ​historical, ​behaviour ​of ​affecting ​some ​outer
 ​ ​ ​ ​ ​ ​ ​ ​file ​scope ​that ​is ​still ​compiling. ​See ​also ​the ​"evalbytes"
 ​ ​ ​ ​ ​ ​ ​ ​keyword, ​which ​always ​treats ​its ​input ​as ​a ​byte ​stream ​and
 ​ ​ ​ ​ ​ ​ ​ ​works ​properly ​with ​source ​filters, ​and ​the ​feature ​pragma.

 ​ ​ ​ ​ ​ ​ ​ ​In ​the ​second ​form, ​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 ​(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 ​the ​"eval" ​itself. ​See
 ​ ​ ​ ​ ​ ​ ​ ​"wantarray" ​for ​more ​on ​how ​the ​evaluation ​context ​can ​be
 ​ ​ ​ ​ ​ ​ ​ ​determined.

 ​ ​ ​ ​ ​ ​ ​ ​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, ​warnings
 ​ ​ ​ ​ ​ ​ ​ ​and ​perllexwarn.

 ​ ​ ​ ​ ​ ​ ​ ​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.

 ​ ​ ​ ​ ​ ​ ​ ​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 ​with ​"eval" ​unless ​$ENV{PERL_DL_NONLAZY} ​is
 ​ ​ ​ ​ ​ ​ ​ ​set. ​See ​perlrun.

 ​ ​ ​ ​ ​ ​ ​ ​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 ​nonfatal
 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​{ ​$answer ​= ​$a ​/ ​$b; ​}; ​warn ​$@ ​if ​$@;

 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​# ​same ​thing, ​but ​less ​efficient
 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​'$answer ​= ​$a ​/ ​$b'; ​warn ​$@ ​if ​$@;

 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​# ​a ​compile-time ​error
 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​{ ​$answer ​= ​}; ​# ​WRONG

 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​# ​a ​run-time ​error
 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​'$answer ​='; ​ ​ ​# ​sets ​$@

 ​ ​ ​ ​ ​ ​ ​ ​Using ​the ​"eval{}" ​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 ​the ​"local
 ​ ​ ​ ​ ​ ​ ​ ​$SIG{__DIE__}" ​construct ​for ​this ​purpose, ​as ​this ​example
 ​ ​ ​ ​ ​ ​ ​ ​shows:

 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​# ​a ​private ​exception ​trap ​for ​divide-by-zero
 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​{ ​local ​$SIG{'__DIE__'}; ​$answer ​= ​$a ​/ ​$b; ​};
 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​warn ​$@ ​if ​$@;

 ​ ​ ​ ​ ​ ​ ​ ​This ​is ​especially ​significant, ​given ​that ​"__DIE__" ​hooks ​can
 ​ ​ ​ ​ ​ ​ ​ ​call ​"die" ​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 ​an ​"eval", ​you ​should ​be ​especially ​careful ​to ​remember
 ​ ​ ​ ​ ​ ​ ​ ​what's ​being ​looked ​at ​when:

 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​$x; ​ ​ ​ ​ ​ ​ ​ ​# ​CASE ​1
 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​"$x"; ​ ​ ​ ​ ​ ​# ​CASE ​2

 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​'$x'; ​ ​ ​ ​ ​ ​# ​CASE ​3
 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​{ ​$x ​}; ​ ​ ​ ​# ​CASE ​4

 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​eval ​"\$$x++"; ​ ​# ​CASE ​5
 ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​$$x++; ​ ​ ​ ​ ​ ​ ​ ​ ​ ​# ​CASE ​6

 ​ ​ ​ ​ ​ ​ ​ ​Cases ​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 ​you
 ​ ​ ​ ​ ​ ​ ​ ​*would* ​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" ​does ​*not* ​count ​as ​a ​loop, ​so ​the ​loop ​control
 ​ ​ ​ ​ ​ ​ ​ ​statements ​"next", ​"last", ​or ​"redo" ​cannot ​be ​used ​to ​leave ​or
 ​ ​ ​ ​ ​ ​ ​ ​restart ​the ​block.

 ​ ​ ​ ​ ​ ​ ​ ​An ​"eval ​''" ​executed ​within ​the ​"DB" ​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.


Datenschutzerklärung: Diese Seite dient rein privaten Zwecken. Auf den für diese Domäne installierten Seiten werden grundsätzlich keine personenbezogenen Daten erhoben. Das Loggen der Zugriffe mit Ihrer Remote Adresse erfolgt beim Provider soweit das technisch erforderlich ist. s​os­@rolf­rost.de und wenn Sie möchten daß mein Prepaid nicht verfällt dürfen Sie mich auch gerne anrufen 01625 26 40 76.