Como analiso argumentos opcionais em um script bash se nenhuma ordem é dada?

Estou confuso sobre como incluir argumentos / sinalizadores opcionais ao escrever um script bash para o seguinte programa:

O programa requer dois argumentos:

run_program --flag1 <value> --flag2 <value>

No entanto, existem vários sinalizadores opcionais:

run_program --flag1 <value> --flag2 <value> --optflag1 <value> --optflag2 <value> --optflag3 <value> --optflag4 <value> --optflag5 <value> 

Eu gostaria de executar o script bash de forma que ele receba argumentos do usuário. Se os usuários digitarem apenas dois argumentos em ordem, seria:

#!/bin/sh

run_program --flag1 $1 --flag2 $2

Mas e se algum dos argumentos opcionais for incluído? Eu pensaria que seria

if [ --optflag1 "$3" ]; then
    run_program --flag1 $1 --flag2 $2 --optflag1 $3
fi

Mas e se $ 4 forem dados, mas não $ 3?

Este artigo mostra duas maneiras diferentes - shifte getopts(e discute as vantagens e desvantagens das duas abordagens).

Com o shiftseu script $1, ele decide qual ação executar e, em seguida shift, executa , movendo $2para $1, $3para $2etc.

Por exemplo:

while :; do
    case $1 in
        -a|--flag1) flag1="SET"            
        ;;
        -b|--flag2) flag2="SET"            
        ;;
        -c|--optflag1) optflag1="SET"            
        ;;
        -d|--optflag2) optflag2="SET"            
        ;;
        -e|--optflag3) optflag3="SET"            
        ;;
        *) break
    esac
    shift
done

Com getoptsvocê, defina as opções (curtas) na whileexpressão:

while getopts abcde opt; do
    case $opt in
        a) flag1="SET"
        ;;
        b) flag2="SET"
        ;;
        c) optflag1="SET"
        ;;
        d) optflag2="SET"
        ;;
        e) optflag3="SET"
        ;;
    esac
done

Obviamente, esses são apenas trechos de código e deixei de lado a validação - verificando se os argumentos obrigatórios flag1 e flag2 estão definidos, etc.

Qual abordagem você usa é, até certo ponto, uma questão de gosto - quão portátil você deseja que seu script seja, se você pode viver apenas com opções curtas (POSIX) ou se deseja opções longas (GNU) etc.

use uma matriz.

#!/bin/bash

args=( --flag1 "$1" --flag2 "$2" )
[  "x$3" = xFALSE ] ||  args+=( --optflag1 "$3" )
[  "x$4" = xFALSE ] ||  args+=( --optflag2 "$4" )
[  "x$5" = xFALSE ] ||  args+=( --optflag3 "$5" )
[  "x$6" = xFALSE ] ||  args+=( --optflag4 "$6" )
[  "x$7" = xFALSE ] ||  args+=( --optflag5 "$7" )

program_name "${args[@]}"

isso manipulará argumentos com espaços neles corretamente.

[edit] Eu estava usando a sintaxe aproximadamente equivalente, args=( "${args[@]}" --optflag1 "$3" )mas o G-Man sugeriu uma maneira melhor.

Em um script de shell, os argumentos são "$ 1", "$ 2", "$ 3" etc. O número de argumentos é $ #.
Se o seu script não reconhecer opções, você pode deixar de fora a detecção de opções e tratar todos os argumentos como operandos.
Para reconhecer opções, use as getopts internas

Se suas opções de entrada são posicionais (você sabe em que lugares eles estão) e não são especificadas com sinalizadores, o que você deseja é apenas construir a linha de comando. Basta preparar os argumentos de comando para todos eles:

FLAG1="--flag1 $1"
FLAG2="--flag2 $2"
OPTFLAG1=""
OPTFLAG2=""
OPTFLAG3=""
if [ xFALSE != x"$3" ]; then
   OPTFLAG1="--optflag1 $3"
fi
if [ xFALSE != x"$4" ]; then
   OPTFLAG2="--optflag2 $4"
fi
#the same for other flags

#now just run the program
runprogram $FLAG1 $FLAG2 $OPTFLAG1 $OPTFLAG2 $OPTFLAG3

Se os parâmetros não forem especificados, as seqüências correspondentes estarão vazias e se expandirão em nada. Observe que na última linha, não há aspas. Isso porque você deseja que o shell divida os parâmetros em palavras (para fornecer --flag1e $1como argumentos separados para o seu programa). Obviamente, isso dará errado se seus parâmetros originais contiverem espaços. Se você é quem está executando isso, pode deixá-lo, mas se for um script geral, ele poderá ter um comportamento inesperado se o usuário inserir algo com espaços. Para lidar com isso, você precisará tornar o código um pouco mais feio.

O xprefixo no []teste está lá $3ou $4está vazio. Nesse caso, o bash se expandirá [ FALSE != $3 ]para o [ FALSE != ]que é um erro de sintaxe, então outro caractere arbitrário existe para se proteger contra isso. Essa é uma maneira muito comum, você a verá em muitos scripts.

Eu configurei OPTFLAG1e o restante deles ""no início apenas para ter certeza (no caso de eles terem sido configurados para algo antes), mas se eles não foram realmente declarados no ambiente, você não precisa fazer isso estritamente.

Algumas observações adicionais:

• Você pode realmente receber os parâmetros da mesma maneira que recebe runprogram: com sinalizadores. É disso que John Nse trata. É aí que getoptsse torna útil.
• Usar FALSE para esse objetivo é um pouco incomum e bastante longo. Normalmente, usaria-se um único caractere (possivelmente -) para sinalizar um valor vazio, ou apenas passasse uma string vazia, como "", se isso não for um valor válido do parâmetro. String vazia também torna o teste mais curto, basta usar if [ -n "$3" ].
• Se houver apenas um sinalizador opcional, ou se eles dependem, para que você nunca possa ter o OPTFLAG2, mas não o OPTFLAG1, poderá simplesmente pular os que não deseja definir. Se você usar ""parâmetros vazios, como sugerido acima, poderá pular todos os vazios finais de qualquer maneira.

Esse método é basicamente o modo como as opções são passadas para os compiladores no Makefiles.

E novamente - se as entradas podem conter espaços, fica feio.