There are two kinds of variable scopes in Perl:
Global variables: They resIDe in the current package,can be accessed from the outsIDe and can have "local" values. The name can be used as a key in the "stash",the package variable hash / the symbol table. Lexical variables: They resIDe in the current scope (roughly delimited by curly braces). There is no symbol table that can be inspected.Lexical variables and global variables do not interfere,there can be two different variables with the same name.
Most Perl variable magic happens with global variables: These lines are rougly equivalent:
our $var; $::var; $main::var; ${var}; ${'var'}; local $var;
but not my $var
.
So we can write:
@::array = qw(a b c); my @secondarray = @{array};
Which copIEs the arrays. We can also look up the array with a name that is stored in a variable:
my $name = "array"; @secondarray = @{$name};
The last line abbreviates to … = @$name
.
This is not possible with lexical vars because they do not resIDe in the stash.
The local
function assigns a "local" value to a global variable (and globals only) within the current scope and in the scope of all subs that are called from within this scope.
Originally (in Perl 4) meddling with variable names and the stash was the only way to simulate references. These usages are Now mostly outdated by ~2 decades as references are available (what is far safer)
There is a perldoc
entry which answers this question in perlfaq7:
. 9/2/2012 Update This weekend,I reread the book of Effective Programming Perl,and found more full answer in the section: Item 43 Understand the difference between my and local.What's the difference between dynamic and lexical (static) scoping? Between
local()
andmy()
?
local($x)
saves away the old value of the global variable$x
and assigns a new value for the duration of the subroutine which is visible in other functions called from that subroutine. This is done at run-time,so is called dynamic scoping.local()
always affects global variables,also called package variables or dynamic variables.my($x)
creates a new variable that is only visible in the current subroutine. This is done at compile-time,so it is called lexical or static scoping.my()
always affects private variables,also called lexical variables or (improperly) static(ly scoped) variables.For instance:
sub visible { print "var has value $var\n"; } sub dynamic { local $var = 'local'; # new temporary value for the still-global visible(); # variable called $var } sub lexical { my $var = 'private'; # new private variable,$var visible(); # (invisible outsIDe of sub scope) } $var = 'global'; visible(); # prints global dynamic(); # prints local lexical(); # prints globalNotice how at no point does the value "private" get printed. That's because
$var
only has that value within the block of thelexical()
function,and it is hIDden from the called subroutine.In summary,
local()
doesn't make what you think of as private,local variables. It gives a global variable a temporary value. my() is what you're looking for if you want private variables.See
Private Variables via my()
in perlsub and Temporary Values via local() in perlsub for excruciating details.
Reference: http://stackoverflow.com/questions/12189865/whats-the-difference-between-local-and-my-in-perl#
总结以上是内存溢出为你收集整理的What's the difference between “local” and “my” in Perl全部内容,希望文章能够帮你解决What's the difference between “local” and “my” in Perl所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错,欢迎将内存溢出网站推荐给程序员好友。
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)