ch04_08.htm

编程珍珠,里面很多好用的代码,大家可以参考学习呵呵,

<p>However, any scope within a file (or even the file itself) is fair
game.  It's often useful to have scopes larger than subroutine
definitions, because this lets you share private variables among a
limited set of subroutines.  This is how you create variables that a C
programmer would think of as "static":
<blockquote>
<pre class="programlisting">{
    my $state = 0;

    sub on     { $state = 1 }
    sub off    { $state = 0 }
    sub toggle { $state = !$state }
}</pre>
</blockquote>
<a name="INDEX-1226"></a>
</p>

<p>The <tt class="literal">eval</tt><em class="replaceable">STRING</em> operator
also works as a nested scope, since the code in the
<tt class="literal">eval</tt> can see its caller's lexicals (as long as the
names aren't hidden by identical declarations within the
<tt class="literal">eval</tt>'s own scope).  Anonymous subroutines can
likewise access any lexical variables from their enclosing scopes; if
they do so, they're what are known as
<em class="emphasis">closures</em>.<a href="#FOOTNOTE-7">[7]</a>
Combining those two notions, if a block <tt class="literal">eval</tt>s a
string that creates an anonymous subroutine, the subroutine becomes a
closure with full access to the lexicals of both the
<tt class="literal">eval</tt> and the block, even after the
<tt class="literal">eval</tt> and the block have exited.  See the section
<a href="ch08_03.htm#ch08-sect-closure">Section 4.3.7, "Closures"</a> in <a href="ch08_01.htm">Chapter 8, "References"</a>.</p>
<blockquote class="footnote">

<a name="FOOTNOTE-7"></a>
<p>[7]As a mnemonic, note the
common element between "en<em class="emphasis">clos</em>ing scope"
and "<em class="emphasis">clos</em>ure".  (The actual definition of
closure comes from a mathematical notion concerning the completeness
of sets of values and operations on those values.)</p>

</blockquote>

<p>The newly declared variable (or value, in the case of
<tt class="literal">local</tt>) does not show up until the statement
<em class="emphasis">after</em> the statement containing the declaration.
Thus you could mirror a variable this way:
<blockquote>
<pre class="programlisting">my $x = $x;</pre>
</blockquote>

That initializes the new inner <tt class="literal">$x</tt> with the current
value <tt class="literal">$x</tt>, whether the current meaning of
<tt class="literal">$x</tt> is global or lexical.  (If you don't initialize
the new variable, it starts out with an undefined or empty value.)</p>

<p>Declaring a lexical variable of a particular name hides any previously
declared lexical of the same name.  It also hides any unqualified
global variable of the same name, but you can always get to the
global variable by explicitly qualifying it with the name of the
package the global is in, for example, <tt class="literal">$PackageName::varname</tt>.</p>






<h3 class="sect2">4.8.3. Lexically Scoped Global Declarations: our</h3>

<a name="INDEX-1227"></a><a name="INDEX-1228"></a><a name="INDEX-1229"></a>
<p>
<a name="INDEX-1230"></a>
A better way to access globals, especially for programs and modules
running under the <tt class="literal">use strict</tt> declaration, is the
<tt class="literal">our</tt> declaration.  This declaration is lexically
scoped in that it applies only through the end of the current scope.
But unlike the lexically scoped <tt class="literal">my</tt> or the
dynamically scoped <tt class="literal">local</tt>, <tt class="literal">our</tt>
does not isolate anything to the current lexical or dynamic scope.
Instead, it provides access to a global variable in the current
package, hiding any lexicals of the same name that would have
otherwise hidden that global from you.  In this respect,
<tt class="literal">our</tt> variables act just like <tt class="literal">my</tt>
variables.</p>

<p>If you place an <tt class="literal">our</tt> declaration outside any
brace-delimited block, it lasts through the end of the current
compilation unit.  Often, though, people put it just inside the top of
a subroutine definition to indicate that they're accessing a global
variable:
<blockquote>
<pre class="programlisting">sub check_warehouse {
    our @Current_Inventory;
    my  $widget;
    foreach $widget (@Current_Inventory) {
        print "I have a $widget in stock today.\n";
    }
}</pre>
</blockquote>

Since global variables are longer in life and broader in visibility
than private variables, we like to use longer and flashier names for
them than for temporary variable.  This practice alone, if studiously
followed, can do as much as <tt class="literal">use strict</tt> can toward
discouraging the use of global variables, especially in less
prestidigitatorial typists.</p>

<p>Repeated <tt class="literal">our</tt> declarations do not meaningfully nest.
Every nested <tt class="literal">my</tt> produces a new variable, and every
nested <tt class="literal">local</tt> a new value.  But every time you use
<tt class="literal">our</tt>, you're talking about <em class="emphasis">the
same</em> global variable, irrespective of nesting.  When you
assign to an <tt class="literal">our</tt> variable, the effects of that
assignment persist after the scope of the declaration.  That's because
<tt class="literal">our</tt> never creates values; it just exposes a limited
form of access to the global, which lives forever:</p>

<blockquote>
<pre class="programlisting">our $PROGRAM_NAME = "waiter";
{
    our $PROGRAM_NAME = "server";
    # Code called here sees "server".
    ...
}
# Code executed here still sees "server".</pre>
</blockquote>

<p>Contrast this with what happens under <tt class="literal">my</tt> or <tt class="literal">local</tt>, where after
the block, the outer variable or value becomes visible again:
<blockquote>
<pre class="programlisting">my $i = 10;
{
    my $i = 99;
    ...
}
# Code compiled here sees outer variable.


local $PROGRAM_NAME = "waiter";
{
    local $PROGRAM_NAME = "server";
    # Code called here sees "server".
    ...
}
# Code executed here sees "waiter" again.</pre>
</blockquote>

It usually only makes sense to assign to an <tt class="literal">our</tt> declaration
once, probably at the very top of the program or module, or, more rarely,
when you preface the <tt class="literal">our</tt> with a <tt class="literal">local</tt> of its own:
<blockquote>
<pre class="programlisting">{
    local our @Current_Inventory = qw(bananas);
    check_warehouse();  # no, we haven't no bananas :-)
}</pre>
</blockquote>
</p>






<h3 class="sect2">4.8.4. Dynamically Scoped Variables: local</h3>

<a name="INDEX-1231"></a><a name="INDEX-1232"></a><a name="INDEX-1233"></a><a name="INDEX-1234"></a>
<p>Using a <tt class="literal">local</tt> operator on a global variable gives
it a temporary value each time <tt class="literal">local</tt> is executed,
but it does not affect that variable's global visibility.  When the
program reaches the end of that dynamic scope, this temporary value is
discarded and the original value restored.  But it's always still a
global variable that just happens to hold a temporary value while that
block is executing.  If you call some other function while your global
contains the temporary value and that function accesses that global
variable, it sees the temporary value, not the original one.  In other
words, that other function is in your dynamic scope, even though it's
presumably not in your lexical scope.<a href="#FOOTNOTE-8">[8]</a>
</p>
<blockquote class="footnote">

<a name="FOOTNOTE-8"></a>
<p>[8] That's why
lexical scopes are sometimes called <em class="emphasis">static
scopes</em>: to contrast them with dynamic scopes and emphasize
their compile-time determinability.  Don't confuse this use of the
term with how <tt class="literal">static</tt> is used in C or C++.  The term
is heavily overloaded, which is why we avoid it.</p>

</blockquote>

<p>If you have a <tt class="literal">local</tt> that looks like this:
<blockquote>
<pre class="programlisting">{
    local $var = $newvalue;
    some_func();
    ...
}</pre>
</blockquote>

you can think of it purely in terms of run-time assignments:
<blockquote>
<pre class="programlisting">{
    $oldvalue = $var;
    $var = $newvalue;
    some_func();
    ...
}
continue {
    $var = $oldvalue;
}</pre>
</blockquote>

The difference is that with <tt class="literal">local</tt> the value is
restored no matter how you exit the block, even if you prematurely
<tt class="literal">return</tt> from that scope.  The variable is still the
same global variable, but the value found there depends on which scope
the function was called from.  That's why it's called
<em class="emphasis">dynamic scoping</em>--because it changes during run
time.</p>

<p>As with <tt class="literal">my</tt>, you can initialize a
<tt class="literal">local</tt> with a copy of the same global variable.  Any
changes to that variable during the execution of a subroutine (and any
others called from within it, which of course can still see the
dynamically scoped global) will be thrown away when the subroutine
returns.  You'd certainly better comment what you are doing, though:
<blockquote>
<pre class="programlisting"># WARNING: Changes are temporary to this dynamic scope.
local $Some_Global = $Some_Global;</pre>
</blockquote>

A global variable then is still completely visible throughout your
whole program, no matter whether it was explicitly declared with
<tt class="literal">our</tt> or just allowed to spring into existence, or
whether it's holding a <tt class="literal">local</tt> value destined to be
discarded when the scope exits.  In tiny programs, this isn't so bad,
but for large ones, you'll quickly lose track of where in the code all
these global variables are being used.  You can forbid accidental use
of globals, if you want, through the <tt class="literal">use strict
'vars'</tt> pragma, described in the next section.</p>

<p>
<a name="INDEX-1235"></a><a name="INDEX-1236"></a>
Although both <tt class="literal">my</tt> and <tt class="literal">local</tt>
confer some degree of protection, by and large you should prefer
<tt class="literal">my</tt> over <tt class="literal">local</tt>.  Sometimes,
though, you have to use <tt class="literal">local</tt> so you can
temporarily change the value of an existing global variable, like
those listed in <a href="ch28_01.htm">Chapter 28, "Special Names"</a>.  Only
alphanumeric identifiers may be lexically scoped, and many of those
special variables aren't strictly alphanumeric.  You also need to use
<tt class="literal">local</tt> to make temporary changes to a package's
symbol table as shown in the section <a href="ch10_01.htm#ch10-sect-st">Section 4.1, "Symbol Tables"</a> in <a href="ch10_01.htm">Chapter 10, "Packages"</a>.  Finally, you can use
<tt class="literal">local</tt> on a single element or a whole slice of an
array or a hash.  This even works if the array or hash happens to be a
lexical variable, layering <tt class="literal">local</tt>'s dynamic scoping
behavior on top of those lexicals.  We won't talk much more about the
semantics of <tt class="literal">local</tt> here.  See
<tt class="literal">local</tt> in <a href="ch29_01.htm">Chapter 29, "Functions"</a> for
more information.</p>



<!-- BOTTOM NAV BAR -->

<hr width="515" align="left">
<div class="navbar">
<table width="515" border="0">
<tr>
<td align="left" valign="top" width="172"><a href="ch04_07.htm"><img src="../gifs/txtpreva.gif" alt="Previous" border="0"></a></td><td align="center" valign="top" width="171"><a href="index.htm"><img src="../gifs/txthome.gif" alt="Home" border="0"></a></td><td align="right" valign="top" width="172"><a href="ch04_09.htm"><img src="../gifs/txtnexta.gif" alt="Next" border="0"></a></td>
</tr>
<tr>
<td align="left" valign="top" width="172">4.7. Global Declarations</td><td align="center" valign="top" width="171"><a href="index/index.htm"><img src="../gifs/index.gif" alt="Book Index" border="0"></a></td><td align="right" valign="top" width="172">4.9. Pragmas</td>
</tr>
</table>
</div>
<hr width="515" align="left">

<!-- LIBRARY NAV BAR -->

<img src="../gifs/smnavbar.gif" usemap="#library-map" border="0" alt="Library Navigation Links"><p>
<font size="-1"><a href="copyrght.htm">Copyright &copy; 2001</a> O'Reilly &amp; Associates. All rights reserved.</font>
</p>
<map name="library-map"> <area shape="rect" coords="2,-1,79,99" href="../index.htm"><area shape="rect" coords="84,1,157,108" href="../perlnut/index.htm"><area shape="rect" coords="162,2,248,125" href="../prog/index.htm"><area shape="rect" coords="253,2,326,130" href="../advprog/index.htm"><area shape="rect" coords="332,1,407,112" href="../cookbook/index.htm"><area shape="rect" coords="414,2,523,103" href="../sysadmin/index.htm">
</map>

<!-- END OF BODY -->

</body>
</html>