analisi della riga di comando di php, howto

Question

Sto usando Console_Getopt in PHP 5.2 e trovo sorprendente quanto sia diverso da getopt in altre lingue (perl, bash, java). Qualcuno può consigliare come analizzare gli arg dalla matrice " $ opts " tornato?

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

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

// print_r ritorna di seguito

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

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

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

        )

    [1] => Array
        (
        )

)

Ho iniziato a fare qualcosa di simile al seguito, che è prolisso, quindi sto cercando suggerimenti su come gestire i flag della riga di comando in 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";
    }
}

Mi chiedo perché la getopt di PHP non sia come quella di perl, dove la chiave dell'array è la bandiera, ad esempio $ opts {'a'} .. sarebbe conveniente.

Answer 1

Per la documentazione in linea

  

Il valore restituito è un array di due elementi: l'elenco di parsed   opzioni e l'elenco di argomenti della riga di comando non opzionali. Ogni voce in   l'elenco delle opzioni analizzate è una coppia di elementi, il primo   specifica l'opzione e la seconda specifica l'argomento dell'opzione,   se ce n'era uno.

Il che significa che puoi scartare facilmente il secondo array e assumere un impegno a mantenere l'array di array, l'opzione del primo elemento, il valore del secondo elemento, il formato.

Con questo presupposto in atto, prova

$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;
}

per ottenere una struttura di dati di tuo gradimento.

Per quanto riguarda il motivo per cui questo è diverso da altre implementazioni di getopt, chiedi a i manutentori .

Answer 2

Controlla GetOptionKit per PHP:

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

Sinossi

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 può stampare le opzioni per te:

* 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

Ho scritto una classe wrapper attorno a getopt (), simile a Console_GetOpt ma penso un po 'più bello.

Puoi trovarlo qui: http://github.com/pete-otaqui/ClipClop

Un parser di opzioni PHP basato su getopt ().

ClipClop ti consente di creare facilmente strumenti da riga di comando con opzioni. ClipClop genera automaticamente istruzioni d'uso ben formattate e fornisce anche una comoda API per l'accesso a parametri e valori.

ClipClop gestisce i parametri obbligatori e facoltativi e i relativi valori. Quindi una data opzione come " - verbose " può essere richiesto o facoltativo di per sé e non può avere alcun valore di parametro o facoltativo o richiesto.

ClipClop gestisce più valori, sebbene imposti valori singoli per impostazione predefinita, può convalidare rispetto alle espressioni regolari e analizzare determinati tipi per te: numeri interi, numeri, json e URL.

Esempio rapido Crea uno script chiamato " environment_test " ;, con il seguente codice

#!/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";
?>

Include varie altre opzioni e unit test.

Answer 4

Per quello che vale, di recente ho hackerato un mio piccolo progetto per l'analisi della riga di comando in PHP. Lo chiamo Pharse (tipo "PHP Parse" ... tipo di). È disponibile per il download su github qui:

https://github.com/chrisallenlane/Pharse

È stato così fortemente ispirato da Trollop che potresti quasi considerarlo una porta, anche se non ho implementato tutte le funzionalità di Trollop. (Non avevo bisogno di alcune funzionalità - come i sotto-comandi - per i miei scopi, quindi non mi sono preoccupato.)

L'essenza generale della libreria è che il suo utilizzo implica la richiesta di un singolo file di base e quindi il passaggio alla classe Pharse di un singolo array associativo di opzioni. Ad esempio:

    <?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);

?>

Ho scritto un post sul blog che introduce la libreria qui:

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

Ho hackerato la libreria per uso casuale per i miei progetti personali, quindi farei attenzione prima di distribuire questo script in un ambiente di produzione. Non sono ancora riuscito a implementare test unitari adeguati, quindi state attenti.

Detto questo, però, penso che sia una sceneggiatura piuttosto carina, e penso che sia perfettamente adatto a progetti di hobby e simili.