2018年做视频网站,2345浏览器网址,做情人在那个网站,9951026企业邮箱888perl脚本中有时候执行的操作可能会引发异常#xff0c;为了直观的说明#xff0c;这里举一个json反序列化的例子#xff0c;脚本如下#xff1a;
#! /usr/bin/perl
use v5.14;
use JSON;
use Data::Dumper;# 读取json字符串数据
my $json_str join(, DATA);
# 反…perl脚本中有时候执行的操作可能会引发异常为了直观的说明这里举一个json反序列化的例子脚本如下
#! /usr/bin/perl
use v5.14;
use JSON;
use Data::Dumper;# 读取json字符串数据
my $json_str join(, DATA);
# 反序列化操作
my $json from_json($json_str);say to_json($json, { pretty 1 });__DATA__
bad {id : 1024,desc : hello world,other : {test_null : null,test_false : false,test_true : true}
} 脚本中有意把正确json字符串之前加了几个字符显然这个json字符串是不符合规范格式的在git bash中执行这个脚本结果如下
下面用perl的eval函数改造这个脚本
#! /usr/bin/perl
use v5.14;
use JSON;
use Data::Dumper;# 读取json字符串数据
my $json_str join(, DATA);
# 反序列化操作
my $json eval {return from_json($json_str);
};unless (defined $json) {say from_json failed !!!!;
} else {say to_json($json, { pretty 1 });
}__DATA__
bad {id : 1024,desc : hello world,other : {test_null : null,test_false : false,test_true : true}
}
脚本中用把from_json的操作放在eval函数中输出结果如下 显然这个结果是可控的可预期的。比如就可以使用这种方法判断json字符串是否合法能够正常反序列化的就是合法的否则就是非法的。eval函数的具体使用可以使用perldoc -f eval查看。 eval EXPReval BLOCKeval eval in all its forms is used to execute a little Perlprogram, trapping any errors encountered so they dont crash thecalling program.Plain eval with no argument is just eval EXPR, where theexpression is understood to be contained in $_. Thus there areonly two real eval forms; the one with an EXPR is often calledstring eval. In a string eval, the value of the expression(which is itself determined within scalar context) is firstparsed, and if there were no errors, executed as a block withinthe lexical context of the current Perl program. This form istypically used to delay parsing and subsequent execution of thetext of EXPR until run time. Note that the value is parsed everytime the eval executes.The other form is called block eval. It is less general thanstring eval, but the code within the BLOCK is parsed only once(at the same time the code surrounding the eval itself wasparsed) and executed within the context of the current Perlprogram. This form is typically used to trap exceptions moreefficiently than the first, while also providing the benefit ofchecking the code within BLOCK at compile time. BLOCK is parsedand compiled just once. Since errors are trapped, it often isused to check if a given feature is available.In both forms, the value returned is the value of the lastexpression evaluated inside the mini-program; a return statementmay also be used, just as with subroutines. The expressionproviding the return value is evaluated in void, scalar, or listcontext, depending on the context of the eval itself. Seewantarray for more on how the evaluation context can bedetermined.If there is a syntax error or runtime error, or a diestatement is executed, eval returns undef in scalar context,or an empty list in list context, and $ is set to the errormessage. (Prior to 5.16, a bug caused undef to be returned inlist context for syntax errors, but not for runtime errors.) Ifthere was no error, $ is set to the empty string. A controlflow operator like last or goto can bypass the setting of$. Beware that using eval neither silences Perl from printingwarnings to STDERR, nor does it stuff the text of warningmessages into $. To do either of those, you have to use the$SIG{__WARN__} facility, or turn off warnings inside the BLOCKor EXPR using no warnings all. See warn, perlvar, andwarnings.Note that, because eval traps otherwise-fatal errors, it isuseful for determining whether a particular feature (such assocket or symlink) is implemented. It is also Perlsexception-trapping mechanism, where the die operator is usedto raise exceptions.Before Perl 5.14, the assignment to $ occurred beforerestoration of localized variables, which means that for yourcode to run on older versions, a temporary is required if youwant 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}There are some different considerations for each form:String evalSince the return value of EXPR is executed as a block withinthe lexical context of the current Perl program, any outerlexical variables are visible to it, and any packagevariable settings or subroutine and format definitionsremain afterwards.Under the unicode_eval featureIf this feature is enabled (which is the default under ause 5.16 or higher declaration), EXPR is considered tobe in the same encoding as the surrounding program. Thusif use utf8 is in effect, the string will be treatedas being UTF-8 encoded. Otherwise, the string isconsidered to be a sequence of independent bytes. Bytesthat correspond to ASCII-range code points will havetheir normal meanings for operators in the string. Thetreatment of the other bytes depends on if theunicode_strings feature is in effect.In a plain eval without an EXPR argument, being inuse utf8 or not is irrelevant; the UTF-8ness of $_itself determines the behavior.Any use utf8 or no utf8 declarations within thestring have no effect, and source filters are forbidden.(unicode_strings, however, can appear within thestring.) See also the evalbytes operator, which worksproperly with source filters.Variables defined outside the eval and used inside itretain their original UTF-8ness. Everything inside thestring follows the normal rules for a Perl program withthe given state of use utf8.Outside the unicode_eval featureIn this case, the behavior is problematic and is not soeasily described. Here are two bugs that cannot easilybe fixed without breaking existing programs:* It can lose track of whether something should beencoded as UTF-8 or not.* Source filters activated within eval leak out intowhichever file scope is currently being compiled. Togive an example with the CPAN moduleSemi::Semicolons:BEGIN { eval use Semi::Semicolons; # not filtered }# filtered here!evalbytes fixes that to work the way one wouldexpect:use feature evalbytes;BEGIN { evalbytes use Semi::Semicolons; # filtered }# not filteredProblems can arise if the string expands a scalar containinga floating point number. That scalar can expand to letters,such as NaN or Infinity; or, within the scope of a uselocale, the decimal point character may be something otherthan a dot (such as a comma). None of these are likely toparse as you are likely expecting.You should be especially careful to remember whats beinglooked 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 codecontained in the variable $x. (Although case 2 hasmisleading double quotes making the reader wonder what elsemight be happening (nothing is).) Cases 3 and 4 likewisebehave in the same way: they run the code $x, which doesnothing but return the value of $x. (Case 4 is preferred forpurely visual reasons, but it also has the advantage ofcompiling at compile-time instead of at run-time.) Case 5 isa place where normally you *would* like to use doublequotes, except that in this particular situation, you canjust use symbolic references instead, as in case 6.An eval executed within a subroutine defined in theDB package doesnt see the usual surrounding lexicalscope, but rather the scope of the first non-DB piece ofcode that called it. You dont normally need to worry aboutthis unless you are writing a Perl debugger.The final semicolon, if any, may be omitted from the valueof EXPR.Block evalIf the code to be executed doesnt vary, you may use theeval-BLOCK form to trap run-time errors without incurringthe penalty of recompiling each time. The error, if any, isstill 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 $If you want to trap errors when loading an XS module, someproblems with the binary interface (such as Perl versionskew) may be fatal even with eval unless$ENV{PERL_DL_NONLAZY} is set. See perlrun.Using the eval {} form as an exception trap in librariesdoes have some issues. Due to the current arguably brokenstate of __DIE__ hooks, you may wish not to trigger any__DIE__ hooks that user code may have installed. You canuse the local $SIG{__DIE__} construct for this purpose, asthis 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__ hookscan call die again, which has the effect of changing theirerror 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, thiscounterintuitive behavior may be fixed in a future release.eval BLOCK does *not* count as a loop, so the loop controlstatements next, last, or redo cannot be used to leaveor restart the block.The final semicolon, if any, may be omitted from within theBLOCK.
