You could use sub references instead:

@listofsubs = (\&sub1, \&sub2, \&sub3);
foreach $sub (@listofsubs)
{
  $sub->();
}
[download]

foreach $sub (@listofsubs) {
  $self->$sub()
}
[download]

foreach $sub (@listofsubs) {
  if (not ref $sub)
  {
    $sub = __PACKAGE__->can($sub);
  }
  $sub->();
}
[download]

No, creating a hash of name => code ref is the normal technique. Do a search for "dispatch table".

This doesn't look like a dispatch table to me. If you're reading in a bunch of sub names from an external source, and calling them, order may matter. Hashes don't preserve that. "But I'm just suggesting using the table to convert from string to code ref! You can use the order of strings to control the order!" True, but why produce another hash when the symbol table (another hash) already exists, with ways to query it?

$ perl -le 'sub foo { }; print \&foo;print __PACKAGE__->can("foo")'
CODE(0xf81930)
CODE(0xf81930)
[download]

No non-strict code. And when I add new functions, no need to remember to update the symbol table - perl does that automatically.

Don't get me wrong. I like dispatch tables. I use them. A lot. This just doesn't seem like a use for them to me, mostly because it seems like the OP is trying to loop through them.

I'm not sure I want an external source telling me which subs in my package to run without some control over which ones it's allowed to run. A hash of the allowed subrefs with a default error sub makes sense in that context.

use strict;
use warnings;

sub one { print "one\n"; }
sub two { print "two\n"; }
sub tres { # some private sub they don't need to access }

my %dispatch = (
    'one' => \&one,
    'uno' => \&one,
    'two' => \&two,
    'dos' => \&two,
    'default' => sub { print "sorry, $_[0] not found.\n"; },
);

my @do_these = qw( one two uno dos tres );

foreach my $do_this ( @do_these ) {
    if ( exists $dispatch{ $do_this } ) {
        $dispatch{ $do_this }->();
    } else {
        $dispatch{ 'default' }->( $do_this );
    }
}
[download]

Thanks, I will try the building the hash. I was looking at that and wanted to see if there were other options. For this particular problem that is the way to go.
Thanks, B

Of course, if you have a lot of subroutines, you may still want symbolic refs to help construct the hash:

  my %dispatch = map { ; no strict 'refs' ; ($_, \&$_) } qw(sub1 sub2 
+sub3 ...) ;
[download]

Update: Doh! Didn't read through the thread far enough to see Tanktalus had already given a better version of the same trick (twice).

Really light weight OO stuff can ease the path:

use strict;
use warnings;

my @listofsubs = qw(sub1 wibble sub2 sub3);
my $obj = bless {};

for my $sub (@listofsubs) {
  if (my $callSub = $obj->can ($sub)) {
    $callSub->();
    next;
  }
  
  print "Can't $sub\n";
}

sub sub1 {
  print "does sub1 stuff\n";
}

sub sub2 {
  print "does sub2 stuff\n";
}

sub sub3 {
  print "does sub3 stuff\n";
}
[download]

Prints:

does sub1 stuff
Can't wibble
does sub2 stuff
does sub3 stuff
[download]

and all you need to do to add a new sub is add the sub.

What's wrong with generating your list of subs as is ... and then turning off strict qw/refs/; before calling the subs in the list by name ??

#!/usr/bin/perl -w
use strict;

my @list_o_subs = ('one','two','three','one','two','one','three','two'
+);

{
    no strict 'refs';
    for(@list_o_subs){
        &{$_};
    }
}
sub one
{
    print "called sub 'one'\n";
}
sub two
{
    print "called sub 'two'\n";
}
sub three
{
    print "called sub 'three'\n";
}
[download]

called sub 'one'
called sub 'two'
called sub 'three'
called sub 'one'
called sub 'two'
called sub 'one'
called sub 'three'
called sub 'two'
[download]