Usando getopts para processar longas e curtas opções de linha de comando
https://stackoverflow.com/questions/402377
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Gostaria de ter longa e formas curtas de opções de linha de comando chamado usando meu script shell.
Eu sei que getopts pode ser usado, mas como em Perl, eu não tenho sido capaz de fazer o mesmo com shell.
Algumas ideias sobre como isso pode ser feito, para que eu possa usar opções como:
./shell.sh --copyfile abc.pl /tmp/
./shell.sh -c abc.pl /tmp/
No exemplo acima, ambos os comandos significam a mesma coisa para o meu escudo, mas usando getopts, eu não tenho sido capaz de implementar isso?
Solução
Há três implementações que podem ser considerados:
-
Bash
getoptsbuiltin. Este não suporta nomes de opções longas com o prefixo duplo traço. Ele suporta apenas as opções de caracteres simples. -
implementação BSD UNIX de comando autônomo
getopt(que é o MacOS usos). Este não suporta opções longas também. -
implementação GNU de
getoptindependente. GNUgetopt(3)(utilizado pela de linha de comandogetopt(1)no Linux) suporta a análise opções longas.
Algumas outras respostas mostram uma solução para usar a festa builtin getopts para opções longas imitar. Essa solução, na verdade, faz uma curta opção cujo caráter é "-". Então você começa "-" como a bandeira. Então qualquer coisa seguinte que se torna OPTARG, e você testar a OPTARG com um case aninhada.
Esta é inteligente, mas ele vem com ressalvas:
-
getoptsnão pode impor a especificação opt. Ele não pode retornar erros se o usuário fornece uma opção inválida. Você tem que fazer o seu próprio como de verificação de erros você analisar OPTARG. - OPTARG é utilizado para o nome da opção de comprimento, o que complica o uso quando seu longa-se opção tem um argumento. Você acabam por ter de código que se como um caso adicional.
Assim, embora seja possível escrever mais código para trabalho em torno da falta de apoio para as opções longas, este é um trabalho muito mais e derrota parcialmente o propósito de usar um analisador getopt para simplificar o seu código.
Outras dicas
getopt e getopts são diferentes animais, e as pessoas parecem ter um pouco de mal-entendido sobre o que eles fazem. getopts é um built-in comando para bash a opções de linha de comando do processo em um loop e atribuir a cada opção encontrada e valor em vez de variáveis ??internas, para que possa ainda processá-los. getopt, no entanto, é um programa utilitário externo, e não realmente processar suas opções para você a maneira que por exemplo getopts bash, o módulo Getopt Perl ou Python optparse / argparse módulos fazer. Tudo o que faz é getopt canonicalize as opções que são passadas em - ou seja, convertê-los em uma forma mais padrão, de modo que é mais fácil para um shell script para processá-los. Por exemplo, um aplicativo de getopt pode converter o seguinte:
myscript -ab infile.txt -ooutfile.txt
a este:
myscript -a -b -o outfile.txt infile.txt
Você tem que fazer o processamento real mesmo. Você não tem que usar getopt em tudo, se você fizer várias restrições sobre a forma como você pode especificar opções:
- só colocar uma opção por argumento;
- todas as opções de ir antes de quaisquer parâmetros posicionais (argumentos ou seja, não-opção);
- para opções com valores (por exemplo
-oacima), o valor tem que ir como um argumento separado (após um espaço).
Por que usar getopt vez de getopts? A razão básica é que apenas GNU getopt lhe dá suporte para as opções de linha de comando longo nomeados. 1 (GNU getopt é o padrão no Linux. Mac OS X e FreeBSD vem com um básico e não muito getopt -Útil, mas a versão GNU pode ser instalado; ver abaixo).
Por exemplo, aqui está um exemplo do uso GNU getopt, a partir de um roteiro de mina chamada javawrap:
# NOTE: This requires GNU getopt. On Mac OS X and FreeBSD, you have to install this
# separately; see below.
TEMP=`getopt -o vdm: --long verbose,debug,memory:,debugfile:,minheap:,maxheap: \
-n 'javawrap' -- "$@"`
if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
# Note the quotes around `$TEMP': they are essential!
eval set -- "$TEMP"
VERBOSE=false
DEBUG=false
MEMORY=
DEBUGFILE=
JAVA_MISC_OPT=
while true; do
case "$1" in
-v | --verbose ) VERBOSE=true; shift ;;
-d | --debug ) DEBUG=true; shift ;;
-m | --memory ) MEMORY="$2"; shift 2 ;;
--debugfile ) DEBUGFILE="$2"; shift 2 ;;
--minheap )
JAVA_MISC_OPT="$JAVA_MISC_OPT -XX:MinHeapFreeRatio=$2"; shift 2 ;;
--maxheap )
JAVA_MISC_OPT="$JAVA_MISC_OPT -XX:MaxHeapFreeRatio=$2"; shift 2 ;;
-- ) shift; break ;;
* ) break ;;
esac
done
Isso permite que você especificar opções como --verbose -dm4096 --minh=20 --maxhe 40 --debugfi="/Users/John Johnson/debug.txt" ou similar. O efeito da chamada para getopt é canonizar as opções para --verbose -d -m 4096 --minheap 20 --maxheap 40 --debugfile "/Users/John Johnson/debug.txt" para que você possa mais facilmente processá-los. O "$1" e "$2" citando volta é importante, pois garante que os argumentos com espaços entre eles se tratada adequadamente.
Se você excluir os primeiros 9 linhas (tudo através da linha eval set), o código irá ainda trabalho ! No entanto, seu código será muito mais exigente no que tipos de opções aceita: Em particular, você terá que especificar todas as opções na forma "canônica" descrito acima. Com o uso de getopt, no entanto, você pode opções único grupo letras, usar mais curtos formas não ambíguas de longo opções, utilize o --file foo.txt ou --file=foo.txt estilo, usar o estilo -m 4096 ou -m4096, misture opções e não-opções qualquer ordem, etc. getopt também gera uma mensagem de erro se as opções não reconhecidas ou ambíguas são encontrados.
NOTA : Na verdade, existem dois totalmente diferente versões do getopt, getopt básico e GNU getopt, com diferentes características e diferentes convenções de chamada 2 getopt básico é bastante quebrado: não só não lidar com opções de comprimento, ele também não pode sequer lidar com espaços incorporados dentro de argumentos ou argumentos vazios, enquanto getopts faz fazer isso direito. O código acima não vai funcionar no getopt básico. GNU getopt é instalado por padrão no Linux, mas no Mac OS X e FreeBSD ele precisa ser instalado separadamente. No Mac OS X, instalar MacPorts ( http://www.macports.org ) e depois fazer sudo port install getopt instalar GNU getopt (geralmente em /opt/local/bin ), e certifique-se de que /opt/local/bin está em seu caminho shell antes do /usr/bin. no FreeBSD, Instale misc/getopt.
Um guia rápido para modificar o código de exemplo para o seu próprio programa: Das primeiras linhas, tudo é "clichê" que deve permanecer o mesmo, exceto a linha que as chamadas getopt. Você deve alterar o nome do programa após -n, especifique as opções curtas após -o e opções longas após --long. Coloque uma vírgula após opções que levam um valor.
Finalmente, se você ver o código que acaba de set vez de eval set, ele foi escrito para BSD getopt. Você deve alterá-lo para usar o estilo eval set, que funciona bem com ambas as versões do getopt, enquanto o set simples não funciona direito com GNU getopt.
1 Na verdade, getopts em suportes ksh93 opções de longo nomeados, mas este shell não é usado tão frequentemente como bash. Em zsh, uso zparseopts para obter essa funcionalidade.
2 Tecnicamente, "GNU getopt" é um equívoco; esta versão foi realmente escrito para Linux em vez do projeto GNU. No entanto, ele segue todas as convenções GNU, e o termo "GNU getopt" é comumente usado (por exemplo, no FreeBSD).
O Bash builtin getopts função pode ser usada para analisar opções longas, colocando um personagem traço seguido de dois pontos para o optspec:
#!/usr/bin/env bash
optspec=":hv-:"
while getopts "$optspec" optchar; do
case "${optchar}" in
-)
case "${OPTARG}" in
loglevel)
val="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
echo "Parsing option: '--${OPTARG}', value: '${val}'" >&2;
;;
loglevel=*)
val=${OPTARG#*=}
opt=${OPTARG%=$val}
echo "Parsing option: '--${opt}', value: '${val}'" >&2
;;
*)
if [ "$OPTERR" = 1 ] && [ "${optspec:0:1}" != ":" ]; then
echo "Unknown option --${OPTARG}" >&2
fi
;;
esac;;
h)
echo "usage: $0 [-v] [--loglevel[=]<value>]" >&2
exit 2
;;
v)
echo "Parsing option: '-${optchar}'" >&2
;;
*)
if [ "$OPTERR" != 1 ] || [ "${optspec:0:1}" = ":" ]; then
echo "Non-option argument: '-${OPTARG}'" >&2
fi
;;
esac
done
Depois de copiar a nome do arquivo executável = getopts_test.sh no diretório de trabalho atual , pode-se produzir uma saída como
$ ./getopts_test.sh
$ ./getopts_test.sh -f
Non-option argument: '-f'
$ ./getopts_test.sh -h
usage: code/getopts_test.sh [-v] [--loglevel[=]<value>]
$ ./getopts_test.sh --help
$ ./getopts_test.sh -v
Parsing option: '-v'
$ ./getopts_test.sh --very-bad
$ ./getopts_test.sh --loglevel
Parsing option: '--loglevel', value: ''
$ ./getopts_test.sh --loglevel 11
Parsing option: '--loglevel', value: '11'
$ ./getopts_test.sh --loglevel=11
Parsing option: '--loglevel', value: '11'
Obviamente getopts nem executa OPTERR verificação, nem de análise opção de argumento para as opções longas. O fragmento de script acima mostra como isto pode ser feito manualmente. O princípio básico também funciona no Debian Almquist shell ( "dash"). Observe o caso especial:
getopts -- "-:" ## without the option terminator "-- " bash complains about "-:"
getopts "-:" ## this works in the Debian Almquist shell ("dash")
Note que, como Greycat de terminar em http://mywiki.wooledge.org/BashFAQ pontos para fora, este truque explora um comportamento fora do padrão da concha que permite a opção de argumento (ou seja, o nome do arquivo no "-f") a ser concatenado com a opção (como em "-fnome do arquivo"). A POSIX norma diz que deve haver um espaço entre eles, o que na caso de "- longoption". terminaria a opção de análise e transformar todos os longoptions em argumentos não-opção
O comando interno getopts é ainda, AFAIK, limitado a opções de caracteres única.
Há (ou costumava ser) um getopt programa externo que iria reorganizar um conjunto de opções, que era mais fácil de analisar. Você pode adaptar esse projeto para lidar com opções longas também. Exemplo de utilização:
aflag=no
bflag=no
flist=""
set -- $(getopt abf: "$@")
while [ $# -gt 0 ]
do
case "$1" in
(-a) aflag=yes;;
(-b) bflag=yes;;
(-f) flist="$flist $2"; shift;;
(--) shift; break;;
(-*) echo "$0: error - unrecognized option $1" 1>&2; exit 1;;
(*) break;;
esac
shift
done
# Process remaining non-option arguments
...
Você pode usar um esquema semelhante com um comando getoptlong.
Note que a fraqueza fundamental com o programa getopt externa é a dificuldade de lidar com argumentos com espaços neles, e em preservar esses espaços com precisão. É por isso que o built-in getopts é superior, embora limitada pelo fato de que só lida com opções de uma única letra.
Aqui está um exemplo que realmente usa getopt com longas opções:
aflag=no
bflag=no
cargument=none
# options may be followed by one colon to indicate they have a required argument
if ! options=$(getopt -o abc: -l along,blong,clong: -- "$@")
then
# something went wrong, getopt will put out an error message for us
exit 1
fi
set -- $options
while [ $# -gt 0 ]
do
case $1 in
-a|--along) aflag="yes" ;;
-b|--blong) bflag="yes" ;;
# for options with required arguments, an additional shift is required
-c|--clong) cargument="$2" ; shift;;
(--) shift; break;;
(-*) echo "$0: error - unrecognized option $1" 1>&2; exit 1;;
(*) break;;
esac
shift
done
opções longas podem ser analisados ??pelo builtin getopts padrão como “argumentos” para a “opção” -
Esta é portátil e nativa POSIX shell -. Não são necessários programas ou bashisms externos
Este guia implementos opções longas como argumentos para a opção -, assim --alpha é visto por getopts como - com alpha argumento e --bravo=foo é visto como - com bravo=foo argumento. O verdadeiro argumento pode ser colhida com uma substituição simples:. ${OPTARG#*=}
Neste exemplo, -b (e sua forma longa, --bravo) possui uma opção obrigatória (note a reconstrução manual dos reforçando que para a forma longa). Não-booleano opções para longos argumentos vir após sinais iguais, por exemplo, --bravo=foo (delimitadores de espaço para opções longas seria difícil de implementar).
Por isso usa getopts, esse uso suportes solução como cmd -ac --bravo=foo -d FILE (que combinou opções -a e -c e intercala longos opções com opções padrão), enquanto a maioria das outras respostas aqui qualquer luta ou deixar de fazer isso.
while getopts ab:c-: arg; do
case $arg in
a ) ARG_A=true ;;
b ) ARG_B="$OPTARG" ;;
c ) ARG_C=true ;;
- ) LONG_OPTARG="${OPTARG#*=}"
case $OPTARG in
alpha ) ARG_A=true ;;
bravo=?* ) ARG_B="$LONG_OPTARG" ;;
bravo* ) echo "No arg for --$OPTARG option" >&2; exit 2 ;;
charlie ) ARG_C=true ;;
alpha* | charlie* )
echo "No arg allowed for --$OPTARG option" >&2; exit 2 ;;
'' ) break ;; # "--" terminates argument processing
* ) echo "Illegal option --$OPTARG" >&2; exit 2 ;;
esac ;;
\? ) exit 2 ;; # getopts already reported the illegal option
esac
done
shift $((OPTIND-1)) # remove parsed options and args from $@ list
Quando o argumento é um traço (-), tem mais dois componentes: o nome da bandeira e (opcionalmente) o seu argumento. I delimitar estes a forma padrão qualquer comando seria, com o primeiro sinal de igual (=). $LONG_OPTARG é, portanto, apenas o conteúdo de $OPTARG sem o nome de bandeira ou sinal de igual.
Opções Os implementos case internos longos manualmente, por isso precisa de uma faxina:
-
bravo=?corresponde--bravo=foomas não--bravo=(nota:casepára após o primeiro jogo) -
bravo*segue, observando o argumento obrigatório faltando em--bravoe--bravo= - capturas
alpha* | charlie*argumentos dada às opções que não apoiá-los -
''está presente para apoiar não-opções que acontecem para começar com traços -
*pega todas as outras opções longas e recria o erro lançado pelo getopts para uma opção inválida
Você não precisa necessariamente todos esses itens de limpeza. Por exemplo, talvez você queira --bravo ter um opcional argumento (que -b não pode suportar devido a uma limitação no getopts). Simplesmente remova a =? eo caso de falha relacionada e ${ARG_B:=$DEFAULT_ARG_B} então chamada a primeira vez que você usar $ARG_B.
Para aceitar opções longas com argumentos delimitados por espaço, você vai precisar de uma eval (decentemente seguro):
bravo=?* ) ARG_B="$LONG_OPTARG" ;;
bravo ) eval "ARG_B=\"\$$OPTIND\""
if [ -z "$ARG_B" ]; then
echo "No arg for --$OPTARG option" >&2; exit 2
fi
OPTIND=$((OPTIND+1)) ;;
bravo* ) echo "No arg for --$OPTARG option" >&2; exit 2 ;;
Esta cláusula adicional, adicionado diretamente após a versão atribuição =, executa um eval para interpretar o valor do parâmetro a seguir a opção que está sendo interpretado na época. Bash pode fazer isso de forma mais limpa usando indireta expansão , ARG_B="${!OPTIND}" e Zsh pode fazê-lo com o parâmetro expansão P bandeira , ARGB="${(P)OPTIND}", mas o eval é necessário para ser totalmente portátil POSIX. $OPTIND é um número referindo-se ao próximo argumento shell, dizem $2 (significando $1 é --bravo). O eval seria, então, interpretar ARG_B="$2" e porque este está entre aspas, ele está a salvo de abuso (eu não poderia encontrar uma maneira de enganá-lo a fazer algo impróprio).
A garantia de um valor não vazio não é trivial e exige realmente verificando-lo, por isso temos uma condicional e gerar um erro fatal no thno caso. Se você permitir que ele seja vazio, você precisa conditionalize o incremento de $OPTIND ou então correr em um loop infinito. [ $# -gt $OPTIND ] && OPTIND=$((OPTIND+1)) deve fazer.
A parte final desta adição incrementos cláusula $OPTIND de absorver adequadamente o argumento da opção e passar para a próxima opção.
Dê uma olhada em shFlags que é uma biblioteca shell portátil (significado :.. sh, bash, traço, ksh, zsh no Linux, Solaris, etc)
Ele faz a adição de novas bandeiras tão simples como adicionar uma linha ao seu script, e fornece uma função de uso gerados automaticamente.
Aqui está uma Hello, world! simples usando shFlag :
#!/bin/sh
# source shflags from current directory
. ./shflags
# define a 'name' command-line string flag
DEFINE_string 'name' 'world' 'name to say hello to' 'n'
# parse the command-line
FLAGS "$@" || exit 1
eval set -- "${FLAGS_ARGV}"
# say hello
echo "Hello, ${FLAGS_name}!"
Para sistemas operacionais que têm o getopt avançada que suporta opções longos (por exemplo, Linux), você pode fazer:
$ ./hello_world.sh --name Kate
Hello, Kate!
Para o resto, você deve usar a opção curta:
$ ./hello_world.sh -n Kate
Hello, Kate!
A adição de uma nova bandeira é tão simples como adicionar um novo DEFINE_ call.
Usando getopts com curtos opções / longos e argumentos
Funciona com todas as combinações, p.ex.:
- foobar -f --bar
- foobar --foo -b
- foobar -bf --bar --foobar
- foobar -fbFBAshorty --bar FB --arguments = longhorn
- foobar -FA "baixinha texto" -B --arguments = "Longhorn texto"
- festa foobar -F --barfoo
- sh foobar -B --foobar - ...
- festa ./foobar -F --bar
Algumas declarações para este exemplo
Options=$@
Optnum=$#
sfoo='no '
sbar='no '
sfoobar='no '
sbarfoo='no '
sarguments='no '
sARG=empty
lfoo='no '
lbar='no '
lfoobar='no '
lbarfoo='no '
larguments='no '
lARG=empty
Como a função de Uso ficaria
function _usage()
{
###### U S A G E : Help and ERROR ######
cat <<EOF
foobar $Options
$*
Usage: foobar <[options]>
Options:
-b --bar Set bar to yes ($foo)
-f --foo Set foo to yes ($bart)
-h --help Show this message
-A --arguments=... Set arguments to yes ($arguments) AND get ARGUMENT ($ARG)
-B --barfoo Set barfoo to yes ($barfoo)
-F --foobar Set foobar to yes ($foobar)
EOF
}
[ $# = 0 ] && _usage " >>>>>>>> no options given "
getops com bandeiras longo / curto, assim como longos argumentos
while getopts ':bfh-A:BF' OPTION ; do
case "$OPTION" in
b ) sbar=yes ;;
f ) sfoo=yes ;;
h ) _usage ;;
A ) sarguments=yes;sARG="$OPTARG" ;;
B ) sbarfoo=yes ;;
F ) sfoobar=yes ;;
- ) [ $OPTIND -ge 1 ] && optind=$(expr $OPTIND - 1 ) || optind=$OPTIND
eval OPTION="\$$optind"
OPTARG=$(echo $OPTION | cut -d'=' -f2)
OPTION=$(echo $OPTION | cut -d'=' -f1)
case $OPTION in
--foo ) lfoo=yes ;;
--bar ) lbar=yes ;;
--foobar ) lfoobar=yes ;;
--barfoo ) lbarfoo=yes ;;
--help ) _usage ;;
--arguments ) larguments=yes;lARG="$OPTARG" ;;
* ) _usage " Long: >>>>>>>> invalid options (long) " ;;
esac
OPTIND=1
shift
;;
? ) _usage "Short: >>>>>>>> invalid options (short) " ;;
esac
done
saída
##################################################################
echo "----------------------------------------------------------"
echo "RESULT short-foo : $sfoo long-foo : $lfoo"
echo "RESULT short-bar : $sbar long-bar : $lbar"
echo "RESULT short-foobar : $sfoobar long-foobar : $lfoobar"
echo "RESULT short-barfoo : $sbarfoo long-barfoo : $lbarfoo"
echo "RESULT short-arguments: $sarguments with Argument = \"$sARG\" long-arguments: $larguments and $lARG"
Combinando o acima em um script coesa
#!/bin/bash
# foobar: getopts with short and long options AND arguments
function _cleanup ()
{
unset -f _usage _cleanup ; return 0
}
## Clear out nested functions on exit
trap _cleanup INT EXIT RETURN
###### some declarations for this example ######
Options=$@
Optnum=$#
sfoo='no '
sbar='no '
sfoobar='no '
sbarfoo='no '
sarguments='no '
sARG=empty
lfoo='no '
lbar='no '
lfoobar='no '
lbarfoo='no '
larguments='no '
lARG=empty
function _usage()
{
###### U S A G E : Help and ERROR ######
cat <<EOF
foobar $Options
$*
Usage: foobar <[options]>
Options:
-b --bar Set bar to yes ($foo)
-f --foo Set foo to yes ($bart)
-h --help Show this message
-A --arguments=... Set arguments to yes ($arguments) AND get ARGUMENT ($ARG)
-B --barfoo Set barfoo to yes ($barfoo)
-F --foobar Set foobar to yes ($foobar)
EOF
}
[ $# = 0 ] && _usage " >>>>>>>> no options given "
##################################################################
####### "getopts" with: short options AND long options #######
####### AND short/long arguments #######
while getopts ':bfh-A:BF' OPTION ; do
case "$OPTION" in
b ) sbar=yes ;;
f ) sfoo=yes ;;
h ) _usage ;;
A ) sarguments=yes;sARG="$OPTARG" ;;
B ) sbarfoo=yes ;;
F ) sfoobar=yes ;;
- ) [ $OPTIND -ge 1 ] && optind=$(expr $OPTIND - 1 ) || optind=$OPTIND
eval OPTION="\$$optind"
OPTARG=$(echo $OPTION | cut -d'=' -f2)
OPTION=$(echo $OPTION | cut -d'=' -f1)
case $OPTION in
--foo ) lfoo=yes ;;
--bar ) lbar=yes ;;
--foobar ) lfoobar=yes ;;
--barfoo ) lbarfoo=yes ;;
--help ) _usage ;;
--arguments ) larguments=yes;lARG="$OPTARG" ;;
* ) _usage " Long: >>>>>>>> invalid options (long) " ;;
esac
OPTIND=1
shift
;;
? ) _usage "Short: >>>>>>>> invalid options (short) " ;;
esac
done
Outra maneira ...
# translate long options to short
for arg
do
delim=""
case "$arg" in
--help) args="${args}-h ";;
--verbose) args="${args}-v ";;
--config) args="${args}-c ";;
# pass through anything else
*) [[ "${arg:0:1}" == "-" ]] || delim="\""
args="${args}${delim}${arg}${delim} ";;
esac
done
# reset the translated args
eval set -- $args
# now we can process with getopt
while getopts ":hvc:" opt; do
case $opt in
h) usage ;;
v) VERBOSE=true ;;
c) source $OPTARG ;;
\?) usage ;;
:)
echo "option -$OPTARG requires an argument"
usage
;;
esac
done
Eu meio que resolvido desta maneira:
# A string with command options
options=$@
# An array with all the arguments
arguments=($options)
# Loop index
index=0
for argument in $options
do
# Incrementing index
index=`expr $index + 1`
# The conditions
case $argument in
-a) echo "key $argument value ${arguments[index]}" ;;
-abc) echo "key $argument value ${arguments[index]}" ;;
esac
done
exit;
Am I ser burro ou algo assim? getopt e getopts são tão confuso.
No caso de você não quer a dependência getopt, você pode fazer isso:
while test $# -gt 0
do
case $1 in
# Normal option processing
-h | --help)
# usage and help
;;
-v | --version)
# version info
;;
# ...
# Special cases
--)
break
;;
--*)
# error unknown (long) option $1
;;
-?)
# error unknown (short) option $1
;;
# FUN STUFF HERE:
# Split apart combined short options
-*)
split=$1
shift
set -- $(echo "$split" | cut -c 2- | sed 's/./-& /g') "$@"
continue
;;
# Done with options
*)
break
;;
esac
# for testing purposes:
echo "$1"
shift
done
É claro, então você não pode usar opções de estilo de comprimento com um traço. E se você quiser adicionar versões encurtadas (por exemplo --verbos vez de --verbose), então você precisa adicionar os manualmente.
Mas se você estiver olhando para obter funcionalidade getopts juntamente com as opções longas, esta é uma maneira simples de fazê-lo.
Eu também colocar esse trecho em um essência .
A built-in getopts não pode fazer isso. Há um link externo getopt de programa (1) que pode fazer isso, mas você só obtê-lo no Linux a partir do util-linux pacote. Ele vem com um script de exemplo getopt-parse.bash .
Há também um getopts_long escrito como uma função shell.
#!/bin/bash
while getopts "abc:d:" flag
do
case $flag in
a) echo "[getopts:$OPTIND]==> -$flag";;
b) echo "[getopts:$OPTIND]==> -$flag";;
c) echo "[getopts:$OPTIND]==> -$flag $OPTARG";;
d) echo "[getopts:$OPTIND]==> -$flag $OPTARG";;
esac
done
shift $((OPTIND-1))
echo "[otheropts]==> $@"
exit
.
#!/bin/bash
until [ -z "$1" ]; do
case $1 in
"--dlong")
shift
if [ "${1:1:0}" != "-" ]
then
echo "==> dlong $1"
shift
fi;;
*) echo "==> other $1"; shift;;
esac
done
exit
Em ksh93, getopts suporta nomes longos ...
while getopts "f(file):s(server):" flag
do
echo "$flag" $OPTIND $OPTARG
done
Ou assim os tutoriais que eu encontrei disse. Experimente e veja.
Inventing ainda uma outra versão da roda ...
Esta função é uma substituição shell Bourne simples (espero) compatível com POSIX para GNU getopt. Ele suporta opções de curto / longo que podem aceitar obrigatórias / opcionais / sem argumentos, e a maneira pela qual as opções são especificadas é quase idêntico ao GNU getopt, então a conversão é trivial.
É claro que este ainda é um pedaço considerável de código para cair em um script, mas é cerca de metade das linhas da função shell getopt_long bem conhecido, e pode ser preferível nos casos em que você só quer substituir usos getopt GNU existentes .
Isso é muito novo código, então YMMV (e, definitivamente, por favor deixe-me saber se isso não é realmente compatível com POSIX, por qualquer razão - a portabilidade foi a intenção desde o início, mas eu não tenho um teste POSIX útil ambiente).
Código e exemplo de uso a seguir:
#!/bin/sh
# posix_getopt shell function
# Author: Phil S.
# Version: 1.0
# Created: 2016-07-05
# URL: http://stackoverflow.com/a/37087374/324105
# POSIX-compatible argument quoting and parameter save/restore
# http://www.etalabs.net/sh_tricks.html
# Usage:
# parameters=$(save "$@") # save the original parameters.
# eval "set -- ${parameters}" # restore the saved parameters.
save () {
local param
for param; do
printf %s\\n "$param" \
| sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/"
done
printf %s\\n " "
}
# Exit with status $1 after displaying error message $2.
exiterr () {
printf %s\\n "$2" >&2
exit $1
}
# POSIX-compatible command line option parsing.
# This function supports long options and optional arguments, and is
# a (largely-compatible) drop-in replacement for GNU getopt.
#
# Instead of:
# opts=$(getopt -o "$shortopts" -l "$longopts" -- "$@")
# eval set -- ${opts}
#
# We instead use:
# opts=$(posix_getopt "$shortopts" "$longopts" "$@")
# eval "set -- ${opts}"
posix_getopt () { # args: "$shortopts" "$longopts" "$@"
local shortopts longopts \
arg argtype getopt nonopt opt optchar optword suffix
shortopts="$1"
longopts="$2"
shift 2
getopt=
nonopt=
while [ $# -gt 0 ]; do
opt=
arg=
argtype=
case "$1" in
# '--' means don't parse the remaining options
( -- ) {
getopt="${getopt}$(save "$@")"
shift $#
break
};;
# process short option
( -[!-]* ) { # -x[foo]
suffix=${1#-?} # foo
opt=${1%$suffix} # -x
optchar=${opt#-} # x
case "${shortopts}" in
( *${optchar}::* ) { # optional argument
argtype=optional
arg="${suffix}"
shift
};;
( *${optchar}:* ) { # required argument
argtype=required
if [ -n "${suffix}" ]; then
arg="${suffix}"
shift
else
case "$2" in
( -* ) exiterr 1 "$1 requires an argument";;
( ?* ) arg="$2"; shift 2;;
( * ) exiterr 1 "$1 requires an argument";;
esac
fi
};;
( *${optchar}* ) { # no argument
argtype=none
arg=
shift
# Handle multiple no-argument parameters combined as
# -xyz instead of -x -y -z. If we have just shifted
# parameter -xyz, we now replace it with -yz (which
# will be processed in the next iteration).
if [ -n "${suffix}" ]; then
eval "set -- $(save "-${suffix}")$(save "$@")"
fi
};;
( * ) exiterr 1 "Unknown option $1";;
esac
};;
# process long option
( --?* ) { # --xarg[=foo]
suffix=${1#*=} # foo (unless there was no =)
if [ "${suffix}" = "$1" ]; then
suffix=
fi
opt=${1%=$suffix} # --xarg
optword=${opt#--} # xarg
case ",${longopts}," in
( *,${optword}::,* ) { # optional argument
argtype=optional
arg="${suffix}"
shift
};;
( *,${optword}:,* ) { # required argument
argtype=required
if [ -n "${suffix}" ]; then
arg="${suffix}"
shift
else
case "$2" in
( -* ) exiterr 1 \
"--${optword} requires an argument";;
( ?* ) arg="$2"; shift 2;;
( * ) exiterr 1 \
"--${optword} requires an argument";;
esac
fi
};;
( *,${optword},* ) { # no argument
if [ -n "${suffix}" ]; then
exiterr 1 "--${optword} does not take an argument"
fi
argtype=none
arg=
shift
};;
( * ) exiterr 1 "Unknown option $1";;
esac
};;
# any other parameters starting with -
( -* ) exiterr 1 "Unknown option $1";;
# remember non-option parameters
( * ) nonopt="${nonopt}$(save "$1")"; shift;;
esac
if [ -n "${opt}" ]; then
getopt="${getopt}$(save "$opt")"
case "${argtype}" in
( optional|required ) {
getopt="${getopt}$(save "$arg")"
};;
esac
fi
done
# Generate function output, suitable for:
# eval "set -- $(posix_getopt ...)"
printf %s "${getopt}"
if [ -n "${nonopt}" ]; then
printf %s "$(save "--")${nonopt}"
fi
}
Exemplo de utilização:
# Process command line options
shortopts="hvd:c::s::L:D"
longopts="help,version,directory:,client::,server::,load:,delete"
#opts=$(getopt -o "$shortopts" -l "$longopts" -n "$(basename $0)" -- "$@")
opts=$(posix_getopt "$shortopts" "$longopts" "$@")
if [ $? -eq 0 ]; then
#eval set -- ${opts}
eval "set -- ${opts}"
while [ $# -gt 0 ]; do
case "$1" in
( -- ) shift; break;;
( -h|--help ) help=1; shift; break;;
( -v|--version ) version_help=1; shift; break;;
( -d|--directory ) dir=$2; shift 2;;
( -c|--client ) useclient=1; client=$2; shift 2;;
( -s|--server ) startserver=1; server_name=$2; shift 2;;
( -L|--load ) load=$2; shift 2;;
( -D|--delete ) delete=1; shift;;
esac
done
else
shorthelp=1 # getopt returned (and reported) an error.
fi
I scripts shell só escrevo agora e, em seguida, e cair fora da prática, portanto, qualquer feedback é apreciado.
Usando a estratégia proposta pela @Arvid Requate, notamos alguns erros do usuário. Um usuário que se esquece de incluir um valor acidentalmente ter o nome do próximo opção tratado como um valor:
./getopts_test.sh --loglevel= --toc=TRUE
fará com que o valor de "loglevel" a ser visto como "--toc = TRUE". Isso pode ser evitado.
Eu adaptei algumas ideias sobre a verificação de erros de utilizador para CLI de http://mwiki.wooledge.org/BashFAQ / 035 discussão de análise manual. I inserido verificação de erros no tratamento de ambas as "-" e "-" argumentos.
Então eu comecei a brincar com a sintaxe, de modo que quaisquer erros aqui são estritamente culpa minha, não dos autores originais.
A minha abordagem ajuda os usuários que preferem para entrar longo com ou sem o sinal de igual. Ou seja, ele deve ter mesma resposta para "--loglevel 9" como "--loglevel = 9". No - / método de espaço, não é possível saber com certeza se o usuário esquecer um argumento, de modo algum adivinhar é necessário.
- se o usuário tem o formato de sinal de long / igual (--opt =), então um espaço após = desencadeia um erro porque um argumento não foi fornecido.
- se o usuário tem uma longa / argumentos espaciais (--opt), este script faz com que a falha se nenhum argumento segue (fim do comando), ou se o argumento começa com traço)
No caso de você está começando com isso, há uma diferença interessante entre "--opt = valor" e formatos de "valor --opt". Com o sinal de igual, o argumento de linha de comando é visto como "opt = valor" e o trabalho de lidar com isso é uma string de análise, para separar o "=". Em contraste, com "valor --opt", o nome do argumento é "opt" e temos o desafio de obter o próximo valor fornecido na linha de comando. É aí que @Arvid Requate usado $ {! OPTIND}, a referência indirecta. Eu ainda não entendo que, bem, em tudo, e comentários em BashFAQ parecem alertar contra esse estilo ( http : //mywiki.wooledge.org/BashFAQ/006 ). BTW, eu não acho que os comentários de cartaz anterior sobre a importância de OPTIND = $ (($ OPTIND + 1)) estão corretas. Quero dizer, não vejo nenhum dano de omiti-lo.
Na versão mais recente deste roteiro, meios bandeira -v VERBOSE impressão.
salvá-lo em um arquivo chamado "cli-5.sh", tornar executável, e qualquer um deles vai funcionar, ou não da maneira desejada
./cli-5.sh -v --loglevel=44 --toc TRUE
./cli-5.sh -v --loglevel=44 --toc=TRUE
./cli-5.sh --loglevel 7
./cli-5.sh --loglevel=8
./cli-5.sh -l9
./cli-5.sh --toc FALSE --loglevel=77
./cli-5.sh --toc=FALSE --loglevel=77
./cli-5.sh -l99 -t yyy
./cli-5.sh -l 99 -t yyy
Aqui está um exemplo de saída da verificação de erros em user intpu
$ ./cli-5.sh --toc --loglevel=77
ERROR: toc value must not have dash at beginning
$ ./cli-5.sh --toc= --loglevel=77
ERROR: value for toc undefined
Você deve considerar ligar -v, porque ele imprime internos do OPTIND e OPTARG
#/usr/bin/env bash
## Paul Johnson
## 20171016
##
## Combines ideas from
## https://stackoverflow.com/questions/402377/using-getopts-in-bash-shell-script-to-get-long-and-short-command-line-options
## by @Arvid Requate, and http://mwiki.wooledge.org/BashFAQ/035
# What I don't understand yet:
# In @Arvid REquate's answer, we have
# val="${!OPTIND}"; OPTIND=$(( $OPTIND + 1 ))
# this works, but I don't understand it!
die() {
printf '%s\n' "$1" >&2
exit 1
}
printparse(){
if [ ${VERBOSE} -gt 0 ]; then
printf 'Parse: %s%s%s\n' "$1" "$2" "$3" >&2;
fi
}
showme(){
if [ ${VERBOSE} -gt 0 ]; then
printf 'VERBOSE: %s\n' "$1" >&2;
fi
}
VERBOSE=0
loglevel=0
toc="TRUE"
optspec=":vhl:t:-:"
while getopts "$optspec" OPTCHAR; do
showme "OPTARG: ${OPTARG[*]}"
showme "OPTIND: ${OPTIND[*]}"
case "${OPTCHAR}" in
-)
case "${OPTARG}" in
loglevel) #argument has no equal sign
opt=${OPTARG}
val="${!OPTIND}"
## check value. If negative, assume user forgot value
showme "OPTIND is {$OPTIND} {!OPTIND} has value \"${!OPTIND}\""
if [[ "$val" == -* ]]; then
die "ERROR: $opt value must not have dash at beginning"
fi
## OPTIND=$(( $OPTIND + 1 )) # CAUTION! no effect?
printparse "--${OPTARG}" " " "${val}"
loglevel="${val}"
shift
;;
loglevel=*) #argument has equal sign
opt=${OPTARG%=*}
val=${OPTARG#*=}
if [ "${OPTARG#*=}" ]; then
printparse "--${opt}" "=" "${val}"
loglevel="${val}"
## shift CAUTION don't shift this, fails othewise
else
die "ERROR: $opt value must be supplied"
fi
;;
toc) #argument has no equal sign
opt=${OPTARG}
val="${!OPTIND}"
## check value. If negative, assume user forgot value
showme "OPTIND is {$OPTIND} {!OPTIND} has value \"${!OPTIND}\""
if [[ "$val" == -* ]]; then
die "ERROR: $opt value must not have dash at beginning"
fi
## OPTIND=$(( $OPTIND + 1 )) #??
printparse "--${opt}" " " "${val}"
toc="${val}"
shift
;;
toc=*) #argument has equal sign
opt=${OPTARG%=*}
val=${OPTARG#*=}
if [ "${OPTARG#*=}" ]; then
toc=${val}
printparse "--$opt" " -> " "$toc"
##shift ## NO! dont shift this
else
die "ERROR: value for $opt undefined"
fi
;;
help)
echo "usage: $0 [-v] [--loglevel[=]<value>] [--toc[=]<TRUE,FALSE>]" >&2
exit 2
;;
*)
if [ "$OPTERR" = 1 ] && [ "${optspec:0:1}" != ":" ]; then
echo "Unknown option --${OPTARG}" >&2
fi
;;
esac;;
h|-\?|--help)
## must rewrite this for all of the arguments
echo "usage: $0 [-v] [--loglevel[=]<value>] [--toc[=]<TRUE,FALSE>]" >&2
exit 2
;;
l)
loglevel=${OPTARG}
printparse "-l" " " "${loglevel}"
;;
t)
toc=${OPTARG}
;;
v)
VERBOSE=1
;;
*)
if [ "$OPTERR" != 1 ] || [ "${optspec:0:1}" = ":" ]; then
echo "Non-option argument: '-${OPTARG}'" >&2
fi
;;
esac
done
echo "
After Parsing values
"
echo "loglevel $loglevel"
echo "toc $toc"
Aqui você pode encontrar algumas abordagens diferentes para complexo de análise opção no bash: http://mywiki.wooledge.org/ComplexOptionParsing
Eu criei o seguinte, e eu acho que é uma boa, porque é o mínimo de código e ambos longa e opções curtas trabalho. Uma longa opção também pode ter vários argumentos com esta abordagem.
#!/bin/bash
# Uses bash extensions. Not portable as written.
declare -A longoptspec
longoptspec=( [loglevel]=1 ) #use associative array to declare how many arguments a long option expects, in this case we declare that loglevel expects/has one argument, long options that aren't listed i n this way will have zero arguments by default
optspec=":h-:"
while getopts "$optspec" opt; do
while true; do
case "${opt}" in
-) #OPTARG is name-of-long-option or name-of-long-option=value
if [[ "${OPTARG}" =~ .*=.* ]] #with this --key=value format only one argument is possible
then
opt=${OPTARG/=*/}
OPTARG=${OPTARG#*=}
((OPTIND--))
else #with this --key value1 value2 format multiple arguments are possible
opt="$OPTARG"
OPTARG=(${@:OPTIND:$((longoptspec[$opt]))})
fi
((OPTIND+=longoptspec[$opt]))
continue #now that opt/OPTARG are set we can process them as if getopts would've given us long options
;;
loglevel)
loglevel=$OPTARG
;;
h|help)
echo "usage: $0 [--loglevel[=]<value>]" >&2
exit 2
;;
esac
break; done
done
# End of file
Tenho vindo a trabalhar sobre o assunto por um longo tempo ... e fiz minha própria biblioteca, que terá de fonte em seu script principal. Consulte libopt4shell e cd2mpc para um exemplo. Espero que ajude!
Uma solução melhorada:
# translate long options to short
# Note: This enable long options but disable "--?*" in $OPTARG, or disable long options after "--" in option fields.
for ((i=1;$#;i++)) ; do
case "$1" in
--)
# [ ${args[$((i-1))]} == ... ] || EndOpt=1 ;;& # DIRTY: we still can handle some execptions...
EndOpt=1 ;;&
--version) ((EndOpt)) && args[$i]="$1" || args[$i]="-V";;
# default case : short option use the first char of the long option:
--?*) ((EndOpt)) && args[$i]="$1" || args[$i]="-${1:2:1}";;
# pass through anything else:
*) args[$i]="$1" ;;
esac
shift
done
# reset the translated args
set -- "${args[@]}"
function usage {
echo "Usage: $0 [options] files" >&2
exit $1
}
# now we can process with getopt
while getopts ":hvVc:" opt; do
case $opt in
h) usage ;;
v) VERBOSE=true ;;
V) echo $Version ; exit ;;
c) source $OPTARG ;;
\?) echo "unrecognized option: -$opt" ; usage -1 ;;
:)
echo "option -$OPTARG requires an argument"
usage -1
;;
esac
done
shift $((OPTIND-1))
[[ "$1" == "--" ]] && shift
Talvez seja mais simples de usar ksh, apenas para a parte getopts, se as opções de linha de comando necessidade longa, pois ele pode ser mais fácil feito lá.
# Working Getopts Long => KSH
#! /bin/ksh
# Getopts Long
USAGE="s(showconfig)"
USAGE+="c:(createdb)"
USAGE+="l:(createlistener)"
USAGE+="g:(generatescripts)"
USAGE+="r:(removedb)"
USAGE+="x:(removelistener)"
USAGE+="t:(createtemplate)"
USAGE+="h(help)"
while getopts "$USAGE" optchar ; do
case $optchar in
s) echo "Displaying Configuration" ;;
c) echo "Creating Database $OPTARG" ;;
l) echo "Creating Listener LISTENER_$OPTARG" ;;
g) echo "Generating Scripts for Database $OPTARG" ;;
r) echo "Removing Database $OPTARG" ;;
x) echo "Removing Listener LISTENER_$OPTARG" ;;
t) echo "Creating Database Template" ;;
h) echo "Help" ;;
esac
done
Eu não tenho rep suficiente ainda para comentar ou votar a sua solução, mas resposta de sme trabalhou muito bem para mim. O único problema que tive foi que os argumentos acabam envolto em aspas simples (por isso tenho uma tira-los para fora).
Eu também adicionei alguns exemplos de usos e texto de ajuda. Vou incluiu a minha versão ligeiramente alargada a este caso:
#!/bin/bash
# getopt example
# from: https://stackoverflow.com/questions/402377/using-getopts-in-bash-shell-script-to-get-long-and-short-command-line-options
HELP_TEXT=\
" USAGE:\n
Accepts - and -- flags, can specify options that require a value, and can be in any order. A double-hyphen (--) will stop processing options.\n\n
Accepts the following forms:\n\n
getopt-example.sh -a -b -c value-for-c some-arg\n
getopt-example.sh -c value-for-c -a -b some-arg\n
getopt-example.sh -abc some-arg\n
getopt-example.sh --along --blong --clong value-for-c -a -b -c some-arg\n
getopt-example.sh some-arg --clong value-for-c\n
getopt-example.sh
"
aflag=false
bflag=false
cargument=""
# options may be followed by one colon to indicate they have a required argument
if ! options=$(getopt -o abc:h\? -l along,blong,help,clong: -- "$@")
then
# something went wrong, getopt will put out an error message for us
exit 1
fi
set -- $options
while [ $# -gt 0 ]
do
case $1 in
-a|--along) aflag=true ;;
-b|--blong) bflag=true ;;
# for options with required arguments, an additional shift is required
-c|--clong) cargument="$2" ; shift;;
-h|--help|-\?) echo -e $HELP_TEXT; exit;;
(--) shift; break;;
(-*) echo "$0: error - unrecognized option $1" 1>&2; exit 1;;
(*) break;;
esac
shift
done
# to remove the single quotes around arguments, pipe the output into:
# | sed -e "s/^'\\|'$//g" (just leading/trailing) or | sed -e "s/'//g" (all)
echo aflag=${aflag}
echo bflag=${bflag}
echo cargument=${cargument}
while [ $# -gt 0 ]
do
echo arg=$1
shift
if [[ $aflag == true ]]; then
echo a is true
fi
done
Eu queria algo sem dependências externas, com o apoio do bash rigoroso (u), e eu precisava para trabalhar em até mesmo as versões mais antigas do bash. Este alças vários tipos de parâmetros:
- bools curtas (-h)
- opções curtas (-i "image.jpg")
- longos bools (help)
- iguala opções (--file = "filename.ext")
- opções de espaço (--file "filename.ext")
- bools concatinated (-hvm)
Basta inserir o seguinte no topo do seu script:
# Check if a list of params contains a specific param
# usage: if _param_variant "h|?|help p|path f|file long-thing t|test-thing" "file" ; then ...
# the global variable $key is updated to the long notation (last entry in the pipe delineated list, if applicable)
_param_variant() {
for param in $1 ; do
local variants=${param//\|/ }
for variant in $variants ; do
if [[ "$variant" = "$2" ]] ; then
# Update the key to match the long version
local arr=(${param//\|/ })
let last=${#arr[@]}-1
key="${arr[$last]}"
return 0
fi
done
done
return 1
}
# Get input parameters in short or long notation, with no dependencies beyond bash
# usage:
# # First, set your defaults
# param_help=false
# param_path="."
# param_file=false
# param_image=false
# param_image_lossy=true
# # Define allowed parameters
# allowed_params="h|?|help p|path f|file i|image image-lossy"
# # Get parameters from the arguments provided
# _get_params $*
#
# Parameters will be converted into safe variable names like:
# param_help,
# param_path,
# param_file,
# param_image,
# param_image_lossy
#
# Parameters without a value like "-h" or "--help" will be treated as
# boolean, and will be set as param_help=true
#
# Parameters can accept values in the various typical ways:
# -i "path/goes/here"
# --image "path/goes/here"
# --image="path/goes/here"
# --image=path/goes/here
# These would all result in effectively the same thing:
# param_image="path/goes/here"
#
# Concatinated short parameters (boolean) are also supported
# -vhm is the same as -v -h -m
_get_params(){
local param_pair
local key
local value
local shift_count
while : ; do
# Ensure we have a valid param. Allows this to work even in -u mode.
if [[ $# == 0 || -z $1 ]] ; then
break
fi
# Split the argument if it contains "="
param_pair=(${1//=/ })
# Remove preceeding dashes
key="${param_pair[0]#--}"
# Check for concatinated boolean short parameters.
local nodash="${key#-}"
local breakout=false
if [[ "$nodash" != "$key" && ${#nodash} -gt 1 ]]; then
# Extrapolate multiple boolean keys in single dash notation. ie. "-vmh" should translate to: "-v -m -h"
local short_param_count=${#nodash}
let new_arg_count=$#+$short_param_count-1
local new_args=""
# $str_pos is the current position in the short param string $nodash
for (( str_pos=0; str_pos<new_arg_count; str_pos++ )); do
# The first character becomes the current key
if [ $str_pos -eq 0 ] ; then
key="${nodash:$str_pos:1}"
breakout=true
fi
# $arg_pos is the current position in the constructed arguments list
let arg_pos=$str_pos+1
if [ $arg_pos -gt $short_param_count ] ; then
# handle other arguments
let orignal_arg_number=$arg_pos-$short_param_count+1
local new_arg="${!orignal_arg_number}"
else
# break out our one argument into new ones
local new_arg="-${nodash:$str_pos:1}"
fi
new_args="$new_args \"$new_arg\""
done
# remove the preceding space and set the new arguments
eval set -- "${new_args# }"
fi
if ! $breakout ; then
key="$nodash"
fi
# By default we expect to shift one argument at a time
shift_count=1
if [ "${#param_pair[@]}" -gt "1" ] ; then
# This is a param with equals notation
value="${param_pair[1]}"
else
# This is either a boolean param and there is no value,
# or the value is the next command line argument
# Assume the value is a boolean true, unless the next argument is found to be a value.
value=true
if [[ $# -gt 1 && -n "$2" ]]; then
local nodash="${2#-}"
if [ "$nodash" = "$2" ]; then
# The next argument has NO preceding dash so it is a value
value="$2"
shift_count=2
fi
fi
fi
# Check that the param being passed is one of the allowed params
if _param_variant "$allowed_params" "$key" ; then
# --key-name will now become param_key_name
eval param_${key//-/_}="$value"
else
printf 'WARNING: Unknown option (ignored): %s\n' "$1" >&2
fi
shift $shift_count
done
}
E usá-lo assim:
# Assign defaults for parameters
param_help=false
param_path=$(pwd)
param_file=false
param_image=true
param_image_lossy=true
param_image_lossy_quality=85
# Define the params we will allow
allowed_params="h|?|help p|path f|file i|image image-lossy image-lossy-quality"
# Get the params from arguments provided
_get_params $*
A resposta aceita faz um trabalho muito bom de apontar todos os defeitos de festa built-in getopts. As extremidades respostas com:
Assim, embora seja possível escrever mais código para trabalho em torno da falta de apoio para as opções longas, este é um trabalho muito mais e derrota parcialmente o propósito de usar um analisador getopt para simplificar o seu código.
E mesmo que eu concordar, em princípio, com essa afirmação, eu sinto que o número de vezes que todos nós implementado esse recurso em vários scripts justifica colocar um pouco de esforço em criar um "padronizados", solução bem testada.
Como tal, eu tenho "atualizado" bash construído em getopts através da implementação de getopts_long em bash puro, sem dependências externas. A utilização da função é 100% compatível com o embutido getopts.
Ao incluir getopts_long (que está hospedado no GitHub em https://github.com/UmkaDK/getopts_long) em um script, a resposta à pergunta inicial pode ser implementado como simplesmente como:
source "${PATH_TO}/getopts_long.bash"
while getopts_long ':c: copyfile:' OPTKEY; do
case ${OPTKEY} in
'c'|'copyfile')
echo 'file supplied -- ${OPTARG}'
;;
'?')
echo "INVALID OPTION -- ${OPTARG}" >&2
exit 1
;;
':')
echo "MISSING ARGUMENT for option -- ${OPTARG}" >&2
exit 1
;;
*)
echo "Misconfigured OPTSPEC or uncaught option -- ${OPTKEY}" >&2
exit 1
;;
esac
done
shift $(( OPTIND - 1 ))
[[ "${1}" == "--" ]] && shift
A fim de permanecer compatível com várias plataformas, e evitar a dependência de executáveis ??externos, eu portado algum código de outro idioma.
Acho que é muito fácil de usar, aqui está um exemplo:
ArgParser::addArg "[h]elp" false "This list"
ArgParser::addArg "[q]uiet" false "Supress output"
ArgParser::addArg "[s]leep" 1 "Seconds to sleep"
ArgParser::addArg "v" 1 "Verbose mode"
ArgParser::parse "$@"
ArgParser::isset help && ArgParser::showArgs
ArgParser::isset "quiet" \
&& echo "Quiet!" \
|| echo "Noisy!"
local __sleep
ArgParser::tryAndGetArg sleep into __sleep \
&& echo "Sleep for $__sleep seconds" \
|| echo "No value passed for sleep"
# This way is often more convienient, but is a little slower
echo "Sleep set to: $( ArgParser::getArg sleep )"
A FESTANÇA necessário é um pouco mais do que poderia ser, mas eu queria evitar a dependência de BASH 4 de arrays associativos. Você também pode baixar esse diretamente do http://nt4.com/bash/argparser.inc.sh
#!/usr/bin/env bash
# Updates to this script may be found at
# http://nt4.com/bash/argparser.inc.sh
# Example of runtime usage:
# mnc.sh --nc -q Caprica.S0*mkv *.avi *.mp3 --more-options here --host centos8.host.com
# Example of use in script (see bottom)
# Just include this file in yours, or use
# source argparser.inc.sh
unset EXPLODED
declare -a EXPLODED
function explode
{
local c=$#
(( c < 2 )) &&
{
echo function "$0" is missing parameters
return 1
}
local delimiter="$1"
local string="$2"
local limit=${3-99}
local tmp_delim=$'\x07'
local delin=${string//$delimiter/$tmp_delim}
local oldifs="$IFS"
IFS="$tmp_delim"
EXPLODED=($delin)
IFS="$oldifs"
}
# See: http://fvue.nl/wiki/Bash:_Passing_variables_by_reference
# Usage: local "$1" && upvar $1 "value(s)"
upvar() {
if unset -v "$1"; then # Unset & validate varname
if (( $# == 2 )); then
eval $1=\"\$2\" # Return single value
else
eval $1=\(\"\${@:2}\"\) # Return array
fi
fi
}
function decho
{
:
}
function ArgParser::check
{
__args=${#__argparser__arglist[@]}
for (( i=0; i<__args; i++ ))
do
matched=0
explode "|" "${__argparser__arglist[$i]}"
if [ "${#1}" -eq 1 ]
then
if [ "${1}" == "${EXPLODED[0]}" ]
then
decho "Matched $1 with ${EXPLODED[0]}"
matched=1
break
fi
else
if [ "${1}" == "${EXPLODED[1]}" ]
then
decho "Matched $1 with ${EXPLODED[1]}"
matched=1
break
fi
fi
done
(( matched == 0 )) && return 2
# decho "Key $key has default argument of ${EXPLODED[3]}"
if [ "${EXPLODED[3]}" == "false" ]
then
return 0
else
return 1
fi
}
function ArgParser::set
{
key=$3
value="${1:-true}"
declare -g __argpassed__$key="$value"
}
function ArgParser::parse
{
unset __argparser__argv
__argparser__argv=()
# echo parsing: "$@"
while [ -n "$1" ]
do
# echo "Processing $1"
if [ "${1:0:2}" == '--' ]
then
key=${1:2}
value=$2
elif [ "${1:0:1}" == '-' ]
then
key=${1:1} # Strip off leading -
value=$2
else
decho "Not argument or option: '$1'" >& 2
__argparser__argv+=( "$1" )
shift
continue
fi
# parameter=${tmp%%=*} # Extract name.
# value=${tmp##*=} # Extract value.
decho "Key: '$key', value: '$value'"
# eval $parameter=$value
ArgParser::check $key
el=$?
# echo "Check returned $el for $key"
[ $el -eq 2 ] && decho "No match for option '$1'" >&2 # && __argparser__argv+=( "$1" )
[ $el -eq 0 ] && decho "Matched option '${EXPLODED[2]}' with no arguments" >&2 && ArgParser::set true "${EXPLODED[@]}"
[ $el -eq 1 ] && decho "Matched option '${EXPLODED[2]}' with an argument of '$2'" >&2 && ArgParser::set "$2" "${EXPLODED[@]}" && shift
shift
done
}
function ArgParser::isset
{
declare -p "__argpassed__$1" > /dev/null 2>&1 && return 0
return 1
}
function ArgParser::getArg
{
# This one would be a bit silly, since we can only return non-integer arguments ineffeciently
varname="__argpassed__$1"
echo "${!varname}"
}
##
# usage: tryAndGetArg <argname> into <varname>
# returns: 0 on success, 1 on failure
function ArgParser::tryAndGetArg
{
local __varname="__argpassed__$1"
local __value="${!__varname}"
test -z "$__value" && return 1
local "$3" && upvar $3 "$__value"
return 0
}
function ArgParser::__construct
{
unset __argparser__arglist
# declare -a __argparser__arglist
}
##
# @brief add command line argument
# @param 1 short and/or long, eg: [s]hort
# @param 2 default value
# @param 3 description
##
function ArgParser::addArg
{
# check for short arg within long arg
if [[ "$1" =~ \[(.)\] ]]
then
short=${BASH_REMATCH[1]}
long=${1/\[$short\]/$short}
else
long=$1
fi
if [ "${#long}" -eq 1 ]
then
short=$long
long=''
fi
decho short: "$short"
decho long: "$long"
__argparser__arglist+=("$short|$long|$1|$2|$3")
}
##
# @brief show available command line arguments
##
function ArgParser::showArgs
{
# declare -p | grep argparser
printf "Usage: %s [OPTION...]\n\n" "$( basename "${BASH_SOURCE[0]}" )"
printf "Defaults for the options are specified in brackets.\n\n";
__args=${#__argparser__arglist[@]}
for (( i=0; i<__args; i++ ))
do
local shortname=
local fullname=
local default=
local description=
local comma=
explode "|" "${__argparser__arglist[$i]}"
shortname="${EXPLODED[0]:+-${EXPLODED[0]}}" # String Substitution Guide:
fullname="${EXPLODED[1]:+--${EXPLODED[1]}}" # http://tldp.org/LDP/abs/html/parameter-substitution.html
test -n "$shortname" \
&& test -n "$fullname" \
&& comma=","
default="${EXPLODED[3]}"
case $default in
false )
default=
;;
"" )
default=
;;
* )
default="[$default]"
esac
description="${EXPLODED[4]}"
printf " %2s%1s %-19s %s %s\n" "$shortname" "$comma" "$fullname" "$description" "$default"
done
}
function ArgParser::test
{
# Arguments with a default of 'false' do not take paramaters (note: default
# values are not applied in this release)
ArgParser::addArg "[h]elp" false "This list"
ArgParser::addArg "[q]uiet" false "Supress output"
ArgParser::addArg "[s]leep" 1 "Seconds to sleep"
ArgParser::addArg "v" 1 "Verbose mode"
ArgParser::parse "$@"
ArgParser::isset help && ArgParser::showArgs
ArgParser::isset "quiet" \
&& echo "Quiet!" \
|| echo "Noisy!"
local __sleep
ArgParser::tryAndGetArg sleep into __sleep \
&& echo "Sleep for $__sleep seconds" \
|| echo "No value passed for sleep"
# This way is often more convienient, but is a little slower
echo "Sleep set to: $( ArgParser::getArg sleep )"
echo "Remaining command line: ${__argparser__argv[@]}"
}
if [ "$( basename "$0" )" == "argparser.inc.sh" ]
then
ArgParser::test "$@"
fi
Se todas as suas opções longas têm único, e de correspondência, primeiros caracteres como as opções curtas, assim, por exemplo
./slamm --chaos 23 --plenty test -quiet
é o mesmo que
./slamm -c 23 -p test -q
Você pode usar este antes getopts para reescrever $ args:
# change long options to short options
for arg; do
[[ "${arg:0:1}" == "-" ]] && delim="" || delim="\""
if [ "${arg:0:2}" == "--" ];
then args="${args} -${arg:2:1}"
else args="${args} ${delim}${arg}${delim}"
fi
done
# reset the incoming args
eval set -- $args
# proceed as usual
while getopts ":b:la:h" OPTION; do
.....
Obrigado por mtvee para a inspiração; -)
Builtin getopts opções curtas única de análise (exceto no ksh93),
mas você ainda pode adicionar algumas linhas de script para fazer getopts alças opções longas.
Aqui está uma parte do código encontrado no http://www.uxora.com/unix/shell-script/22-handle-long-options-with-getopts
#== set short options ==#
SCRIPT_OPTS=':fbF:B:-:h'
#== set long options associated with short one ==#
typeset -A ARRAY_OPTS
ARRAY_OPTS=(
[foo]=f
[bar]=b
[foobar]=F
[barfoo]=B
[help]=h
[man]=h
)
#== parse options ==#
while getopts ${SCRIPT_OPTS} OPTION ; do
#== translate long options to short ==#
if [[ "x$OPTION" == "x-" ]]; then
LONG_OPTION=$OPTARG
LONG_OPTARG=$(echo $LONG_OPTION | grep "=" | cut -d'=' -f2)
LONG_OPTIND=-1
[[ "x$LONG_OPTARG" = "x" ]] && LONG_OPTIND=$OPTIND || LONG_OPTION=$(echo $OPTARG | cut -d'=' -f1)
[[ $LONG_OPTIND -ne -1 ]] && eval LONG_OPTARG="\$$LONG_OPTIND"
OPTION=${ARRAY_OPTS[$LONG_OPTION]}
[[ "x$OPTION" = "x" ]] && OPTION="?" OPTARG="-$LONG_OPTION"
if [[ $( echo "${SCRIPT_OPTS}" | grep -c "${OPTION}:" ) -eq 1 ]]; then
if [[ "x${LONG_OPTARG}" = "x" ]] || [[ "${LONG_OPTARG}" = -* ]]; then
OPTION=":" OPTARG="-$LONG_OPTION"
else
OPTARG="$LONG_OPTARG";
if [[ $LONG_OPTIND -ne -1 ]]; then
[[ $OPTIND -le $Optnum ]] && OPTIND=$(( $OPTIND+1 ))
shift $OPTIND
OPTIND=1
fi
fi
fi
fi
#== options follow by another option instead of argument ==#
if [[ "x${OPTION}" != "x:" ]] && [[ "x${OPTION}" != "x?" ]] && [[ "${OPTARG}" = -* ]]; then
OPTARG="$OPTION" OPTION=":"
fi
#== manage options ==#
case "$OPTION" in
f ) foo=1 bar=0 ;;
b ) foo=0 bar=1 ;;
B ) barfoo=${OPTARG} ;;
F ) foobar=1 && foobar_name=${OPTARG} ;;
h ) usagefull && exit 0 ;;
: ) echo "${SCRIPT_NAME}: -$OPTARG: option requires an argument" >&2 && usage >&2 && exit 99 ;;
? ) echo "${SCRIPT_NAME}: -$OPTARG: unknown option" >&2 && usage >&2 && exit 99 ;;
esac
done
shift $((${OPTIND} - 1))
Aqui está um teste:
# Short options test
$ ./foobar_any_getopts.sh -bF "Hello world" -B 6 file1 file2
foo=0 bar=1
barfoo=6
foobar=1 foobar_name=Hello world
files=file1 file2
# Long and short options test
$ ./foobar_any_getopts.sh --bar -F Hello --barfoo 6 file1 file2
foo=0 bar=1
barfoo=6
foobar=1 foobar_name=Hello
files=file1 file2
Caso contrário em recente Korn Shell ksh93, getopts pode opções longas naturalmente analisar e até mesmo exibir uma página homem iguais. (Veja http: // www .uxora.com / unix / shell-script / 20-getopts-com-homem-page-e-longo opções )
Th built-in OS X (BSD) getopt não suporta opções longas, mas a versão GNU faz: brew install gnu-getopt. Então, algo semelhante a:. cp /usr/local/Cellar/gnu-getopt/1.1.6/bin/getopt /usr/local/bin/gnu-getopt
EasyOptions lida com opções de curto e longo:
## Options:
## --verbose, -v Verbose mode
## --logfile=NAME Log filename
source easyoptions || exit
if test -n "${verbose}"; then
echo "log file: ${logfile}"
echo "arguments: ${arguments[@]}"
fi
A DIY simples de se apenas o tempo chamado args:
Use:
$ ./test-args.sh --a1 a1 --a2 "a 2" --a3 --a4= --a5=a5 --a6="a 6"
a1 = "a1"
a2 = "a 2"
a3 = "TRUE"
a4 = ""
a5 = "a5"
a6 = "a 6"
a7 = ""
Script:
#!/bin/bash
function main() {
ARGS=`getArgs "$@"`
a1=`echo "$ARGS" | getNamedArg a1`
a2=`echo "$ARGS" | getNamedArg a2`
a3=`echo "$ARGS" | getNamedArg a3`
a4=`echo "$ARGS" | getNamedArg a4`
a5=`echo "$ARGS" | getNamedArg a5`
a6=`echo "$ARGS" | getNamedArg a6`
a7=`echo "$ARGS" | getNamedArg a7`
echo "a1 = \"$a1\""
echo "a2 = \"$a2\""
echo "a3 = \"$a3\""
echo "a4 = \"$a4\""
echo "a5 = \"$a5\""
echo "a6 = \"$a6\""
echo "a7 = \"$a7\""
exit 0
}
function getArgs() {
for arg in "$@"; do
echo "$arg"
done
}
function getNamedArg() {
ARG_NAME=$1
sed --regexp-extended --quiet --expression="
s/^--$ARG_NAME=(.*)\$/\1/p # Get arguments in format '--arg=value': [s]ubstitute '--arg=value' by 'value', and [p]rint
/^--$ARG_NAME\$/ { # Get arguments in format '--arg value' ou '--arg'
n # - [n]ext, because in this format, if value exists, it will be the next argument
/^--/! p # - If next doesn't starts with '--', it is the value of the actual argument
/^--/ { # - If next do starts with '--', it is the next argument and the actual argument is a boolean one
# Then just repla[c]ed by TRUE
c TRUE
}
}
"
}
main "$@"
Se simplesmente é assim que você quer chamar o script
myscript.sh --input1 "ABC" --input2 "PQR" --input2 "XYZ"
então você pode seguir este caminho mais simples para alcançá-lo com a ajuda de getopt e --longoptions
tentar isso, espero que este seja útil
# Read command line options
ARGUMENT_LIST=(
"input1"
"input2"
"input3"
)
# read arguments
opts=$(getopt \
--longoptions "$(printf "%s:," "${ARGUMENT_LIST[@]}")" \
--name "$(basename "$0")" \
--options "" \
-- "$@"
)
echo $opts
eval set --$opts
while true; do
case "$1" in
--input1)
shift
empId=$1
;;
--input2)
shift
fromDate=$1
;;
--input3)
shift
toDate=$1
;;
--)
shift
break
;;
esac
shift
done
