B<Make Rule 2>
C<[ ITEMS ]> makes a new, anonymous array, and returns a reference to
-that array. C<{ ITEMS }> makes a new, anonymous hash. and returns a
+that array. C<{ ITEMS }> makes a new, anonymous hash, and returns a
reference to that hash.
$aref = [ 1, "foo", undef, 13 ];
On each line are two expressions that do the same thing. The
-left-hand versions operate on the array C<@a>, and the right-hand
-versions operate on the array that is referred to by C<$aref>, but
-once they find the array they're operating on, they do the same things
-to the arrays.
+left-hand versions operate on the array C<@a>. The right-hand
+versions operate on the array that is referred to by C<$aref>. Once
+they find the array they're operating on, both versions do the same
+things to the arrays.
Using a hash reference is I<exactly> the same:
We'll look at output first. Supposing we already have this structure,
how do we print it out?
+ 8 foreach $country (sort keys %table) {
+ 9 print "$country: ";
+ 10 my @cities = @{$table{$country}};
+ 11 print join ', ', sort @cities;
+ 12 print ".\n";
+ 13 }
+
C<%table> is an
ordinary hash, and we get a list of keys from it, sort the keys, and
loop over the keys as usual. The only use of references is in line 10.
out as usual.
Lines 2-7 are responsible for building the structure in the first
-place; here they are again:
+place. Here they are again:
2 while (<>) {
3 chomp;
=item *
-In B<USE RULE 1>, you can omit the curly brackets whenever the thing
+In B<Use Rule 1>, you can omit the curly brackets whenever the thing
inside them is an atomic scalar variable like C<$aref>. For example,
C<@$aref> is the same as C<@{$aref}>, and C<$$aref[1]> is the same as
C<${$aref}[1]>. If you're just starting out, you may want to adopt
Similarly, to copy an anonymous hash, you can use
- $href = {%{$href}};
+ $href2 = {%{$href1}};
=item *
-To see if a variable contains a reference, use the `ref' function. It
+To see if a variable contains a reference, use the C<ref> function. It
returns true if its argument is a reference. Actually it's a little
better than that: It returns C<HASH> for hash references and C<ARRAY>
for array references.
You can use a string as if it were a reference. If you use the string
C<"foo"> as an array reference, it's taken to be a reference to the
-array C<@foo>. This is called a I<soft reference> or I<symbolic reference>.
+array C<@foo>. This is called a I<soft reference> or I<symbolic
+reference>. The declaration C<use strict 'refs'> disables this
+feature, which can cause all sorts of trouble if you use it by accident.
=back
=head1 Credits
-Author: Mark-Jason Dominus, Plover Systems (C<mjd-perl-ref+@plover.com>)
+Author: Mark Jason Dominus, Plover Systems (C<mjd-perl-ref+@plover.com>)
This article originally appeared in I<The Perl Journal>
( http://www.tpj.com/ ) volume 3, #2. Reprinted with permission.
Copyright 1998 The Perl Journal.
-When included as part of the Standard Version of Perl, or as part of
-its complete documentation whether printed or otherwise, this work may
-be distributed only under the terms of Perl's Artistic License. Any
-distribution of this file or derivatives thereof outside of that
-package require that special arrangements be made with copyright
-holder.
+This documentation is free; you can redistribute it and/or modify it
+under the same terms as Perl itself.
Irrespective of its distribution, all code examples in these files are
hereby placed into the public domain. You are permitted and
projects / p5sagit/p5-mst-13.2.git / blobdiff