Comment puis-je utiliser longs avec le Bash getopts builtin?

getopts peut analyser uniquement à court d'options.

La plupart des systèmes ont également un externe getopt de commande, mais getopt n'est pas standard, et est généralement cassé par la conception qu'il ne peut pas gérer tous les arguments en toute sécurité (arguments avec des espaces blancs et vides d'arguments), seulement GNU getopt peut les manipuler en toute sécurité, mais seulement si vous utilisez la version GNU de manière spécifique.

Le choix le plus facile est d'utiliser non plus, juste répéter les arguments du script avec un tout-boucle et de faire l'analyse de vous-même.

Voir http://mywiki.wooledge.org/BashFAQ/035 pour un exemple.

getopts est utilisé par le shell procédures pour analyser les paramètres positionnels de 1 caractère
(pas de style GNU longue options (--mon option) ou XF86-style long options (mon option))

la façon la plus simple d'y parvenir est avec l'aide de getopt et --longoptions

essayer , j'espère que cela est utile

# 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

et c'est de cette façon - vous appeler le script shell

myscript.sh --input1 "ABC" --input2 "PQR" --input2 "XYZ"

C'est vrai que builtin bash getopts analyser uniquement les fichiers à court d'options,
mais vous pouvez toujours ajouter quelques lignes de script de getopts de poignées options.

Ici est une partie de code trouvé dans http://www.uxora.com/unix/shell-script/22-handle-long-options-with-getopts

  #== set options ==#
SCRIPT_OPTS=':fbF:B:-:h'
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))

Voici un test:

# 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

Sinon au cours des dernières Korn Shell ksh93, getopts peut naturellement analyser longs et même afficher une page de man de même. (voir http://www.uxora.com/unix/shell-script/20-getopts-with-man-page-and-long-options)

Michel VONGVILAY.

Un simple BRICOLAGE si vous avez des ennuis pour utiliser le haut -getopts:

Utilisation:

$ ./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 "$@"