Perl Cd Bookshelf [Electronic resources] نسخه متنی

11.4.1. Problem

To get a code reference:

$cref = \&func;
$cref = sub { ... };

To call a code reference:

@returned = $cref->(@arguments);
@returned = &$cref(@arguments);

If the name of a function is func, you can produce
a reference to it by prefixing its name with
\&. You can also dynamically allocate
anonymous functions using the sub {
} notation. These code references can be stored just like
any other reference.

It is possible to store the name of a function in a variable, such as:

$funcname = "thefunc";
&$funcname( );

but that's not a very good solution for several reasons. First, it
uses symbolic references, not real (hard) references, and so is
forbidden under the use strict
"refs" pragma. Symbolic references to variables
are usually a bad idea, since they can't access lexical variables,
only globals, and aren't reference counted. Second, as written it
doesn't include package information, so if executed in a different
package, it would try to call the wrong function. Finally, in the odd
case that the function were redefined at some point, the symbolic
reference would get whatever the current definition for the function
was, whereas the hard reference would still access the old
definition.

Instead of placing the name of the function in the variable, use the
backslash operator to create a reference to the function. This is the
normal way to store a function in a variable or pass along to another
function. You can mix and match references to named functions with
references to unnamed ones:

my %commands = (
"happy" => \&joy,
"sad" => \&sullen,
"done" => sub { die "See ya!" },
"mad" => \&angry,
);
print "How are you? ";
chomp($string = <STDIN>);
if ($commands{$string}) {
$commands{$string}->( );
} else {
print "No such command: $string\n";
}

If you create an anonymous function that refers to a lexical
(my) variable from an enclosing scope, reference
counting ensures that the lexical variable is never deallocated so
long as that function reference exists:

sub counter_maker {
my $start = 0;
return sub { # this is a closure
return $start++; # lexical from enclosing scope
};
}
$counter = counter_maker( );
for ($i = 0; $i < 5; $i ++) {
print &$counter, "\n";
}

Even though counter_maker has ended and
$start gone out of scope, Perl doesn't free the
variable, because the anonymous subroutine referenced by
$counter still has a reference to
$start. If we call
counter_maker again, it'll return another,
different anonymous subroutine reference that uses a
different $start:

$counter1 = counter_maker( );
$counter2 = counter_maker( );
for ($i = 0; $i < 5; $i ++) {
print &$counter1, "\n";
}
print &$counter1, " ", &$counter2, "\n";
1
2
3
4
5 0