I'd go with Getopt::Long.

The difference between the two isn't that drastic, but Long is far more configurable and powerful (IMHO), making your task trivial...

my $ok = GetOptions( \%args, 'i=s', 'o=s', 'w=i', 's=i', 'help|?', );

usage() if ! $ok || $args{'help'};
[download]

That still allows an all-digit filename, but you can handle those with ...

foreach my $opt (qw( i o )) {
    usage() unless $args{$opt} =~ /\D/;
}
[download]

... if you really think that should be disallowed.

Also, if you take advantage of Getopt::Long's auto-abbreviation feature (which is on by default), then you can give your switches more meaningful names (ie, 'input=s') for use within your script and still have the shorter, 'initials-only' forms work.

    --k.

Thanks, all. Looks like Getopt::Long is going to be the way to go. Time to read the docs... :-)

Have a great weekend!

I generally use getopts with hash references since, to me, it is the easier way to do what I want. With that, I will show some of my own code:

use Getopt::Std;
...
&parse_commandline;
...
sub parse_commandline {
    my $funcName  = (caller(0))[3];
    print "\nWorking in function: $funcName\n" if $DEBUG;
    
# c: require different config file (requires param)
# q: quiet or cron mode
# t: test mode (don't do anything.  Just run through the motions)
# v: verbose mode (same as debug)
# V: version information.
# d: debug mode (extra output)
# h: help

    getopts('c:qtrvVdh',\%ARGS);  ## <- here is the hash ref!

# From there I just check the hash{switch}
# to see if what I want is there and set 
# script environment accordingly.

    $DEBUG       = 1 if ( exists  $ARGS{'v'} );
    $DEBUG       = 1 if ( exists  $ARGS{'d'} );
    $NO_RULE_OUTPUT
                 = 1 if ( exists  $ARGS{'r'} );

    &version   if ( exists  $ARGS{V} );
    &funcUsage if ( exists  $ARGS{h} );

    if ( defined $ARGS{'c'} ) {

    if ( ! &check_for_valid_conf($ARGS{'c'}) ) {
        print "\n$config_file: Invalid config file specified on ".
              "command line\n";
        &funcUsage
    } else {
        $config_file = $ARGS{'c'};
    }
    }

    $CRON_MODE   = 1 if ( exists  $ARGS{'q'} );
    $TEST_MODE   = 1 if ( exists  $ARGS{'t'} and !$CRON_MODE );
}
[download]

So, in a nutshell, the way I do it (and by all means mine is not the best way but its a way...as is the way with Perl), using getopts('switches I want',\%HASHREF); is my favorite. Note that in 'switches I want' you will see letters followed by ':'. That ':' specifies that that the 'i' parameter in getopts('hi:o:',\%HASHREF) needs an argument on the command line, ie myscript.pl -i input_file ... and my '-o' will need one too. However, '-h' will not. Also note, that this is easy if you want optional variables because when you are testing for defined'ness or existence of your hashed arguments, you simply ignore doing anything with those that are not defined or in existence.

I hope this helps.

_ _ _ _ _ _ _ _ _ _
- Jim
Insert clever comment here...

Hi,
use the GetOpt::Long module. With that it's realy easy to handle command line switches.

#!/usr/bin/perl -w
use strict;
use Getopt::Std;

use vars qw/ $opt_i $opt_o $opt_n $opt_s $opt_h /;
my $inputFile;
my $outFile     = "Default.out";
my $n        = 123;
my $s;

getopts( 'i:o:n:s:h' );

if( $opt_i ) { 
    $inputFile = $opt_i;
    &usage( "Input File $inputFile does not exist" ) 
                 unless ( -T $inputFile );
} else {
    &usage( "Must specify output file with -i<filename>" );
}
if( $opt_o ) { $outFile = $opt_o; }
if( $opt_n ) { $n     = $opt_n; }
if( $opt_s ) { 
    $s    = $opt_s;
} else {
    &usage( "Must specify s number with -s <number>" );
}
if( $opt_o ) { $outFile = $opt_o; }
if( $opt_h ) { &usage(); exit; }

print "Input file is $inputFile\n";
print "Output file is $outFile\n";
print "n is $n\n";
print "s is $s\n";


sub usage {
    my $msg = shift;

print <<USAGE;
usage error [$msg]
usage: $0 -i<input file> -s<number> -o[<output file>] -n[<number>]
USAGE
exit;
}
[download]