[Chapter 7] 7.2.36 Getopt::Std - Process Single-Character Options with Option Clustering
Author: Larry Wall, Tom Christiansen & Randal L. Schwartz
Date: 1999-07-02T02:02:40Z

#

| Chapter 7 The Standard Perl Library |

### 7.2.36 Getopt::Std - Process Single-Character Options with Option Clustering

    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.

The `getopt()` and `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 `getopt()` or `getopts()`, you pass along information about the kinds of options your program expects. These functions then analyze `@ARGV`, extract information about the options, and return this information to your program in a set of variables. The processing of `@ARGV` stops when an argument without a leading "`-`" is encountered, if that argument is not associated with a preceding option. Otherwise, `@ARGV` is processed to its end and left empty.

For each option in your program's invocation, both `getopt()` and `getopts()` define a variable `$opt_``x` where `x` is the option name. If the option takes an argument, then the argument is read and assigned to `$opt_``x` as its value; otherwise, a value of 1 is assigned to the variable.

Invoke `getopt()` with one argument, which should contain all options that require a following argument. For example:

    getopt('dV');

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 `getopt()` are assumed to be without accompanying argument.

Where `getopt()` allows any single-character option, `getopts()` allows only those options you declare explicitly. For example, this invocation:

    getopts('a:bc:');

legitimizes only the options `-a`, `-b`, and `-c`. The colon following the `a` and `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 `$opt_``x` 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 `getopt()` and `getopts()` halt argument processing upon reading an argument (without leading "`-`") where 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 `@ARGV` has been completely emptied or not - that is, whether all arguments have been processed. 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;

7.2.35 Getopt::Long - Extended Processing of Command-Line Options |  | 7.2.37 I18N::Collate - Compare 8-bit Scalar Data According to the Current Locale