Answer.

Command line argument processing is a basic task for Perl programs. Historically, Perl provided the variable @ARGV to access the arguments passed to the script. The problem is that complex scenarios may include flags and key-value parameters, which require manual parsing of the @ARGV array. If handled incorrectly, parameters can be processed incorrectly, mandatory values may be missed, or extra values may be processed, leading to errors in the program logic.

The solution is to use systematic processing: iterating through @ARGV, analyzing content, processing keys and their values.

Example code:

my %args;
while (my $arg = shift @ARGV) {
    if ($arg =~ /^--(\w+)=?(.*)/) {
        my ($key, $val) = ($1, $2);
        if ($val eq '' && @ARGV) {
            $val = shift @ARGV; # next value
        }
        $args{$key} = $val eq '' ? 1 : $val;
    } else {
        push @{$args{'_free'}}, $arg;
    }
}

print "Got foo: $args{foo}
" if exists $args{foo};

Key features:

Flexible handling of positional and named parameters.
Manual checking for the presence and length of values.
Keeping a separate list of free arguments (_free).

Tricky questions.

What happens if the argument is passed as '--flag value' instead of '--flag=value'?

If processing only the separation through '=', the value will be an empty string, and the next element of the array will be ignored as a standalone argument. The solution is to consider both cases when parsing:

if ($arg =~ /^--(\w+)=?(.*)/)

and if $val is empty, take the next element.

How does Perl behave with arguments containing spaces?

Perl does not split arguments within @ARGV by spaces, all splitting is done by the shell. Therefore, "--foo=bar baz" will come as two different elements unless the string is quoted in the command line. This should be considered and users should always be required to escape spaces.

Can @ARGV be modified using shift without losing the original arguments?

Shift alters the array itself, and the original list of arguments cannot be restored. If the original content of @ARGV needs to be preserved, it must be cloned in advance:

my @original_argv = @ARGV;

Common mistakes and anti-patterns

Not checking if there is a value after a key, leading to reading past the array.
Ignoring processing free arguments and flags without values.
Not considering both cases '--key value' and '--key=value'.

Real-life example

Negative case

The script only processed keys of the form '--foo=bar', ignoring '--foo bar', and crashed with an error when the value was missing.

Pros:

The code is simple.

Cons:

Using the script was inconvenient; users often made mistakes.
The script crashed on unexpected command line scenarios.

Positive case

Added processing for both syntaxes and checking the length of @ARGV, allowed flag toggles.