análisis de la opción de línea de comando de php, howto

Question

Estoy usando Console_Getopt en PHP 5.2, y me resulta sorprendente lo diferente que es de getopt en otros idiomas (perl, bash, java). ¿Alguien puede recomendar cómo analizar los argumentos de la matriz " $ opts " devuelto?

php myprog.php -a varA -c -b varB

$o= new Console_Getopt;
$opts = $o->getopt($argv, "a:b:c");
print_r($opts);

// el print_r regresa a continuación

Array
(
    [0] => Array
        (
            [0] => Array
                (
                    [0] => a
                    [1] => varA
                )

            [1] => Array
                (
                    [0] => c
                    [1] =>
                )

            [2] => Array
                (
                    [0] => b
                    [1] => varB
                )

        )

    [1] => Array
        (
        )

)

Empecé a hacer algo como a continuación, que es de largo aliento, por lo que estoy buscando sugerencias sobre cómo tratar con las banderas de línea de comandos en php.

foreach($opts[0] as $i -> $keyval) {
    list($key, $val) = $keyval;
    if($key == 'a') {
        print "valueForA: $val\n";
    } else if($key == 'b') {
        print "valueForB: $val\n";         
    } else if($key == 'c') {
        print "c is set\n";
    }
}

Me pregunto por qué el getopt de PHP no es como el de perl, donde la clave de la matriz es la bandera, por ejemplo, $ opts {'a'} ... eso sería conveniente.

Answer 1

Por la documentación en línea

  

El valor de retorno es una matriz de dos elementos: la lista de analizados   opciones y la lista de argumentos de línea de comandos que no son opciones. Cada entrada en   la lista de opciones analizadas es un par de elementos: el primero   especifica la opción, y la segunda especifica el argumento de la opción,   si hubiera uno.

Lo que significa que descarta fácilmente la segunda matriz y asume el compromiso de mantener la matriz de matrices, la opción del primer elemento, el valor del segundo elemento, el formato.

Con esa suposición establecida, intente

$o= new Console_Getopt;
$opts = $o->getopt($argv, "a:b:c");
print_r(getHashOfOpts($opts));

function getHashOfOpts($opts) {
    $opts = $opts[0];
    $return_opts = $opts;
    $return_opts = Array();
    foreach($opts as $pair){
        $return_opts[$pair[0]] = $pair[1];
    }
    return $return_opts;
}

para obtener una estructura de datos más de su agrado.

En cuanto a por qué esto es diferente a otra implementación de getopt, pregunte a los mantenedores .

Answer 2

Verifique GetOptionKit para PHP:

https://github.com/c9s/php-GetOptionKit

Sinopsis

use GetOptionKit\OptionCollection;
use GetOptionKit\OptionParser;

$options = new OptionCollection;
$options->add( 'f|foo:' , 'option require value' );  # returns spec object.

$options->add( 'b|bar+' , 'option with multiple value' );
$options->add( 'z|zoo?' , 'option with optional value' );

$options->add( 'f|foo:=i' , 'option require value, with integer type' );
$options->add( 'f|foo:=s' , 'option require value, with string type' );

$options->add( 'v|verbose' , 'verbose flag' );
$options->add( 'd|debug'   , 'debug flag' );


$parser = new OptionParser($options);
$result = $parser->parse( array( 'program' , '-f' , 'foo value' , '-v' , '-d' ) );

$spec = $result->verbose;
$spec = $result->debug;
$spec->value;  # get value

GetOptionKit \ OptionPrinter puede imprimir opciones para usted:

* Available options:
              -f, --foo   option requires a value.
              -b, --bar   option with multiple value.
              -z, --zoo   option with optional value.
          -v, --verbose   verbose message.
            -d, --debug   debug message.
                 --long   long option name only.
                     -s   short option name only.

Answer 3

Escribí una clase de contenedor alrededor de getopt (), similar a Console_GetOpt pero creo que es un poco más agradable.

Puede encontrarlo aquí: http://github.com/pete-otaqui/ClipClop

Un analizador de opciones PHP basado en getopt ().

ClipClop le permite crear fácilmente herramientas de línea de comandos con opciones. ClipClop genera automáticamente instrucciones de uso bien formateadas, y también proporciona una API conveniente para acceder a parámetros y valores.

ClipClop maneja los parámetros obligatorios y opcionales, y los valores para ellos. Entonces, una opción dada como " - verbose " puede ser obligatorio u opcional en sí mismo, y no puede tener ningún valor de parámetro, ni uno opcional, ni uno obligatorio.

ClipClop gestiona múltiples valores, aunque aplica valores únicos por defecto, puede validar contra expresiones regulares y puede analizar ciertos tipos para usted: enteros, números, json y urls.

Ejemplo rápido Cree un script llamado " environment_test " ;, con el siguiente código

#!/usr/bin/env php
<?php

// do this unless you have setup an Autoloader
require_once('/path/to/ClipClop.php');

$clipclop = new ClipClop();

$clipclop->addOption(array(
    'short' => 'e', // shortname, i.e. "-e"
    'long' => 'environment', // longname, i.e. "--environment"
    'value' => TRUE, // A value must be given such as "--environment=TEST"
    'help' => 'Set the environment', // help text for the 'usage' text
    'required' => TRUE, // Environment must be provided
));

// as soon as we ask for an option, ClipClop will parse CLI arguments with getopt()

$environment = $clipclop->getOption('e'); // returns the value set for 'e' OR 'environment'

print "You ran this script with environment: $environment";
?>

Incluye varias otras opciones y pruebas unitarias.

Answer 4

Por lo que vale, recientemente pirateé un pequeño proyecto propio para el análisis de opciones de línea de comandos en PHP. Lo llamo Pharse (como " PHP Parse " ... más o menos). Está disponible para descargar en github aquí:

https://github.com/chrisallenlane/Pharse

Estaba tan fuertemente inspirado por Trollop que casi podría considerarlo un puerto, aunque no lo implementé todas las características que tiene Trollop. (No necesitaba algunas funciones, como subcomandos, para mis propios fines, así que no me molesté).

La esencia general de la biblioteca es que su uso implica requerir un único archivo base y luego pasar a la clase Pharse una única matriz asociativa de opciones. Por ejemplo:

    <?php

   # specify some options
   $options = array(
        'user_name'     => array(
            'description'   => 'Your username',
            'default'       => 'admin',
            'type'          => 'string',
            'required'      => true,
            'short'         => 'u',
        ),

        'password' => array(
            'description'   => 'Your password',
            'default'       => 'sexsecretlovegod',
            'type'          => 'string',
            'required'      => true,
        ),
    );

# You may specify a program banner thusly:
$banner = "This program logs you in to the Gibson.";
Pharse::setBanner($banner);

# After you've configured Pharse, run it like so:
$opts = Pharse::options($options);

?>

Escribí una publicación de blog presentando la biblioteca aquí:

http : //chris-allen-lane.com/2012/03/pharse-a-library-for-php-command-line-option-parsing/

Pirateé la biblioteca para uso casual para mis proyectos personales, por lo que sería precavido antes de implementar este script en un entorno de producción. Aún no he llegado a implementar pruebas unitarias adecuadas, así que ten cuidado.

Dicho esto, sin embargo, creo que es un guión bastante ingenioso, y creo que es perfectamente adecuado para proyectos de pasatiempo y similares.