Home arrow Perl Programming arrow Page 2 - Command Line Options in Perl: Using Getopt::Std

Parsing short options with Getopt::Std - Perl

Unlike command line arguments, command line options can sometimes be a bit difficult to read; nevertheless, they can prove to be quite useful. This article explains what a command line option is, why you would use one, and how to process them in Perl. This article is the first of two parts.

TABLE OF CONTENTS:
  1. Command Line Options in Perl: Using Getopt::Std
  2. Parsing short options with Getopt::Std
  3. Parsing options without values
  4. Special options
By: Peyton McCullough
Rating: starstarstarstarstar / 2
May 18, 2009

print this article
SEARCH DEV SHED

TOOLS YOU CAN USE

advertisement
 

Let's start by taking a look at the Getopt::Std module. This module provides two functions for parsing short options and isn't very difficult to get started with. With each method, you simply need to specify the letters for short options, and then the module stores the values of those options in the appropriate variables. 

For example, consider a Perl script named optapp. This application can take two short command line options, a and b. Both of these options take values. We might call this script like this:

 

$ ./optapp -a20 -b30

 

In order to actually create this script, we'd use the getopt function of the Getopt::Std module. This function takes one argument, a string containing the letters of all command line options to be recognized. Also, with the getopt function, these command line options must take values. 

This function is called near the top of the script, and after being called, it will set global variables named $opt_x, where x is the letter of the option. The values of the variables will be the values associated with the options. In the case of the above call, $opt_a would be set to 20, and $opt_b would be set to 30. 

The resulting script would look like this:

 

#!/usr/bin/perluse Getopt::Std;getopt('ab');print "$opt_an" if (defined $opt_a);print "$opt_bn" if (defined $opt_b);

 

As you can see, the script simply prints out the values of the options, if they are used at all. Run the program, passing in some values with the options, and see what you get. 

Notice, though, that the script doesn't use the strict pragma. If we do use it, then Perl will complain, since $opt_a and $opt_b were never declared. This is a problem, but it's a problem that's easily fixed. We simply need to put in an "our" declaration for each of the names we plan to use. 

Note that we can't just use "my." We must use "our." 

Now we can use the strict pragma:

 

#!/usr/bin/perluse strict;use warnings;use Getopt::Std;our($opt_a, $opt_b);getopt('ab');print "$opt_an" if (defined $opt_a);print "$opt_bn" if (defined $opt_b);

 

Still, using global variables to store option values is a bit ugly, and every time you need to define a new command line option, it's necessary to declare the associated name using our. Fortunately, we're able to use a hash instead, which makes things easier and keeps our commands neat. 

To store option values in a hash, just pass a hash reference to the getopt function as the second argument. The keys of the hash correspond to the option names. Here's part of our script rewritten to use a hash rather than global variables:

 

my %opt;getopt('ab', %opt);print $opt{'a'} . "n" if (defined $opt{'a'});print $opt{'b'} . "n" if (defined %opt{'b'});

 

The same thing can be accomplished with either method. Just use whatever method you feel looks better. 



 
 
>>> More Perl Programming Articles          >>> More By Peyton McCullough
 

blog comments powered by Disqus
escort Bursa Bursa escort Antalya eskort
   

PERL PROGRAMMING ARTICLES

- Perl Turns 25
- Lists and Arguments in Perl
- Variables and Arguments in Perl
- Understanding Scope and Packages in Perl
- Arguments and Return Values in Perl
- Invoking Perl Subroutines and Functions
- Subroutines and Functions in Perl
- Perl Basics: Writing and Debugging Programs
- Structure and Statements in Perl
- First Steps in Perl
- Completing Regular Expression Basics
- Modifiers, Boundaries, and Regular Expressio...
- Quantifiers and Other Regular Expression Bas...
- Parsing and Regular Expression Basics
- Hash Functions

Developer Shed Affiliates

 


Dev Shed Tutorial Topics: