Calling options via Sub Routines

[sunadmn]

Good day all I am still pretty new to perl and just really starting to get my feet wet, so I was wondering how I would correctly write a script to look for command line options to run a certain sub routine.

What I would like to be able to do is write a script that can be very interactive with the user. I would like to have the script print out a question and then depending on the answer the user gives run a certain part of the script.

print "What file do you want to edit?\n";
$file = <STDIN>;
chomp($file);

Here we would do some sort of test I guess to ensure what part of the code would be ran. This is the part I guess I am most unsure about. Any advice you may offer here would be great.

-Stephen

[dragonchild]

There are a huge number of ways to do this. They all boil down to:

my @values = qw(Stuff you want to pass in);
print "Some question\n";
chomp(my $file = <>);
if ($file eq 'A') {
    do_A($file, @values);
} elsif ($file eq 'B') {
    do_B($file, @values);
} elsif ... {
} else {
    complain_that_value_sucks($file, @values);
}

Now, that's a really piss-poor thing, especially if you have more than 5-10 options. So, we can use a dispatch table. This is a preferred method of doing things.

my %dispatch_table = (
    A => \&do_A,
    B => \&do_B,
    C => \&do_C,
);

my @values = qw(Stuff you want to pass in);

print "Some question\n";
chomp(my $file = <>);

my $sub = $dispatch_table{$file} || \&complain_that_value_sucks;
$sub->($file, @values);

Now, the dispatch table can be in a module, built on-the-fly, or whatever. What's happening here is that we're taking references to subroutines and associating them with strings. So, whenever we see a given string, we can map that to the given subroutine. This is very similar (but more powerful) to funcp's in C/C++.

------
We are the carpenters and bricklayers of the Information Age.

The idea is a little like C++ templates, except not quite so brain-meltingly complicated. -- TheDamian, Exegesis 6

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

[sri]

You should also consider the use of Getopt::Long over interactivity, it makes many things easier!

[davido]

For the "New and just getting feet wet" folks (myself included), Getopt::Std has a pretty easy to use interface, and is flexible enough to allow multiple -a -b -c type options, as well as -abc (meaning -a -b and -c), as well as things like '-z [arg]'.

I would provide examples, but can't possibly do so as effectively as the POD that comes with the module. See the perldocs for Getopt::Std for more info. It really is pretty simple to use and is much more robust than any "roll your own" technique could be (assuming again, that you, like I, are 'still pretty new').

Dave

"If I had my life to do over again, I'd be a plumber." -- Albert Einstein

[Roger]

I quickly wrote some sample code below that I hope would be more helpful to set your perl programming on the right track :-D

#!/usr/bin/perl
use Getopt::Long;
use Pod::Usage;  # Recomend to use Pod::Usage along with Getopt::Long
use strict;

# Parse command line arguments and assign corresponding variables
GetOptions
(
    'f|fruit=s'  => \( my $fruit  = undef ),
    'a|action=s' => \( my $action = undef ),
    'g|greet'    => \( my $greet  = undef ),
);

unless ( defined $action && defined $fruit )
{
    pod2usage( -exitval => 1, -output => \*STDERR );
}

# do greeting
print "Hello there!\n" if ($greet);

# multiple fruit possible
my @fruit = split /,/, $fruit;

foreach (@fruit)
{
    print "I will $action $_.\n";
    # etc...
}

exit(0);

__END__

=pod

=head1 NAME

fruit.pl

=head1 SYNOPSIS

fruit.pl [options]

=head1 ARGUMENTS

The -f and -a options are mandatory. The -g option is optional.

=over 4

=item B<-f|--fruit [name]>

Specify the fruit, multiple fruits possible, separate by comma

=item B<-a|--action [name]>

Specify the action to perform on fruit.

=item B<-g|--greet>

Print the greeting.

=back

=cut

Then you can run the program with command-line options:

perl ./fruit.pl -f apple,orange -a eat -g
perl ./fruit.pl --fruit banana -action sell
...

[yosefm]

There's a nice tutorial about parsing command-line arguments, right here in the monastery. I read it (but never used it) and it looks very informative.