It doesn't magically start being an array or hash or subroutine; you have to
tell it explicitly to do so, by dereferencing it.
-That said, be aware that Perl version 5.14 introduces an exception
-to the rule, for syntactic convenience. Experimental array and hash container
-function behavior allows array and hash references to be handled by Perl as
-if they had been explicitly syntactically dereferenced. See
-L<perl5140delta/"Syntactical Enhancements">
-and L<perlfunc> for details.
-
=head2 Making References
X<reference, creation> X<referencing>
References can be created in several ways.
-=over 4
-
-=item 1.
+=head3 Backslash Operator
X<\> X<backslash>
By using the backslash operator on a variable, subroutine, or value.
-(This works much like the & (address-of) operator in C.)
+(This works much like the & (address-of) operator in C.)
This typically creates I<another> reference to a variable, because
there's already a reference to the variable in the symbol table. But
the symbol table reference might go away, and you'll still have the
But see the explanation of the C<*foo{THING}> syntax below. However,
you can still use type globs and globrefs as though they were IO handles.
-=item 2.
+=head3 Square Brackets
X<array, anonymous> X<[> X<[]> X<square bracket>
X<bracket, square> X<arrayref> X<array reference> X<reference, array>
a list of references!
@list = (\$a, \@b, \%c);
- @list = \($a, @b, %c); # same thing!
+ @list = \($a, @b, %c); # same thing!
As a special case, C<\(@foo)> returns a list of references to the contents
of C<@foo>, not a reference to C<@foo> itself. Likewise for C<%foo>,
except that the key references are to copies (since the keys are just
strings rather than full-fledged scalars).
-=item 3.
+=head3 Curly Brackets
X<hash, anonymous> X<{> X<{}> X<curly bracket>
X<bracket, curly> X<brace> X<hashref> X<hash reference> X<reference, hash>
brackets:
$hashref = {
- 'Adam' => 'Eve',
- 'Clyde' => 'Bonnie',
+ 'Adam' => 'Eve',
+ 'Clyde' => 'Bonnie',
};
Anonymous hash and array composers like these can be intermixed freely to
The leading C<+{> and C<{;> always serve to disambiguate
the expression to mean either the HASH reference, or the BLOCK.
-=item 4.
+=head3 Anonymous Subroutines
X<subroutine, anonymous> X<subroutine, reference> X<reference, subroutine>
X<scope, lexical> X<closure> X<lexical> X<lexical scope>
closures work:
sub newprint {
- my $x = shift;
- return sub { my $y = shift; print "$x, $y!\n"; };
+ my $x = shift;
+ return sub { my $y = shift; print "$x, $y!\n"; };
}
$h = newprint("Howdy");
$g = newprint("Greetings");
continue to work as they have always worked. Closure is not something
that most Perl programmers need trouble themselves about to begin with.
-=item 5.
+=head3 Constructors
X<constructor> X<new>
References are often returned by special subroutines called constructors. Perl
$menubar = $main->Frame(-relief => "raised",
-borderwidth => 2)
-=item 6.
+This indirect object syntax is only available when
+L<C<use feature "indirect">|feature/The 'indirect' feature> is in effect,
+and that is not the case when L<C<use v5.36>|perlfunc/use VERSION> (or
+higher) is requested, it is best to avoid indirect object syntax entirely.
+
+=head3 Autovivification
X<autovivification>
References of the appropriate type can spring into existence if you
dereference them in a context that assumes they exist. Because we haven't
talked about dereferencing yet, we can't show you any examples yet.
-=item 7.
+=head3 Typeglob Slots
X<*foo{THING}> X<*>
A reference can be created by using a special syntax, lovingly known as
(L<perlfunc/socket> and L<perlfunc/socketpair>), and directory
handles (L<perlfunc/opendir>). For compatibility with previous
versions of Perl, C<*foo{FILEHANDLE}> is a synonym for C<*foo{IO}>, though it
-is deprecated as of 5.8.0. If deprecation warnings are in effect, it will warn
-of its use.
+is discouraged, to encourage a consistent use of one name: IO. On perls
+between v5.8 and v5.22, it will issue a deprecation warning, but this
+deprecation has since been rescinded.
C<*foo{THING}> returns undef if that particular THING hasn't been used yet,
except in the case of scalars. C<*foo{SCALAR}> returns a reference to an
value to a scalar instead of a typeglob as we do in the examples
below, there's no risk of that happening.
- splutter(*STDOUT); # pass the whole glob
- splutter(*STDOUT{IO}); # pass both file and dir handles
+ splutter(*STDOUT); # pass the whole glob
+ splutter(*STDOUT{IO}); # pass both file and dir handles
sub splutter {
- my $fh = shift;
- print $fh "her um well a hmmm\n";
+ my $fh = shift;
+ print $fh "her um well a hmmm\n";
}
- $rec = get_rec(*STDIN); # pass the whole glob
+ $rec = get_rec(*STDIN); # pass the whole glob
$rec = get_rec(*STDIN{IO}); # pass both file and dir handles
sub get_rec {
- my $fh = shift;
- return scalar <$fh>;
+ my $fh = shift;
+ return scalar <$fh>;
}
-=back
-
=head2 Using References
X<reference, use> X<dereferencing> X<dereference>
know how to use references to get back to your long-lost data. There
are several basic methods.
-=over 4
-
-=item 1.
+=head3 Simple Scalar
Anywhere you'd put an identifier (or chain of identifiers) as part
of a variable or subroutine name, you can replace the identifier with
$refrefref = \\\"howdy";
print $$$$refrefref;
-=item 2.
+=head3 Block
Anywhere you'd put an identifier (or chain of identifiers) as part of a
variable or subroutine name, you can replace the identifier with a
the BLOCK can contain any arbitrary expression, in particular,
subscripted expressions:
- &{ $dispatch{$index} }(1,2,3); # call correct routine
+ &{ $dispatch{$index} }(1,2,3); # call correct routine
Because of being able to omit the curlies for the simple case of C<$$x>,
people often make the mistake of viewing the dereferencing symbols as
Consider the difference below; case 0 is a short-hand version of case 1,
I<not> case 2:
- $$hashref{"KEY"} = "VALUE"; # CASE 0
- ${$hashref}{"KEY"} = "VALUE"; # CASE 1
- ${$hashref{"KEY"}} = "VALUE"; # CASE 2
- ${$hashref->{"KEY"}} = "VALUE"; # CASE 3
+ $$hashref{"KEY"} = "VALUE"; # CASE 0
+ ${$hashref}{"KEY"} = "VALUE"; # CASE 1
+ ${$hashref{"KEY"}} = "VALUE"; # CASE 2
+ ${$hashref->{"KEY"}} = "VALUE"; # CASE 3
Case 2 is also deceptive in that you're accessing a variable
called %hashref, not dereferencing through $hashref to the hash
it's presumably referencing. That would be case 3.
-=item 3.
+=head3 Arrow Notation
Subroutine calls and lookups of individual array elements arise often
enough that it gets cumbersome to use method 2. As a form of
Well, okay, not entirely like C's arrays, actually. C doesn't know how
to grow its arrays on demand. Perl does.
-=item 4.
+=head3 Objects
If a reference happens to be a reference to an object, then there are
probably methods to access the things referred to, and you should probably
encapsulation. We are not totalitarians here. We do expect some basic
civility though.
-=back
+=head3 Miscellaneous Usage
Using a string or number as a reference produces a symbolic reference,
as explained above. Using a reference as a number produces an
X<reference, numeric context>
if ($ref1 == $ref2) { # cheap numeric compare of references
- print "refs 1 and 2 refer to the same thing\n";
+ print "refs 1 and 2 refer to the same thing\n";
}
Using a reference as a string produces both its referent's type,
weak reference does not increment the reference count for a variable,
which means that the object can go out of scope and be destroyed. You
can weaken a reference with the C<weaken> function exported by the
-L<Scalar::Util> module.
+L<Scalar::Util> module, or available as C<builtin::weaken> directly in
+Perl version 5.35.7 or later.
Here's how we can make the first example safer:
People frequently expect it to work like this. So it does.
$name = "foo";
- $$name = 1; # Sets $foo
- ${$name} = 2; # Sets $foo
- ${$name x 2} = 3; # Sets $foofoo
- $name->[0] = 4; # Sets $foo[0]
- @$name = (); # Clears @foo
- &$name(); # Calls &foo()
+ $$name = 1; # Sets $foo
+ ${$name} = 2; # Sets $foo
+ ${$name x 2} = 3; # Sets $foofoo
+ $name->[0] = 4; # Sets $foo[0]
+ @$name = (); # Clears @foo
+ &$name(); # Calls &foo()
$pack = "THAT";
- ${"${pack}::$name"} = 5; # Sets $THAT::foo without eval
+ ${"${pack}::$name"} = 5; # Sets $THAT::foo without eval
This is powerful, and slightly dangerous, in that it's possible
to intend (with the utmost sincerity) to use a hard reference, and
local $value = 10;
$ref = "value";
{
- my $value = 20;
- print $$ref;
+ my $value = 20;
+ print $$ref;
}
This will still print 10, not 20. Remember that local() affects package
using strict refs:
use strict 'refs';
- ${ bareword }; # Okay, means $bareword.
- ${ "bareword" }; # Error, symbolic reference.
+ ${ bareword }; # Okay, means $bareword.
+ ${ "bareword" }; # Error, symbolic reference.
Similarly, because of all the subscripting that is done using single words,
the same rule applies to any bareword that is used for subscripting a hash.
So now, instead of writing
- $array{ "aaa" }{ "bbb" }{ "ccc" }
+ $hash{ "aaa" }{ "bbb" }{ "ccc" }
you can write just
- $array{ aaa }{ bbb }{ ccc }
+ $hash{ aaa }{ bbb }{ ccc }
and not worry about whether the subscripts are reserved words. In the
rare event that you do wish to do something like
- $array{ shift }
+ $hash{ shift }
you can force interpretation as a reserved word by adding anything that
makes it more than a bareword:
- $array{ shift() }
- $array{ +shift }
- $array{ shift @_ }
+ $hash{ shift() }
+ $hash{ +shift }
+ $hash{ shift @_ }
The C<use warnings> pragma or the B<-w> switch will warn you if it
interprets a reserved word as a string.
The red() and green() functions would be similar. To create these,
we'll assign a closure to a typeglob of the name of the function we're
-trying to build.
+trying to build.
@colors = qw(red blue green yellow orange purple violet);
for my $name (@colors) {
- no strict 'refs'; # allow symbol table manipulation
+ no strict 'refs'; # allow symbol table manipulation
*$name = *{uc $name} = sub { "<FONT COLOR='$name'>@_</FONT>" };
- }
+ }
Now all those different functions appear to exist independently. You can
call red(), RED(), blue(), BLUE(), green(), etc. This technique saves on
nested subroutines in other programming languages with their own private
variables, you'll have to work at it a bit in Perl. The intuitive coding
of this type of thing incurs mysterious warnings about "will not stay
-shared" due to the reasons explained above.
+shared" due to the reasons explained above.
For example, this won't work:
sub outer {
This has the interesting effect of creating a function local to another
function, something not normally supported in Perl.
-=head1 WARNING
-X<reference, string context> X<reference, use as hash key>
-
-You may not (usefully) use a reference as the key to a hash. It will be
-converted into a string:
-
- $x{ \$a } = $a;
-
-If you try to dereference the key, it won't do a hard dereference, and
-you won't accomplish what you're attempting. You might want to do something
-more like
-
- $r = \@a;
- $x{ $r } = $r;
-
-And then at least you can use the values(), which will be
-real refs, instead of the keys(), which won't.
-
-The standard Tie::RefHash module provides a convenient workaround to this.
-
-=head1 Postfix Dereference Syntax
+=head2 Postfix Dereference Syntax
Beginning in v5.20.0, a postfix syntax for using references is
available. It behaves as described in L</Using References>, but instead
$r = [ 1, [ 2, 3 ], 4 ];
$r->[1]->@*; # equivalent to @{ $r->[1] }
-This syntax must be enabled with C<use feature 'postderef'>. It is
-experimental, and will warn by default unless C<no warnings
-'experimental::postderef'> is in effect.
+In Perl 5.20 and 5.22, this syntax must be enabled with C<use feature
+'postderef'>. As of Perl 5.24, no feature declarations are required to make
+it available.
Postfix dereference should work in all circumstances where block
(circumfix) dereference worked, and should be entirely equivalent. This
syntax allows dereferencing to be written and read entirely
left-to-right. The following equivalencies are defined:
- $sref->$*; # same as ${ $sref }
- $aref->@*; # same as @{ $aref }
- $href->%*; # same as %{ $href }
- $cref->&*; # same as &{ $cref }
- $gref->&*; # same as *{ $cref }
+ $sref->$*; # same as ${ $sref }
+ $aref->@*; # same as @{ $aref }
+ $aref->$#*; # same as $#{ $aref }
+ $href->%*; # same as %{ $href }
+ $cref->&*; # same as &{ $cref }
+ $gref->**; # same as *{ $gref }
Note especially that C<< $cref->&* >> is I<not> equivalent to C<<
$cref->() >>, and can serve different purposes.
Postfix array and scalar dereferencing I<can> be used in interpolating
strings (double quotes or the C<qq> operator), but only if the
-
additional C<postderef_qq> feature is enabled.
+C<postderef_qq> feature is enabled.
=head2 Postfix Reference Slicing
As with postfix array, postfix value slice dereferencing I<can> be used
in interpolating strings (double quotes or the C<qq> operator), but only
-if the additional C<postderef_qq> L<feature> is enabled.
+if the C<postderef_qq> L<feature> is enabled.
+
+=head2 Assigning to References
+
+Beginning in v5.22.0, the referencing operator can be assigned to. It
+performs an aliasing operation, so that the variable name referenced on the
+left-hand side becomes an alias for the thing referenced on the right-hand
+side:
+
+ \$a = \$b; # $a and $b now point to the same scalar
+ \&foo = \&bar; # foo() now means bar()
+
+This syntax must be enabled with C<use feature 'refaliasing'>. It is
+experimental, and will warn by default unless C<no warnings
+'experimental::refaliasing'> is in effect.
+
+These forms may be assigned to, and cause the right-hand side to be
+evaluated in scalar context:
+
+ \$scalar
+ \@array
+ \%hash
+ \&sub
+ \my $scalar
+ \my @array
+ \my %hash
+ \state $scalar # or @array, etc.
+ \our $scalar # etc.
+ \local $scalar # etc.
+ \local our $scalar # etc.
+ \$some_array[$index]
+ \$some_hash{$key}
+ \local $some_array[$index]
+ \local $some_hash{$key}
+ condition ? \$this : \$that[0] # etc.
+
+Slicing operations and parentheses cause
+the right-hand side to be evaluated in
+list context:
+
+ \@array[5..7]
+ (\@array[5..7])
+ \(@array[5..7])
+ \@hash{'foo','bar'}
+ (\@hash{'foo','bar'})
+ \(@hash{'foo','bar'})
+ (\$scalar)
+ \($scalar)
+ \(my $scalar)
+ \my($scalar)
+ (\@array)
+ (\%hash)
+ (\&sub)
+ \(&sub)
+ \($foo, @bar, %baz)
+ (\$foo, \@bar, \%baz)
+
+Each element on the right-hand side must be a reference to a datum of the
+right type. Parentheses immediately surrounding an array (and possibly
+also C<my>/C<state>/C<our>/C<local>) will make each element of the array an
+alias to the corresponding scalar referenced on the right-hand side:
+
+ \(@a) = \(@b); # @a and @b now have the same elements
+ \my(@a) = \(@b); # likewise
+ \(my @a) = \(@b); # likewise
+ push @a, 3; # but now @a has an extra element that @b lacks
+ \(@a) = (\$a, \$b, \$c); # @a now contains $a, $b, and $c
+
+Combining that form with C<local> and putting parentheses immediately
+around a hash are forbidden (because it is not clear what they should do):
+
+ \local(@array) = foo(); # WRONG
+ \(%hash) = bar(); # WRONG
+
+Assignment to references and non-references may be combined in lists and
+conditional ternary expressions, as long as the values on the right-hand
+side are the right type for each element on the left, though this may make
+for obfuscated code:
+
+ (my $tom, \my $dick, \my @harry) = (\1, \2, [1..3]);
+ # $tom is now \1
+ # $dick is now 2 (read-only)
+ # @harry is (1,2,3)
+
+ my $type = ref $thingy;
+ ($type ? $type eq 'ARRAY' ? \@foo : \$bar : $baz) = $thingy;
+
+The C<foreach> loop can also take a reference constructor for its loop
+variable, though the syntax is limited to one of the following, with an
+optional C<my>, C<state>, or C<our> after the backslash:
+
+ \$s
+ \@a
+ \%h
+ \&c
+
+No parentheses are permitted. This feature is particularly useful for
+arrays-of-arrays, or arrays-of-hashes:
+
+ foreach \my @a (@array_of_arrays) {
+ frobnicate($a[0], $a[-1]);
+ }
+
+ foreach \my %h (@array_of_hashes) {
+ $h{gelastic}++ if $h{type} eq 'funny';
+ }
+
+B<CAVEAT:> Aliasing does not work correctly with closures. If you try to
+alias lexical variables from an inner subroutine or C<eval>, the aliasing
+will only be visible within that inner sub, and will not affect the outer
+subroutine where the variables are declared. This bizarre behavior is
+subject to change.
+
+=head2 Declaring a Reference to a Variable
+
+Beginning in v5.26.0, the referencing operator can come after C<my>,
+C<state>, C<our>, or C<local>. This syntax must be enabled with C<use
+feature 'declared_refs'>. It is experimental, and will warn by default
+unless C<no warnings 'experimental::refaliasing'> is in effect.
+
+This feature makes these:
+
+ my \$x;
+ our \$y;
+
+equivalent to:
+
+ \my $x;
+ \our $x;
+
+It is intended mainly for use in assignments to references (see
+L</Assigning to References>, above). It also allows the backslash to be
+used on just some items in a list of declared variables:
+
+ my ($foo, \@bar, \%baz); # equivalent to: my $foo, \my(@bar, %baz);
+
+=head1 WARNING: Don't use references as hash keys
+X<reference, string context> X<reference, use as hash key>
+
+You may not (usefully) use a reference as the key to a hash. It will be
+converted into a string:
+
+ $x{ \$a } = $a;
+
+If you try to dereference the key, it won't do a hard dereference, and
+you won't accomplish what you're attempting. You might want to do something
+more like
+
+ $r = \@a;
+ $x{ $r } = $r;
+
+And then at least you can use the values(), which will be
+real refs, instead of the keys(), which won't.
+
+The standard Tie::RefHash module provides a convenient workaround to this.
=head1 SEE ALSO
https://perl5.git.perl.org / perl5.git / blobdiff