ch10_01.htm

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

<p>Earlier we said that only identifiers are stored in packages other than
<tt class="literal">main</tt>.  That was a bit of a fib: you can use any string you want as the
key in a symbol table hash--it's just that it wouldn't be valid Perl if
you tried to use a non-identifier directly:
<blockquote>
<pre class="programlisting">$!@#$%           = 0;         # WRONG, syntax error.
${'!@#$%'}       = 1;         # Ok, though unqualified.

${'main::!@#$%'} = 2;         # Can qualify within the string.
print ${ $main::{'!@#$%'} }   # Ok, prints 2!</pre>
</blockquote>
<a name="INDEX-2232"></a>
Assignment to a typeglob performs an aliasing operation; that is,
<blockquote>
<pre class="programlisting">*dick = *richard;</pre>
</blockquote>

causes variables, subroutines, formats, and file and directory handles
accessible via the identifier <tt class="literal">richard</tt> to also be
accessible via the symbol <tt class="literal">dick</tt>.  If you want to
alias only a particular variable or subroutine, assign a reference
instead:
<blockquote>
<pre class="programlisting">*dick = \$richard;</pre>
</blockquote>

That makes <tt class="literal">$richard</tt> and <tt class="literal">$dick</tt> the same variable, but leaves
<tt class="literal">@richard</tt> and <tt class="literal">@dick</tt> as separate arrays.  Tricky, eh?</p>

<p>
<a name="INDEX-2233"></a>
This is how the <tt class="literal">Exporter</tt> works when importing symbols from one
package to another. For example:
<blockquote>
<pre class="programlisting">*SomePack::dick = \&amp;OtherPack::richard;</pre>
</blockquote>

imports the <tt class="literal">&amp;richard</tt> function from package <tt class="literal">OtherPack</tt> into
<tt class="literal">SomePack</tt>, making it available as the <tt class="literal">&amp;dick</tt> function.  (The
<tt class="literal">Exporter</tt> module is described in the next chapter.)  If you
precede the assignment with a <tt class="literal">local</tt>, the aliasing will only last as
long as the current dynamic scope.</p>

<p>
<a name="INDEX-2234"></a><a name="INDEX-2235"></a>
This mechanism may be used to retrieve a reference from a subroutine,
making the referent available as the appropriate data type:
<blockquote>
<pre class="programlisting">*units = populate() ;         # Assign \%newhash to the typeglob
print $units{kg};             # Prints 70; no dereferencing needed!

sub populate {
    my %newhash = (km =&gt; 10, kg =&gt; 70);
    return \%newhash;
}</pre>
</blockquote>

Likewise, you can pass a reference into a subroutine and use it
without dereferencing:
<blockquote>
<pre class="programlisting">%units = (miles =&gt; 6, stones =&gt; 11);  
fillerup( \%units );          # Pass in a reference
print $units{quarts};         # Prints 4

sub fillerup {
    local *hashsym = shift;   # Assign \%units to the typeglob
    $hashsym{quarts} = 4;     # Affects %units; no dereferencing needed!
}</pre>
</blockquote>

These are tricky ways to pass around references cheaply when you don't
want to have to explicitly dereference them.  Note that both
techniques only work with package variables; they would not have
worked had we declared <tt class="literal">%units</tt> with
<tt class="literal">my</tt>.</p>

<p>
<a name="INDEX-2236"></a><a name="INDEX-2237"></a><a name="INDEX-2238"></a><a name="INDEX-2239"></a>
Another use of symbol tables is for making "constant" scalars:
<blockquote>
<pre class="programlisting">*PI = \3.14159265358979;</pre>
</blockquote>
<a name="INDEX-2240"></a><a name="INDEX-2241"></a>
Now you cannot alter <tt class="literal">$PI</tt>, which is probably a good
thing, all in all.  This isn't the same as a constant subroutine,
which is optimized at compile time.  A constant subroutine is one
prototyped to take no arguments and to return a constant expression;
see <a href="ch06_04.htm#ch06-sect-icf">Section 10.4.1, "Inlining Constant Functions"</a> in <a href="ch06_01.htm">Chapter 6, "Subroutines"</a>, for details.  The <tt class="literal">use
constant</tt> pragma (see <a href="ch31_01.htm">Chapter 31, "Pragmatic Modules"</a>) is a convenient shorthand:
<blockquote>
<pre class="programlisting">use constant PI =&gt; 3.14159;</pre>
</blockquote>

Under the hood, this uses the subroutine slot of
<tt class="literal">*PI</tt>, instead of the scalar slot used earlier.  It's
equivalent to the more compact (but less readable):
<blockquote>
<pre class="programlisting">*PI = sub () { 3.14159 };</pre>
</blockquote>

That's a handy idiom to know anyway--assigning a <tt class="literal">sub
{}</tt> to a typeglob is the way to give a name to an anonymous
subroutine at run time.</p>

<p>
<a name="INDEX-2242"></a><a name="INDEX-2243"></a>
Assigning a typeglob reference to another typeglob (<tt class="literal">*sym =
\*oldvar</tt>) is the same as assigning the entire typeglob,
because Perl automatically dereferences the typeglob reference for
you.  And when you set a typeglob to a simple string, you get the
entire typeglob named by that string, because Perl looks up the string
in the current symbol table.  The following are all equivalent to one
another, though the first two compute the symbol table entry at
compile time, while the last two do so at run time:
<blockquote>
<pre class="programlisting">*sym =   *oldvar;
*sym =  \*oldvar;       # autodereference
*sym = *{"oldvar"};     # explicit symbol table lookup
*sym =   "oldvar";      # implicit symbol table lookup</pre>
</blockquote>

When you perform any of the following assignments, you're replacing just
one of the references within the typeglob:
<blockquote>
<pre class="programlisting">*sym = \$frodo;
*sym = \@sam;
*sym = \%merry;
*sym = \&amp;pippin;</pre>
</blockquote>

If you think about it sideways, the typeglob itself can be viewed as a
kind of hash, with entries for the different variable types in it.  In
this case, the keys are fixed, since a typeglob can contain exactly one
scalar, one array, one hash, and so on.  But you can pull out the
individual references, like this:
<blockquote>
<pre class="programlisting">*pkg::sym{SCALAR}      # same as \$pkg::sym
*pkg::sym{ARRAY}       # same as \@pkg::sym
*pkg::sym{HASH}        # same as \%pkg::sym
*pkg::sym{CODE}        # same as \&amp;pkg::sym
*pkg::sym{GLOB}        # same as \*pkg::sym
*pkg::sym{IO}          # internal file/dir handle, no direct equivalent
*pkg::sym{NAME}        # "sym" (not a reference)
*pkg::sym{PACKAGE}     # "pkg" (not a reference)</pre>
</blockquote>

You can say <tt class="literal">*foo{PACKAGE}</tt> and
<tt class="literal">*foo{NAME}</tt> to find out what name and package the
<tt class="literal">*foo</tt> symbol table entry comes from.  This may be
useful in a subroutine that is passed typeglobs as arguments:
<blockquote>
<pre class="programlisting">sub identify_typeglob {
    my $glob = shift;
    print 'You gave me ', *{$glob}{PACKAGE}, '::', *{$glob}{NAME}, "\n";
}

identify_typeglob(*foo);
identify_typeglob(*bar::glarch);</pre>
</blockquote>

This prints:
<blockquote>
<pre class="programlisting">You gave me main::foo
You gave me bar::glarch</pre>
</blockquote>

The
<tt class="literal">*foo{</tt><em class="replaceable">THING</em><tt class="literal">}</tt>
notation can be used to obtain references to individual elements of
<tt class="literal">*foo</tt>.  See the section <a href="ch08_02.htm#ch08-sect-str">Section 10.2.5, "Symbol Table References"</a> in
<a href="ch08_01.htm">Chapter 8, "References"</a> for details.</p>

<p>This syntax is primarily used to get at the internal filehandle or
directory handle reference, because the other internal references are
already accessible in other ways.  (The old
<tt class="literal">*foo{FILEHANDLE}</tt> is still supported to mean
<tt class="literal">*foo{IO}</tt>, but don't let its name fool you into
thinking it can distinguish filehandles from directory handles.)  But
we thought we'd generalize it because it looks kind of pretty.  Sort
of.  You probably don't need to remember all this unless you're
planning to write another Perl debugger.</p>

<a name="INDEX-2244"></a><a name="INDEX-2245"></a><a name="INDEX-2246"></a>


















<a name="INDEX-2267"></a>


<!-- 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="ch09_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="ch10_02.htm"><img src="../gifs/txtnexta.gif" alt="Next" border="0"></a></td>
</tr>
<tr>
<td align="left" valign="top" width="172">9.7. Saving Data Structures</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">10.2. Autoloading</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>