de análise argumentos Getopt :: longas de Can Perl eu não definir antes do tempo?

Question

Eu sei como usar do Perl Getopt :: longa, mas eu não sei como eu pode configurá-lo para aceitar qualquer "--key = valor" par que não foi explicitamente definido e colá-la em um hash. Em outras palavras, eu não saber de antemão quais as opções que o usuário pode querer, por isso, não há nenhuma maneira para mim para definir todos eles, mas eu quero ser capaz de analisar todos eles.

Sugestões? Graças antes do tempo.

Answer 1

O Getopt::Long documentação sugere uma opção de configuração que podem ajudar:

pass_through (default: disabled)
             Options that are unknown, ambiguous or supplied
             with an invalid option value are passed through
             in @ARGV instead of being flagged as errors.
             This makes it possible to write wrapper scripts
             that process only part of the user supplied
             command line arguments, and pass the remaining
             options to some other program.

Uma vez que as opções regulares são analisados, você poderia usar o código como o fornecido pelo Runrig para analisar as opções ad hoc.

Answer 2

Getopt :: longa não faz isso. Você pode analisar as opções de si mesmo ... por exemplo.

my %opt;
my @OPTS = @ARGV;
for ( @OPTS ) {
  if ( /^--(\w+)=(\w+)$/ ) {
    $opt{$1} = $2;
    shift @ARGV;
  } elsif ( /^--$/ ) {
    shift @ARGV;
    last;
  }
}

Ou modificar Getopt :: longo para lidar com isso (ou modificar o código acima para lidar com mais tipos de opções se precisar que).

Answer 3

Eu sou um pouco parcial, mas eu usei Getopt :: O que quer que no passado para analisar argumentos desconhecidos.

Answer 4

Potencialmente, você poderia usar o " Opções com valores de hash " recurso.

Por exemplo, eu queria permitir que os usuários para definir filtros arbitrários ao analisar através de um conjunto de objetos.

GetOptions(my $options = {}, 'foo=s', 'filter=s%')

my $filters = $options->{filter};

E, em seguida, chamá-lo como

perl ./script.pl --foo bar --filter baz=qux --filter hail=eris

Qual seria construir algo como ..

$options = {
          'filter' => {
                        'hail' => 'eris',
                        'baz' => 'qux'
                      },
          'foo' => 'bar'
        };

E, claro $ filtros terá o valor associado com 'filtro'

Boa sorte! Espero que alguém acharam isso útil.

Answer 5

A partir da documentação :

Argumento Callback

A opção de 'nome' especial <> pode ser usado para designar uma sub-rotina para lidar com argumentos não-opção. Quando GetOptions() encontra um argumento que não se parece com uma opção, ele irá chamar imediatamente essa sub-rotina e passa um parâmetro: o nome do argumento.

Bem, na verdade, é um objeto que stringifies para o nome do argumento.

Por exemplo:

    my $width = 80;
    sub process { ... }
    GetOptions ('width=i' => \$width, '<>' => \&process);

Quando aplicado para a seguinte linha de comando:

    arg1 --width=72 arg2 --width=60 arg3

Isto vai chamar process("arg1") enquanto $width é 80, enquanto process("arg2") $width é 72, e process("arg3") enquanto $width é 60.

Este recurso requer configuração opção de permuta, consulte a secção "Configurando Getopt :: Long" .

Answer 6

Este é um bom momento para lançar seu próprio analisador opção. Nenhum dos módulos que eu vi no CPAN fornecer este tipo de funcionalidade, e você pode sempre olhar para as suas implementações de obter um bom senso de como lidar com as porcas e parafusos de análise.

Como um aparte, este tipo de código faz com que me odeiam Getopt variantes:

use Getopt::Long;
&GetOptions(
    'name' => \$value
);

A capitalização inconsistente é enlouquecedora, mesmo para pessoas que tenham visto e usado esse estilo de código por um longo tempo.