do php opção de linha de comando de análise, howto

Question

Eu estou usando Console_Getopt no PHP 5.2, e encontrá-lo surpreendente sobre como é diferente a partir de getopt em outros idiomas (perl, bash, java). Alguém pode recomendar como analisar os argumentos da matriz "$ opta" voltou?

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

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

// os retornos print_r abaixo

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

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

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

        )

    [1] => Array
        (
        )

)

Eu comecei a fazer algo como abaixo, que é prolixo, então eu estou procurando sugestões sobre como lidar com as bandeiras de linha de comando em 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";
    }
}

Eu me pergunto por getopt do PHP não é como perl do, onde a chave do array é a bandeira por exemplo $ opta { 'a'} .. isso seria conveniente.

Answer 1

Per a documentação em linha

O valor de retorno é um array de dois elementos: a lista de analisado opções e a lista de argumentos de linha de comando não-opção. Cada entrada no a lista de opções analisada é um par de elementos - o primeiro Especifica a opção, eo segundo especifica o argumento de opção, se houvesse um.

O que significa que facilmente descartar a segunda matriz, e assumir um compromisso com a manter a matriz de matrizes, opção primeiro elemento, segundo valor elemento, formato.

Com essa suposição no lugar, tente

$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 obter uma estrutura de dados mais do seu agrado.

Quanto ao porquê isso é diferente de outras aplicações com getopt, pergunte os mantenedores .

Answer 2

Verifique GetOptionKit para PHP:

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

Sinopse

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 pode imprimir opções para você:

* 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

Eu escrevi uma classe invólucro em torno getopt (), semelhante ao Console_GetOpt mas eu acho que um pouco melhor.

Você pode encontrá-lo aqui: http://github.com/pete-otaqui/ClipClop

A PHP parser opção com base no getopt ().

ClipClop permite que você facilmente criar ferramentas de linha de comando com opções. ClipClop gera automaticamente as instruções de uso bem formatados, e também dá uma API conveniente para acessar os parâmetros e valores.

parâmetros alças ClipClop obrigatórios e opcionais, e os valores para eles. Assim, uma determinada opção como "--verbose" pode ser obrigatório ou opcional em si mesmo, e ele não pode ter nenhum valor de parâmetro ou um opcional, ou um exigido um.

ClipClop administra vários valores, embora impõe valores únicos por padrão, pode validar contra expressões regulares e pode analisar certos tipos para você:. Inteiros, números, JSON e urls

Exemplo Rápida Criar um script chamado "environment_test", com o seguinte 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";
?>

Ele inclui várias outras opções, e testes de unidade.

Answer 4

Por que vale a pena, eu recentemente cortado um pouco projeto do meu próprio para a opção de linha de comando de análise em PHP. Eu chamo-lhe pharse (como "PHP Parse" ... tipo de). Ele está disponível para download no GitHub aqui:

https://github.com/chrisallenlane/Pharse

Foi tão fortemente inspirado por Trollop que quase se podia considerá-lo um porto, embora eu não implementou todos os recursos Trollop tem. (Eu não preciso de alguns recursos - como sub-comandos -. Para meus próprios fins, então eu não me incomodei)

A essência geral da biblioteca é que a sua utilização envolve exigindo um único arquivo de base, e depois passando a classe pharse uma única matriz associativo de opções. Por exemplo:

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

?>

Eu escrevi um post no blog introduzindo a biblioteca aqui:

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

Eu cortei a biblioteca para uso casual para meus projetos pessoais, por isso eu tenha cuidado antes de implantar esse script para um ambiente de produção. Eu nem sequer chegado a cerca de implementação de testes de unidade adequadas ainda, então vos advertiu.

Com o que disse, no entanto, eu acho que é um pequeno script muito bacana, e eu acho que é perfeitamente adequado para projetos de hobby e similares.