Estilo de opções de linha de comando - POSIX ou o que?

14

Em algum lugar eu vi um discurso contra o java / javac, alegadamente usando uma mistura de estilo Windows e Unix como

java -classpath ... -ea ... Something

IMHO, não é mix, é como find funciona também, não é? AFAIK, de acordo com o POSIX, a sintaxe deveria ser como

java --classpath ... --ea ... Something

e -abcdef significariam especificar 6 opções curtas de uma só vez. Gostaria de saber qual versão leva, em geral, a menos digitação e menos erros.

Estou escrevendo um pequeno utilitário em Java e, em nenhum caso, vou usar o estilo /a /b do Windows, já que estou interessado principalmente no Unix. Qual estilo devo escolher?

    
por maaartinus 21.04.2011 / 22:44
fonte

4 respostas

19

Você pode encontrar as convenções de argumento POSIX no capítulo Convenções de Utilidades . O estilo POSIX consiste em opções com um único traço seguido por uma única letra indicando a opção, com o valor do argumento separado da opção por um espaço.

Há exceções às regras - find , por exemplo -, mas elas são causadas pelos precedentes históricos do Unix.

O X Windows (X11) usa find , como as opções de nome único e traço único.

As opções de nome longo de traço duplo foram iniciadas pelo GNU (após um desvio usando + como prefixo).

Veja este StackOverflow pergunta para uma discussão sobre a grande variedade de sistemas de manipulação de argumentos de linha de comando conhecidos - há muitos. ( Como isso foi escrito, os poderes que decidiram que a pergunta SO 367309 não era uma boa opção para SO. Eu transferi a resposta para outra pergunta, Qual é a sintaxe geral de um comando shell Unix? . )

Você pode estender a lista de técnicas para cobrir git (e vários outros sistemas) onde você obtém uma estrutura como:

  • basecommand [ opções globais ] subcommand [ opções de subcomando ] [nome ...]

Pode haver muitos subcomandos, cada um com seu próprio léxico de opções.

É claro que o Windows usa (usado) barra ' / ' para indicar opções em vez de traço ' - '.

O JCL (para sistemas z / OS, OS / 360 e intermediários) tende a usar parâmetros posicionais separados por vírgulas e geralmente é considerado não amigável ao usuário ou uma boa interface.

    
por 22.04.2011 / 04:35
fonte
15

EDIT: Tem sido apontado que este estilo é um GNU-ismo, e que os Unixes não baseados em GNU tendem a usar uma sintaxe de traço único (em particular, variantes OS X e BSD) .

Apesar do status do GNU-ism, muitos programas recém-escritos no estilo Unix usam esse estilo:

  • --long-option para nomes de opções longas,
  • -s para opções curtas (um caractere),
  • -abc para várias opções curtas sem argumentos (um caractere por opção).
  • Opções com argumentos:
    • --long arg ou --long=arg para opções longas,
    • -s arg , -sarg ou (opcionalmente) -s=arg para opções curtas. Isso pode ser combinado com outras opções curtas, contanto que somente o último tenha um argumento.
  • A mesma opção "semântica" pode ter vários aliases, mais comumente um curto (mais rápido para digitar) e um longo (mais fácil de lembrar) um.

Qualquer um que tenha usado um shell Linux por qualquer período de tempo deve estar familiarizado com este estilo 1 , então ele tem o princípio de menor surpresa do seu lado. Permitir o agrupamento de múltiplas opções curtas sem ser ambíguo com opções longas também é bom.

1 Por exemplo, alguns dos programas que usam esse estilo (na minha máquina Linux): ls , grep , man , sed , bash , etc. ( EDIT: estes são aparentemente GNU-isms, máquinas BSD e OS X não usam este estilo)

Existem várias bibliotecas que podem tratar de analisar isso para você (o mais conhecido é Implementação do GNU de getopt ), precisando apenas que você especifique quais opções longas e curtas existem, se elas um argumento e o que fazer quando uma opção é encontrada. (E, claro, o que fazer para argumentos posicionais, ou seja, aqueles que não começam com - e não são argumentos para as opções anteriores)

find é um programa muito antigo (ou talvez mais provável: uma versão reescrita de um programa muito antigo) que não pode ser facilmente alterado para usar uma nova sintaxe de linha de comando. Muitos scripts quebrariam, e muitos usuários acostumados com a antiga sintaxe se queixariam. javac foi provavelmente influenciado por gcc e amigos, que também seguem uma antiga sintaxe por razões históricas.

    
por 22.04.2011 / 00:19
fonte
7
  • Argumento com traço de traço ( --long-arg ) é uma convenção da GNU (consulte o implementação de getopt ).
  • Os comandos POSIX nunca usam argumentos de traço duplo. Isso se aplica à maioria das variantes do Unix (Mac OS X, BSD), exceto o Linux, que usa o GNU por padrão.

Para o seu projeto Java, você pode querer dar uma olhada no GNU getopt for Java ou Apache CLI . Eles suportam ambas as convenções.

Uma terceira opção é usar argumentos Java VM e deixar o tempo de execução analisá-los para você:

 $ java -Dcolor=blue

E então, no código:

 System.getProperty("color");

Pessoalmente, usaria o -D idiom e envolvesse o incantation Java em um script de shell que lida com a análise de linha de comando, incluindo a verificação do classpath, etc. Isso também facilita para os usuários nativos executarem o programa Java. / p>     

por 22.04.2011 / 12:58
fonte
1

Depende. Eu pessoalmente prefiro o estilo POSIX, mas no seu caso eu provavelmente teria como objetivo a consistência com o ambiente no qual sua ferramenta será usada. Isso significa usar a convenção Java para JARs (a menos que você planeje ter um script de wrapper que faria com que parecesse um comando típico do Unix).

    
por 22.04.2011 / 00:15
fonte