After using PHP's getopt(), how can I tell what arguments remain?

Question

OK, So PHP has a built-in getopt() function which returns information about what program options the user has provided. Only, unless I'm missing something, it's completely borked! From the manual:

The parsing of options will end at the first non-option found, anything that follows is discarded.

So getopt() returns an array with the valid and parsed options only. You can still see the entire original command-line by looking at $argv, which remains unmodified, but how do you tell where in that command-line getopt() stopped parsing arguments? It is essential to know this if you want treat the remainder of a command-line as other stuff (like, e.g., file names).

Here's an example...

Suppose I want to set up a script to accept the following arguments:

Usage: test [OPTION]... [FILE]...

Options:
  -a  something
  -b  something
  -c  something

Then I might call getopt() like this:

$args = getopt( 'abc' );

And, if I ran the script like this:

$ ./test.php -a -bccc file1 file2 file3

I should expect to have the following array returned to me:

Array
(
    [a] =>
    [b] =>
    [c] => Array
        (
            [0] =>
            [1] =>
            [2] =>
        )
)

So the question is this: How on Earth am I supposed to know that the three unparsed, non-option FILE arguments start at $argv[ 3 ]???

Answer 1

Starting with PHP 7.1, getopt supports an optional by-ref param, &$optind, that contains the index where argument parsing stopped. This is useful for mixing flags with positional arguments. E.g.:

user@host:~$ php -r '$i = 0; getopt("a:b:", [], $i); print_r(array_slice($argv, $i));' -- -a 1 -b 2 hello1 hello2
Array
(
    [0] => hello1
    [1] => hello2
)

Answer 2

Nobody said you have ot use getopt. You may do it in any way you like:

$arg_a = null; // -a=YOUR_OPTION_A_VALUE
$arg_b = null; // -b=YOUR_OPTION_A_VALUE
$arg_c = null; // -c=YOUR_OPTION_A_VALUE

$arg_file = null;  // -file=YOUR_OPTION_FILE_VALUE

foreach ( $argv as $arg )
{
    unset( $matches );

    if ( preg_match( '/^-a=(.*)$/', $arg, $matches ) )
    {
        $arg_a = $matches[1];
    }
    else if ( preg_match( '/^-b=(.*)$/', $arg, $matches ) )
    {
        $arg_b = $matches[1];
    }
    else if ( preg_match( '/^-c=(.*)$/', $arg, $matches ) )
    {
        $arg_c = $matches[1];
    }
    else if ( preg_match( '/^-file=(.*)$/', $arg, $matches ) )
    {
        $arg_file = $matches[1];
    }
    else
    {
        // all the unrecognized stuff
    }
}//foreach

if ( $arg_a === null )    { /* missing a - do sth here */ }
if ( $arg_b === null )    { /* missing b - do sth here */ }
if ( $arg_c === null )    { /* missing c - do sth here */ }
if ( $arg_file === null ) { /* missing file - do sth here */ }

echo "a=[$arg_a]\n";
echo "b=[$arg_b]\n";
echo "c=[$arg_c]\n";
echo "file=[$arg_file]\n";

I always do it like that and it works. Moreover I can do whatever I want with it.

Answer 3

The following may be used to obtain any arguments following command line options. It can be used before or after invoking PHP's getopt() with no change in outcome:

# $options = getopt('cdeh');

$argx = 0;

while (++$argx < $argc && preg_match('/^-/', $argv[$argx])); # (no loop body)

$arguments = array_slice($argv, $argx);

$arguments now contains any arguments following any leading options. Alternatively, if you don't want the argument(s) in a separate array, then $argx is the index of the first actual argument: $argv[$argx].

If there are no arguments, after any leading options, then:

• $arguments is an empty array [], and
• count($arguments) == 0, and
• $argx == $argc.

Answer 4

Take a look at GetOptionKit to get rid of the flag parsing.

http://github.com/c9s/GetOptionKit

GetOptionKit can be easily integrated into your command line script. It supports type constraint, value validation and so on.