How can I elegantly call a Perl subroutine whose name is held in a variable?

Question

I keep the name of the subroutine I want to call at runtime in a variable called $action. Then I use this to call that sub at the right time:

&{\&{$action}}();

Works fine. The only thing I don't like is that it's ugly and every time I do it, I feel beholden to add a comment for the next developer:

# call the sub by the name of $action

Anyone know a prettier way of doing this?

---

UPDATE: The idea here was to avoid having to maintain a dispatch table every time I added a new callable sub, since I am the sole developer, I'm not worried about other programmers following or not following the 'rules'. Sacrificing a bit of security for my convenience. Instead my dispatch module would check $action to make sure that 1) it is the name of a defined subroutine and not malicious code to run with eval, and 2) that it wouldn't run any sub prefaced by an underscore, which would be marked as internal-only subs by this naming convention.

Any thoughts on this approach? Whitelisting subroutines in the dispatch table is something I will forget all the time, and my clients would rather me err on the side of "it works" than "it's wicked secure". (very limited time to develop apps)

---

FINAL UPDATE: I think I've decided on a dispatch table after all. Although I'd be curious if anyone who reads this question has ever tried to do away with one and how they did it, I have to bow to the collective wisdom here. Thanks to all, many great responses.

Tevere

Realize that when you take a reference to something to immediately dereference it, you can skip the middle steps. :) – Marksman

@brian: usually (and definitely in this case), but see #1836678 for a counter-example. :) – Ramillies

A dispatch table also means you can use strict, which is generally a good thing. – Traipse

Answer 1

Rather than storing subroutine names in a variable and calling them, a better way to do this is to use a hash of subroutine references (otherwise known as a dispatch table.)

my %actions = ( foo => \&foo,
                bar => \&bar,
                baz => sub { print 'baz!' } 
                ... 
              );

Then you can call the right one easily:

$actions{$action}->();

You can also add some checking to make sure $action is a valid key in the hash, and so forth.

In general, you should avoid symbolic references (what you're doing now) as they cause all kinds of problems. In addition, using real subroutine references will work with strict turned on.

Hushaby

I've repeated my comment here from another answer below, as this answer has by far the highest score! in case it helps anyone, if you also want to pass parameters to the subroutine, you just put them in between the () - i.e. the same as you would to a normal sub. e.g. $actions{$action}->($parmVariable,11,'a'); The parameters would have to be consistent across all the possible sub-routines being called, though the values can come from variables of course. – Sparks

Answer 2

Just &$action(), but usually it's nicer to use coderefs from the beginning, or use a dispatcher hash. For example:

my $disp = {foo => \&some_sub, bar => \&some_other_sub };
$disp->{'foo'}->();

Bambino

Using the &$action solution I get: Can't use string ("main::instructors") as a subroutine ref while "strict refs". So are the gymnastics I am doing only because I have strict turned on? – Tevere

Yes, this kind of usage is what 'use strict' prevents (among others). Use 'no strict "refs"' to allow it, but again, real references or dispatchers are ususally much clearer. – Bambino

The dispatch table answer, which uses real (as opposed to symbolic) references, will of course work with strict turned on, which is another advantage of doing it that way. – Hushaby

use strict qw(vars subs) is a shorter way to say use strict; no strict 'refs'; – Mccubbin

@mobrule: until someone adds a fourth category of stricture, that is :) – Ramillies

Answer 3

Huh? You can just say

    $action->()

Example:

    sub f { return 11 }
    $action = 'f';
    print $action->();


    $ perl subfromscalar.pl
    11

Constructions like

    'f'->()     # equivalent to   &f()

also work.

Mccubbin

If you use strict (and of course you do), you'll need to say no strict 'refs' or just use strict qw(vars subs) to use this syntax. – Mccubbin

Answer 4

I'm not sure I understand what you mean. (I think this is another in a recent group of "How can I use a variable as a variable name?" questions, but maybe not.)

In any case, you should be able to assign an entire subroutine to a variable (as a reference), and then call it straightforwardly:

# create the $action variable - a reference to the subroutine
my $action = \&sing_out;
# later - perhaps much later - I call it
$action->();

sub sing_out {
    print "La, la, la, la, la!\n"
}

Detrital

Answer 5

__PACKAGE__->can($action)->(@args);

For more info on can(): http://perldoc.perl.org/UNIVERSAL.html

Purposive

Answer 6

The most important thing is: why do you want to use variable as function name. What will happen if it will be 'eval'? Is there a list of functions that can be used? Or can it be any function? If list exists - how long it is?

Generally, the best way to handle such cases is to use dispatch tables:

my %dispatch = (
   'addition' => \&some_addition_function,
   'multiplication' => sub { $self->call_method( @_ ) },
);

And then just:

$dispatch{ $your_variable }->( 'any', 'args' );

Sapanwood

Answer 7

I do something similar. I split it into two lines to make it slightly more identifiable, but it's not a lot prettier.

my $sub = \&{$action};
$sub->();

I do not know of a more correct or prettier way of doing it. For what it's worth, we have production code that does what you are doing, and it works without having to disable use strict.

Faultless

and in case it helps anyone, if you also want to pass parameters to the subroutine, you just put them in between the () - i.e. the same as you would to a normal sub. e.g. $sub->($parmVariable,11,'a'); – Sparks

To call this reflexively from within a sub; my $this = \&{(caller(0))[3]}; $return = $this->(); $return .= $this->(\@flags,$arguments,\%foo); – Albrecht

Answer 8

I did it in this way:

@func = qw(cpu mem net disk);
foreach my $item (@func){
    $ret .= &$item(1);
}

Articulate

Answer 9

Every package in Perl is already a hash table. You can add elements and reference them by the normal hash operations. In general it is not necessary to duplicate the functionality by an additional hash table.

#! /usr/bin/perl -T
use strict;
use warnings;

my $tag = 'HTML';

*::->{$tag} = sub { print '<html>', @_, '</html>', "\n" };

HTML("body1");

*::->{$tag}("body2");

The code prints:

<html>body1</html>
<html>body2</html>

If you need a separate name space, you can define a dedicated package.

See perlmod for further information.

Millham

That's a long page to link to, but I think you're referring to the Symbol Tables section. – Thy

Answer 10

Either use

&{\&{$action}}();

Or use eval to execute the function:

eval("$action()");

Giantism

Answer 11

If it's only in one program, write a function that calls a subroutine using a variable name, and only have to document it/apologize once?

Chalco

Answer 12

I used this: it works for me.

(\$action)->();

Or you can use 'do', quite similar with previous posts:

$p = do { \&$conn;}; 
$p->();

Bartlett

Answer 13

For a relatively save approach

sub func() {
    say 'hello';
}

for (qw(func func_me_not)) {
    if (my $func = __PACKAGE__->can($_)) {
        $func->();
    }
}

Loginov