ch08_03.htm

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

* % &amp;</tt>) effectively bind more tightly than braces or
brackets.<a href="#FOOTNOTE-5">[5]</a> Therefore, it is
<tt class="literal">$$listref</tt> and not <tt class="literal">$listref[2]</tt>
that is taken to be a

reference

to an array. If you want the C behavior, either you have to write
<tt class="literal">${$listref[2]}</tt>
to force the <tt class="literal">$listref[2]</tt> to get evaluated before
the leading <tt class="literal">$</tt> dereferencer, or you have to use the
<tt class="literal">-&gt;</tt> notation:
<blockquote>
<pre class="programlisting">$listref[2]-&gt;[$greeting] = "hello";</pre>
</blockquote>
</p>
<blockquote class="footnote">

<a name="FOOTNOTE-5"></a>
<p>[5] But not because of operator precedence.  The
funny characters in Perl are not operators in that sense.  Perl's
grammar simply prohibits anything more complicated than a simple
variable or block from following the initial funny character, for
various funny reasons.</p>

</blockquote>






<h3 class="sect2">8.3.4. Using Object Methods</h3>

<a name="INDEX-2016"></a><a name="INDEX-2017"></a><a name="INDEX-2018"></a><a name="INDEX-2019"></a>
<p>If a reference happens to be a reference to an object, then the class
that defines that object probably provides methods to access the
innards of the object, and you should generally stick to those methods
if you're merely using the class (as opposed to implementing it).  In other
words, be nice, and don't treat an object like a regular reference,
even though Perl lets you when you really need to.  Perl does not
enforce encapsulation.  We are not totalitarians here.  We do expect
some basic civility, however.</p>

<p>In return for this civility, you get complete orthogonality between
objects and data structures.  Any data structure can behave as an object
when you want it to.  Or not, when you don't.</p>





<a name="ch08-sect-pseudo"></a>
<h3 class="sect2">8.3.5. Pseudohashes</h3>

<a name="INDEX-2020"></a>
<p>A <em class="emphasis">pseudohash</em> is any reference to an array whose first element is a
reference to a hash.  You can treat the pseudohash reference as either an
array reference (as you would expect) or a hash reference (as you might not expect).  Here's an example of a pseudohash:
<blockquote>
<pre class="programlisting">$john = [ {age =&gt; 1, eyes =&gt; 2, weight =&gt; 3}, 47, "brown", 186 ];</pre>
</blockquote>

The underlying hash in <tt class="literal">$john-&gt;[0]</tt> defines the names (<tt class="literal">"age"</tt>, <tt class="literal">"eyes"</tt>,
<tt class="literal">"weight"</tt>) of the array elements that follow (<tt class="literal">47</tt>, <tt class="literal">"brown"</tt>, <tt class="literal">186</tt>).  Now
you can access an element with both hash and array notations:
<blockquote>
<pre class="programlisting">$john-&gt;{weight}             # Treats $john as a hashref
$john-&gt;[3]                  # Treats $john as an arrayref</pre>
</blockquote>

Pseudohash magic is not deep; it only knows one "trick": how to turn a hash dereference into an array dereference. When adding another element to a
pseudohash, you have to explicitly tell the underlying mapping hash where the element
will reside before you can use the hash notation:
<blockquote>
<pre class="programlisting">$john-&gt;[0]{height} = 4;     # height is to be element 4
$john-&gt;{height} = "tall";   # Or $john-&gt;[4] = "tall"</pre>
</blockquote>

Perl raises an exception if you try to delete a key from a pseudohash,
although you can always delete keys from the mapping hash.  Perl
also raises an exception if you try to access a nonexistent key,

where "existence" means presence in the mapping hash:
<blockquote>
<pre class="programlisting">delete $john-&gt;[0]{height};  # Deletes from the underlying hash only
$john-&gt;{height};            # This now raises an exception
$john-&gt;[4];                 # Still prints "tall"</pre>
</blockquote>

Don't try to splice the array unless you know what you're
doing.  If the array elements move around, the mapping hash values
will still refer to the <em class="emphasis">old</em> element positions, unless you change
those explicitly, too.  Pseudohash magic is not deep.</p>

<p>To avoid inconsistencies, you can use the <tt class="literal">fields::phash</tt> function
provided by the <tt class="literal">use fields</tt> pragma to create a pseudohash:
<blockquote>
<pre class="programlisting">use fields;
$ph = fields::phash(age =&gt; 47, eyes =&gt; "brown", weight =&gt; 186);
print $ph-&gt;{age};</pre>
</blockquote>

There are two ways to check for the existence of a key in a
pseudohash.  The first is to use <tt class="literal">exists</tt>, which checks whether the
given field has ever been set.  It acts this way to match the behavior
of a real hash.  For instance:
<blockquote>
<pre class="programlisting">use fields;
$ph= fields::phash([qw(age eyes brown)], [47]);
$ph-&gt;{eyes} = undef;

print exists $ph-&gt;{age};     # True, 'age' was set in declaration.
print exists $ph-&gt;{weight};  # False, 'weight' has not been used.
print exists $ph-&gt;{eyes};    # True, your 'eyes' have been touched.</pre>
</blockquote>

The second way is to use <tt class="literal">exists</tt> on the mapping hash sitting in the
first array element.  This checks whether the given key is a valid
field for that pseudohash:
<blockquote>
<pre class="programlisting">print exists $ph-&gt;[0]{age};   # True, 'age' is a valid field
print exists $ph-&gt;[0]{name};  # False, 'name' can't be used</pre>
</blockquote>

Unlike what happens in a real hash, calling <tt class="literal">delete</tt> on a pseudohash
element deletes only the array value corresponding to the key, not the
real key in the mapping hash.  To delete the key, you have to
explicitly delete it from the mapping hash.  Once you do that, you may
no longer use that key name as a pseudohash subscript:
<blockquote>
<pre class="programlisting">print delete $ph-&gt;{age};     # Removes and returns $ph-&gt;[1], 47
print exists $ph-&gt;{age};     # Now false
print exists $ph-&gt;[0]{age};  # True, 'age' key still usable
print delete $ph-&gt;[0]{age};  # Now 'age' key is gone
print $ph-&gt;{age};            # Run-time exception</pre>
</blockquote>

You've probably begun to wonder what could possibly have motivated
this masquerade of arrays prancing about in hashes' clothing.  Arrays
provide faster lookups and more efficient storage, while hashes offer the
convenience of naming (instead of numbering) your data;
pseudohashes provide the best of both worlds.  But it's not until you
consider Perl's compilation phase that the greatest benefit becomes
apparent.  With the help of a pragma or two, the compiler can verify
proper access to valid fields, so you can find out about nonexistent
subscripts (or spelling errors) before your program starts to run.</p>

<p>Pseudohashes' properties of speed, efficiency, and compile-time
access checking (you might even think of it as type safety) are
especially handy for creating efficient and robust class modules.
See the discussion of the <tt class="literal">use fields</tt> pragma in <a href="ch12_01.htm">Chapter 12, "Objects"</a> and <a href="ch31_01.htm">Chapter 31, "Pragmatic Modules"</a>.</p>

<p>Pseudohashes are a new and relatively experimental feature; as such,
the underlying implementation may well change in the future.  To
protect yourself from such changes, always go through the <tt class="literal">fields</tt>
module's documented interface via its <tt class="literal">phash</tt> and <tt class="literal">new</tt> functions.</p>





<a name="ch08-sect-tricks"></a>
<h3 class="sect2">8.3.6. Other Tricks You Can Do with Hard References</h3>

<p>As mentioned earlier, the backslash operator is usually used
on a single referent to generate a single reference, but it doesn't have
to be.  When used on a list of referents, it produces a list of
corresponding references.  The second line of the following example does the same thing as the first line, since the backslash
is automatically distributed throughout the whole list.
<blockquote>
<pre class="programlisting">@reflist = (\$s, \@a, \%h, \&amp;f);     # List of four references
@reflist = \($s,  @a   %h,  &amp;f);     # Same thing</pre>
</blockquote>

If a parenthesized list contains exactly one array or hash, then all
of its values are interpolated and references to each returned:
<blockquote>
<pre class="programlisting">@reflist = \(@x);                    # Interpolate array, then get refs
@reflist = map { \$_ } @x;           # Same thing</pre>
</blockquote>

This also occurs when there are internal parentheses:
<blockquote>
<pre class="programlisting">@reflist = \(@x, (@y));              # But only single aggregates expand
@reflist = (\@x, map { \$_ } @y);    # Same thing</pre>
</blockquote>

If you try this with a hash, the result will contain references to
the values (as you'd expect), but references to <em class="emphasis">copies</em> of the keys
(as you might not expect).</p>

<p>Since array and hash slices are really just lists, you can backslash a
slice of either of these to get a list of references.  Each of the
next three lines does exactly the same thing:
<blockquote>
<pre class="programlisting">@envrefs = \@ENV{'HOME', 'TERM'};         # Backslashing a slice
@envrefs = \( $ENV{HOME},  $ENV{TERM} );  # Backslashing a list
@envrefs = ( \$ENV{HOME}, \$ENV{TERM} );  # A list of two references</pre>
</blockquote>

Since functions can return lists, you can apply a backslash to them.
If you have more than one function to call, first interpolate each
function's return values into a larger list and then backslash the
whole thing:
<blockquote>
<pre class="programlisting">@reflist = \fx();
@reflist = map { \$_ } fx();                # Same thing

@reflist = \( fx(), fy(), fz() );
@reflist = ( \fx(), \fy(), \fz() );         # Same thing
@reflist = map { \$_ } fx(), fy(), fz();    # Same thing</pre>
</blockquote>
<a name="INDEX-2021"></a>
The backslash operator always supplies a list context to its operand,
so those functions are all called in list context.  If the backslash
is itself in scalar context, you'll end up with a reference to the
last value of the list returned by the function:
<blockquote>
<pre class="programlisting">@reflist = \localtime();      # Ref to each of nine time elements
$lastref = \localtime();      # Ref to whether it's daylight savings time</pre>
</blockquote>

In this regard, the backslash behaves like the named Perl list
operators, such as <tt class="literal">print</tt>, <tt class="literal">reverse</tt>, and <tt class="literal">sort</tt>, which always
supply a list context on their right no matter what might be happening
on their left.  As with named list operators, use an explicit
<tt class="literal">scalar</tt> to force what follows into scalar context:
<blockquote>
<pre class="programlisting">$dateref = \scalar localtime();    # \"Sat Jul 16 11:42:18 2000"</pre>
</blockquote>
<a name="INDEX-2022"></a>
</p>

<p>You can use the <tt class="literal">ref</tt> operator to determine what a reference is
pointing to.  Think of <tt class="literal">ref</tt> as a "typeof" operator that returns true
if its argument is a reference and false otherwise.  The value
returned depends on the type of thing referenced. Built-in types
include <tt class="literal">SCALAR</tt>, <tt class="literal">ARRAY</tt>, <tt class="literal">HASH</tt>, <tt class="literal">CODE</tt>, <tt class="literal">GLOB</tt>, <tt class="literal">REF</tt>,
<tt class="literal">LVALUE</tt>, <tt class="literal">IO</tt>, <tt class="literal">IO::Handle</tt>, and <tt class="literal">Regexp</tt>.  Here, we use
it to check subroutine arguments:
<blockquote>
<pre class="programlisting">sub sum {
    my $arrayref = shift;
    warn "Not an array reference" if ref($arrayref) ne "ARRAY";
    return eval join("+", @$arrayref);
}</pre>
</blockquote>
<a name="INDEX-2023"></a><a name="INDEX-2024"></a>
</p>

<p>If you use a hard reference in a string context, it'll be converted to
a string containing both the type and the address:
<tt class="literal">SCALAR(0x1fc0e)</tt>. (The reverse conversion cannot be done, since
reference count information is lost during stringification--and also
because it would be dangerous to let programs access a memory address
named by an arbitrary string.)</p>

<p>
<a name="INDEX-2025"></a><a name="INDEX-2026"></a><a name="INDEX-2027"></a>
You can use the <tt class="literal">bless</tt> operator to associate a referent with a
package functioning as an object class.  When you do this, <tt class="literal">ref</tt>
returns the class name instead of the internal type.  An object
reference used in a string context returns a string with the external
and internal types, and the address in memory:
<tt class="literal">MyType=HASH(0x20d10)</tt> or <tt class="literal">IO::Handle=IO(0x186904)</tt>.  See <a href="ch12_01.htm">Chapter 12, "Objects"</a> for more details about objects.</p>

<p>
<a name="INDEX-2028"></a><a name="INDEX-2029"></a>
Since the way in which you dereference something always indicates what
sort of referent you're looking for, a typeglob can be used the same
way a reference can, despite the fact that a typeglob contains
multiple referents of various types.  So <tt class="literal">${*main::foo}</tt> and <tt class="literal">${\$main::foo}</tt>
both access the same scalar variable, although the latter is more
efficient.</p>

<p>
<a name="INDEX-2030"></a>
Here's a trick for interpolating the return value of a subroutine call
into a string:
<blockquote>
<pre class="programlisting">print "My sub returned @{[ mysub(1,2,3) ]} that time.\n";</pre>
</blockquote>

It works like this.  At compile time, when the <tt class="literal">@{...}</tt> is seen
within the double-quoted string, it's parsed as a block that returns
a reference.  Within the block, there are square brackets that
create a reference to an anonymous array from whatever is in the
brackets.  So at run time, <tt class="literal">mysub(1,2,3)</tt> is called in list context,
and the results are loaded into an anonymous array, a reference to
which is then returned within the block.  That array reference is
then immediately dereferenced by the surrounding <tt class="literal">@{...}</tt>, and the
array value is interpolated into the double-quoted string just as
an ordinary array would be.  This chicanery is also useful for
arbitrary expressions, such as: