use Getopt::Std; getopt('oDI'); # -o, -D & -I take arg. Sets opt_* as a side effect. getopts('oif:'); # -o & -i are boolean flags, -f takes an argument. # Sets opt_* as a side effect.
getopts() functions give
your program simple mechanisms for processing single-character options. These
options can be clustered (for example,
-bdLc might be
interpreted as four single-character options), and you can specify individual
options that require an accompanying argument. When you invoke
getopts(), you pass along
information about the kinds of options your program expects. These functions
@ARGV, extract information about the options,
and return this information to your program in a set of variables. The
@ARGV stops when an argument without a leading
-" is encountered, if that argument is not
associated with a preceding option. Otherwise,
processed to its end and left empty.
For each option in your program's invocation, both
getopts() define a variable
x is the
option name. If the option takes an argument, then the argument is read
and assigned to
x as its value; otherwise, a value of 1 is
assigned to the variable.
getopt() with one argument, which should contain all
options that require a following argument. For example:
If your program is then invoked as:
myscr -bfd January -V 10.4
then these variables will be set in the program:
$opt_b = 1; $opt_f = 1; $opt_d = "January"; $opt_V = 10.4;
Space between an option and its following argument is unnecessary. The previous command line could have been given this way:
myscr -bfdJanuary -V10.4
In general, your program can be invoked with options given in any order.
All options not "declared" in the invocation of
assumed to be without accompanying argument.
getopt() allows any single-character option,
getopts() allows only those options you declare explicitly. For
example, this invocation:
legitimizes only the options
colon following the
c means that these two options
require an accompanying argument;
b is not allowed to have an
argument. Accordingly, here are some ways to invoke the program:
myscr -abc # WRONG unless bc is really the argument to -a myscr -a -bc # WRONG, with same qualification myscr -a foo -bc bar # $opt_a = "foo"; $opt_b = 1; $opt_c = "bar" myscr -bafoo -cbar # same as previous
getopts() returns false if it encounters errors during option
processing. However, it continues to process arguments and assign values
as best it can to
variables. You should always check for
errors before assuming that the variables hold meaningful values.
getopt() does not return a meaningful value.
Remember that both
getopts() halt argument
processing upon reading an argument (without leading "
none was called for. This is not considered an error. So a user might
invoke your program with invalid arguments, without your being notified of
the fact. However, you can always check to see whether
been completely emptied or not - that is, whether all arguments have been
If you're using the
use strict pragma, which requires you to employ
only lexical variables or else globals that are fully declared, you
will have to use the double-colon package delimiter or else the
use vars pragma. For example:
use strict; use vars qw($opt_o $opt_i $opt_D); use Getopt::Std;