Пример использования getopts в bash

Question

Пример использования getopts в bash

215

Я хочу вызвать myscript файл следующим образом:

$ ./myscript -s 45 -p any_string

или

$ ./myscript -h >>> should display help
$ ./myscript    >>> should display help

Мои требования:

getopt здесь, чтобы получить входные аргументы
проверьте, что -s существует, если не возвращать ошибку
убедитесь, что значение после -s равно 45 или 90
убедитесь, что существует -p и есть строка ввода после
если пользователь вводит ./myscript -h или просто ./myscript, тогда отобразите справку

Я пробовал до сих пор этот код:

#!/bin/bash
while getopts "h:s:" arg; do
  case $arg in
    h)
      echo "usage" 
      ;;
    s)
      strength=$OPTARG
      echo $strength
      ;;
  esac
done

Но с этим кодом я получаю ошибки. Как это сделать с помощью Bash и getopt?

MOHAMED 10 май 2013, в 14:04

Источник

2

Опции должны быть необязательными. Если вам требуется значение, указанное в -s , сделайте его позиционным аргументом: ./myscript 45 anystring .
chepner 10 май 2013, в 13:19
0

@chepner $./myscript -s 45 -p any_string
MOHAMED 10 май 2013, в 13:21
0

Это нормально, если опция -p на самом деле является опцией (то есть ваша программа может продолжаться, если ее нет). В этом случае ./myscript 45 -p any_string . (Я думаю, что getopt может обрабатывать смешанные опции и позиционные аргументы, тогда как встроенная команда bash getopts требует, чтобы все позиционные аргументы были помещены после опций.)
chepner 10 май 2013, в 13:42

Показать ещё 1 комментарий

Теги:

bash

linux

shell

getopts

5 ответов

47

Проблема с исходным кодом заключается в следующем:

h: ожидает параметр, где он не должен, поэтому измените его на h (без двоеточия)
ожидать -p any_string, вам нужно добавить p: в список аргументов

Основной синтаксис getopts равен (см. man bash):

getopts OPTSTRING VARNAME [ARGS...]

где:

OPTSTRING - строка со списком ожидаемых аргументов,
- h - проверьте параметры -h без; дает ошибку при неподдерживаемых опциях;
- h: - проверьте параметр -h с параметром; дает ошибки в неподдерживаемых опциях;
- abc - проверьте параметры -a, -b, -c; дает ошибки в неподдерживаемых опциях;
- :abc - проверьте параметры -a, -b, -c; отключает ошибки в неподдерживаемых опциях;
  
  ^{Примечания: Другими словами, двоеточие перед параметрами позволяет обрабатывать ошибки в коде. Переменная будет содержать ? в случае неподдерживаемой опции, : в случае отсутствия значения.}
OPTARG - установлено значение текущего аргумента,
OPTERR - указывает, должен ли Bash отображать сообщения об ошибках.

Таким образом, код может быть:

#!/usr/bin/env bash
usage() { echo "$0 usage:" && grep " .)\ #" $0; exit 0; }
[ $# -eq 0 ] && usage
while getopts ":hs:p:" arg; do
  case $arg in
    p) # Specify p value.
      echo "p is ${OPTARG}"
      ;;
    s) # Specify strength, either 45 or 90.
      strength=${OPTARG}
      [ $strength -eq 45 -o $strength -eq 90 ] \
        && echo "Strength is $strength." \
        || echo "Strength needs to be either 45 or 90, $strength found instead."
      ;;
    h | *) # Display help.
      usage
      exit 0
      ;;
  esac
done

Пример использования:

$ ./foo.sh 
./foo.sh usage:
    p) # Specify p value.
    s) # Specify strength, either 45 or 90.
    h | *) # Display help.
$ ./foo.sh -s 123 -p any_string
Strength needs to be either 45 or 90, 123 found instead.
p is any_string
$ ./foo.sh -s 90 -p any_string
Strength is 90.
p is any_string

Смотрите: Небольшой учебник по учебникам в Bash Hackers Wiki

kenorb 30 дек. 2015, в 15:18

2

Измените функцию использования следующим образом: usage() { echo "$0 usage:" && grep "[[:space:]].)\ #" $0 | sed 's/#//' | sed -r 's/([az])\)/-\1/'; exit 0; } Он учитывает только один символ пробела перед параметром буквы, удаляет знак # из комментария и добавляет символ «-» перед параметром буквы, делая его более понятным для команды.
poagester 05 окт. 2016, в 19:55
1

@kenorb: двоеточие перед опциями не игнорирует неподдерживаемые опции, но заставляет глушить ошибки из bash и позволяет обрабатывать их в вашем коде. Переменная будет содержать '?' в случае неподдерживаемой опции и «:» в случае пропущенного значения.
Hynek -Pichi- Vychodil 06 фев. 2017, в 07:42
0

Спасибо за подробные документы, не смог получить : прямо, пока я не увидел эти заметки. Нам нужно добавить : к опциям, где мы ожидаем аргумент.
Aukhan 25 фев. 2019, в 07:22

Показать ещё 1 комментарий

28

Пример, упакованный в getopt (мой дистрибутив помещается в /usr/share/getopt/getopt-parse.bash), выглядит так, как будто он охватывает все ваши случаи:

#!/bin/bash

# A small example program for using the new getopt(1) program.
# This program will only work with bash(1)
# An similar program using the tcsh(1) script language can be found
# as parse.tcsh

# Example input and output (from the bash prompt):
# ./parse.bash -a par1 'another arg' --c-long 'wow!*\?' -cmore -b " very long "
# Option a
# Option c, no argument
# Option c, argument `more'
# Option b, argument ` very long '
# Remaining arguments:
# --> `par1'
# --> `another arg'
# --> `wow!*\?'

# Note that we use `"$@"' to let each command-line parameter expand to a 
# separate word. The quotes around `$@' are essential!
# We need TEMP as the `eval set --' would nuke the return value of getopt.
TEMP=`getopt -o ab:c:: --long a-long,b-long:,c-long:: \
     -n 'example.bash' -- "$@"`

if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi

# Note the quotes around `$TEMP': they are essential!
eval set -- "$TEMP"

while true ; do
    case "$1" in
        -a|--a-long) echo "Option a" ; shift ;;
        -b|--b-long) echo "Option b, argument \`$2'" ; shift 2 ;;
        -c|--c-long) 
            # c has an optional argument. As we are in quoted mode,
            # an empty parameter will be generated if its optional
            # argument is not found.
            case "$2" in
                "") echo "Option c, no argument"; shift 2 ;;
                *)  echo "Option c, argument \`$2'" ; shift 2 ;;
            esac ;;
        --) shift ; break ;;
        *) echo "Internal error!" ; exit 1 ;;
    esac
done
echo "Remaining arguments:"
for arg do echo '--> '"\`$arg'" ; done

Brian Cain 10 май 2013, в 14:22

11

Внешнюю команду getopt (1) никогда нельзя использовать безопасно, если только вы не знаете, что это GNU getopt, вы вызываете ее специфичным для GNU способом и гарантируете, что GETOPT_COMPATIBLE не находится в среде. Вместо этого используйте getopts (встроенную оболочку) или просто переключайтесь между позиционными параметрами.
Gilles Quenot 14 авг. 2013, в 16:52
0

@sputnick, tyvm, не знал этого.
Brian Cain 14 авг. 2013, в 17:38
14

Эх, ни одна внешняя команда не является безопасной для использования по этому стандарту. Во встроенных getopts отсутствуют важные функции, и если вы хотите проверить GETOPT_COMPATIBLE, это проще, чем портировать функции getopt.
Michael Terry 12 сен. 2014, в 18:26

Показать ещё 1 комментарий

9

Я знаю, что об этом уже ответили, но для записи и для тех, кто с теми же запросами, что и я, я решил опубликовать этот ответ. Код будет заполнен комментариями для объяснения кода.

Обновленный ответ:

Сохраните файл как getopt.sh:

#!/bin/bash

function get_variable_name_for_option {
    local OPT_DESC=${1}
    local OPTION=${2}
    local VAR=$(echo ${OPT_DESC} | sed -e "s/.*\[\?-${OPTION} \([A-Z_]\+\).*/\1/g" -e "s/.*\[\?-\(${OPTION}\).*/\1FLAG/g")

    if [[ "${VAR}" == "${1}" ]]; then
        echo ""
    else
        echo ${VAR}
    fi
}

function parse_options {
    local OPT_DESC=${1}
    local INPUT=$(get_input_for_getopts "${OPT_DESC}")

    shift
    while getopts ${INPUT} OPTION ${@};
    do
        [ ${OPTION} == "?" ] && usage
        VARNAME=$(get_variable_name_for_option "${OPT_DESC}" "${OPTION}")
            [ "${VARNAME}" != "" ] && eval "${VARNAME}=${OPTARG:-true}" # && printf "\t%s\n" "* Declaring ${VARNAME}=${!VARNAME} -- OPTIONS='$OPTION'"
    done

    check_for_required "${OPT_DESC}"

}

function check_for_required {
    local OPT_DESC=${1}
    local REQUIRED=$(get_required "${OPT_DESC}" | sed -e "s/\://g")
    while test -n "${REQUIRED}"; do
        OPTION=${REQUIRED:0:1}
        VARNAME=$(get_variable_name_for_option "${OPT_DESC}" "${OPTION}")
                [ -z "${!VARNAME}" ] && printf "ERROR: %s\n" "Option -${OPTION} must been set." && usage
        REQUIRED=${REQUIRED:1}
    done
}

function get_input_for_getopts {
    local OPT_DESC=${1}
    echo ${OPT_DESC} | sed -e "s/\([a-zA-Z]\) [A-Z_]\+/\1:/g" -e "s/[][ -]//g"
}

function get_optional {
    local OPT_DESC=${1}
    echo ${OPT_DESC} | sed -e "s/[^[]*\(\[[^]]*\]\)[^[]*/\1/g" -e "s/\([a-zA-Z]\) [A-Z_]\+/\1:/g" -e "s/[][ -]//g"
}

function get_required {
    local OPT_DESC=${1}
    echo ${OPT_DESC} | sed -e "s/\([a-zA-Z]\) [A-Z_]\+/\1:/g" -e "s/\[[^[]*\]//g" -e "s/[][ -]//g"
}

function usage {
    printf "Usage:\n\t%s\n" "${0} ${OPT_DESC}"
    exit 10
}

Затем вы можете использовать его следующим образом:

#!/bin/bash
#
# [ and ] defines optional arguments
#

# location to getopts.sh file
source ./getopt.sh
USAGE="-u USER -d DATABASE -p PASS -s SID [ -a START_DATE_TIME ]"
parse_options "${USAGE}" ${@}

echo ${USER}
echo ${START_DATE_TIME}

Старый ответ:

Недавно мне нужно было использовать общий подход. Я столкнулся с этим решением:

#!/bin/bash
# Option Description:
# -------------------
#
# Option description is based on getopts bash builtin. The description adds a variable name feature to be used
# on future checks for required or optional values.
# The option description adds "=>VARIABLE_NAME" string. Variable name should be UPPERCASE. Valid characters
# are [A-Z_]*.
#
# A option description example:
#   OPT_DESC="a:=>A_VARIABLE|b:=>B_VARIABLE|c=>C_VARIABLE"
#
# -a option will require a value (the colon means that) and should be saved in variable A_VARIABLE.
# "|" is used to separate options description.
# -b option rule applies the same as -a.
# -c option doesn't require a value (the colon absense means that) and its existence should be set in C_VARIABLE
#
#   ~$ echo get_options ${OPT_DESC}
#   a:b:c
#   ~$
#


# Required options 
REQUIRED_DESC="a:=>REQ_A_VAR_VALUE|B:=>REQ_B_VAR_VALUE|c=>REQ_C_VAR_FLAG"

# Optional options (duh)
OPTIONAL_DESC="P:=>OPT_P_VAR_VALUE|r=>OPT_R_VAR_FLAG"

function usage {
    IFS="|"
    printf "%s" ${0}
    for i in ${REQUIRED_DESC};
    do
        VARNAME=$(echo $i | sed -e "s/.*=>//g")
    printf " %s" "-${i:0:1} $VARNAME"
    done

    for i in ${OPTIONAL_DESC};
    do
        VARNAME=$(echo $i | sed -e "s/.*=>//g")
        printf " %s" "[-${i:0:1} $VARNAME]"
    done
    printf "\n"
    unset IFS
    exit
}

# Auxiliary function that returns options characters to be passed
# into 'getopts' from a option description.
# Arguments:
#   $1: The options description (SEE TOP)
#
# Example:
#   OPT_DESC="h:=>H_VAR|f:=>F_VAR|P=>P_VAR|W=>W_VAR"
#   OPTIONS=$(get_options ${OPT_DESC})
#   echo "${OPTIONS}"
#
# Output:
#   "h:f:PW"
function get_options {
    echo ${1} | sed -e "s/\([a-zA-Z]\:\?\)=>[A-Z_]*|\?/\1/g"
}

# Auxiliary function that returns all variable names separated by '|'
# Arguments:
#       $1: The options description (SEE TOP)
#
# Example:
#       OPT_DESC="h:=>H_VAR|f:=>F_VAR|P=>P_VAR|W=>W_VAR"
#       VARNAMES=$(get_values ${OPT_DESC})
#       echo "${VARNAMES}"
#
# Output:
#       "H_VAR|F_VAR|P_VAR|W_VAR"
function get_variables {
    echo ${1} | sed -e "s/[a-zA-Z]\:\?=>\([^|]*\)/\1/g"
}

# Auxiliary function that returns the variable name based on the
# option passed by.
# Arguments:
#   $1: The options description (SEE TOP)
#   $2: The option which the variable name wants to be retrieved
#
# Example:
#   OPT_DESC="h:=>H_VAR|f:=>F_VAR|P=>P_VAR|W=>W_VAR"
#   H_VAR=$(get_variable_name ${OPT_DESC} "h")
#   echo "${H_VAR}"
#
# Output:
#   "H_VAR"
function get_variable_name {
    VAR=$(echo ${1} | sed -e "s/.*${2}\:\?=>\([^|]*\).*/\1/g")
    if [[ ${VAR} == ${1} ]]; then
        echo ""
    else
        echo ${VAR}
    fi
}

# Gets the required options from the required description
REQUIRED=$(get_options ${REQUIRED_DESC})

# Gets the optional options (duh) from the optional description
OPTIONAL=$(get_options ${OPTIONAL_DESC})

# or... $(get_options "${OPTIONAL_DESC}|${REQUIRED_DESC}")

# The colon at starts instructs getopts to remain silent
while getopts ":${REQUIRED}${OPTIONAL}" OPTION
do
    [[ ${OPTION} == ":" ]] && usage
    VAR=$(get_variable_name "${REQUIRED_DESC}|${OPTIONAL_DESC}" ${OPTION})
    [[ -n ${VAR} ]] && eval "$VAR=${OPTARG}"
done

shift $(($OPTIND - 1))

# Checks for required options. Report an error and exits if
# required options are missing.

# Using function version ...
VARS=$(get_variables ${REQUIRED_DESC})
IFS="|"
for VARNAME in $VARS;
do
    [[ -v ${VARNAME} ]] || usage
done
unset IFS

# ... or using IFS Version (no function)
OLDIFS=${IFS}
IFS="|"
for i in ${REQUIRED_DESC};
do
    VARNAME=$(echo $i | sed -e "s/.*=>//g")
    [[ -v ${VARNAME} ]] || usage
    printf "%s %s %s\n" "-${i:0:1}" "${!VARNAME:=present}" "${VARNAME}"
done
IFS=${OLDIFS}

Я не тестировал это примерно так, поэтому у меня могли быть некоторые ошибки.

Sebastian 12 янв. 2014, в 06:45

2

Пример POSIX 7

Также стоит проверить пример со стандартом: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/getopts.html

aflag=
bflag=
while getopts ab: name
do
    case $name in
    a)    aflag=1;;
    b)    bflag=1
          bval="$OPTARG";;
    ?)   printf "Usage: %s: [-a] [-b value] args\n" $0
          exit 2;;
    esac
done
if [ ! -z "$aflag" ]; then
    printf "Option -a specified\n"
fi
if [ ! -z "$bflag" ]; then
    printf 'Option -b "%s" specified\n' "$bval"
fi
shift $(($OPTIND - 1))
printf "Remaining arguments are: %s\n" "$*"

И тогда мы можем попробовать:

$ sh a.sh
Remaining arguments are: 
$ sh a.sh -a
Option -a specified
Remaining arguments are: 
$ sh a.sh -b
No arg for -b option
Usage: a.sh: [-a] [-b value] args
$ sh a.sh -b myval
Option -b "myval" specified
Remaining arguments are: 
$ sh a.sh -a -b myval
Option -a specified
Option -b "myval" specified
Remaining arguments are: 
$ sh a.sh remain
Remaining arguments are: remain
$ sh a.sh -- -a remain
Remaining arguments are: -a remain

Протестировано в Ubuntu 17.10, sh - тире 0.5.8.

Ciro Santilli 新疆改造中心六四事件法轮功 30 март 2018, в 12:01

Ещё вопросы

Опции должны быть необязательными. Если вам требуется значение, указанное в -s , сделайте его позиционным аргументом: ./myscript 45 anystring .
Это нормально, если опция -p на самом деле является опцией (то есть ваша программа может продолжаться, если ее нет). В этом случае ./myscript 45 -p any_string . (Я думаю, что getopt может обрабатывать смешанные опции и позиционные аргументы, тогда как встроенная команда bash getopts требует, чтобы все позиционные аргументы были помещены после опций.)
Измените функцию использования следующим образом: usage() { echo "$0 usage:" && grep "[[:space:]].)\ #" $0 | sed 's/#//' | sed -r 's/([az])\)/-\1/'; exit 0; } Он учитывает только один символ пробела перед параметром буквы, удаляет знак # из комментария и добавляет символ «-» перед параметром буквы, делая его более понятным для команды.
@kenorb: двоеточие перед опциями не игнорирует неподдерживаемые опции, но заставляет глушить ошибки из bash и позволяет обрабатывать их в вашем коде. Переменная будет содержать '?' в случае неподдерживаемой опции и «:» в случае пропущенного значения.
Спасибо за подробные документы, не смог получить : прямо, пока я не увидел эти заметки. Нам нужно добавить : к опциям, где мы ожидаем аргумент.
Внешнюю команду getopt (1) никогда нельзя использовать безопасно, если только вы не знаете, что это GNU getopt, вы вызываете ее специфичным для GNU способом и гарантируете, что GETOPT_COMPATIBLE не находится в среде. Вместо этого используйте getopts (встроенную оболочку) или просто переключайтесь между позиционными параметрами.
Эх, ни одна внешняя команда не является безопасной для использования по этому стандарту. Во встроенных getopts отсутствуют важные функции, и если вы хотите проверить GETOPT_COMPATIBLE, это проще, чем портировать функции getopt.

Adrian Frühwirth · Accepted Answer · 2013-05-11T12-18-00.000Z

373

Лучший ответ

#!/bin/bash

usage() { echo "Usage: $0 [-s <45|90>] [-p <string>]" 1>&2; exit 1; }

while getopts ":s:p:" o; do
    case "${o}" in
        s)
            s=${OPTARG}
            ((s == 45 || s == 90)) || usage
            ;;
        p)
            p=${OPTARG}
            ;;
        *)
            usage
            ;;
    esac
done
shift $((OPTIND-1))

if [ -z "${s}" ] || [ -z "${p}" ]; then
    usage
fi

echo "s = ${s}"
echo "p = ${p}"

Пример выполнения:

$ ./myscript.sh
Usage: ./myscript.sh [-s <45|90>] [-p <string>]

$ ./myscript.sh -h
Usage: ./myscript.sh [-s <45|90>] [-p <string>]

$ ./myscript.sh -s "" -p ""
Usage: ./myscript.sh [-s <45|90>] [-p <string>]

$ ./myscript.sh -s 10 -p foo
Usage: ./myscript.sh [-s <45|90>] [-p <string>]

$ ./myscript.sh -s 45 -p foo
s = 45
p = foo

$ ./myscript.sh -s 90 -p bar
s = 90
p = bar

Adrian Frühwirth 11 май 2013, в 12:18

12

В вызове getopts почему ведущий двоеточие? Когда после h стоит двоеточие?
e40 14 авг. 2013, в 14:43
0

@ e40 Хорошо, спасибо! Вероятно, ошибка копирования-вставки на h . Начальная двоеточие объясняется в getopts странице для getopts . Попробуйте $ ./myscript.sh -s 45 -p с и без него, и разница будет очевидна. Хотите ли вы использовать эту функцию, решать только вам и как вы хотите справиться со всем этим.
Adrian Frühwirth 14 авг. 2013, в 15:02
25

@ e40 Ведущая двоеточие включает тихую отчетность об ошибках.
Chris 18 авг. 2013, в 16:06
4

Должно ли usage() действительно возвращать 1?
Pithikos 10 сен. 2014, в 08:21
2

@Pithikos Хороший вопрос. Здравый смысл подсказывает мне, что при вызове через -h он должен возвращать 0 , при нажатии на несуществующий флаг он должен возвращать >0 (для простоты я не делал различий между этими случаями, и никто не заставляет вас печатать текст использования) в последнем случае). Я видел программы, которые всегда возвращают != 0 , хотя даже на -h/--help . Может быть, мне следует обновить фрагмент на тот случай, если люди используют его как шаблон (надеюсь, нет)?
Adrian Frühwirth 10 сен. 2014, в 09:04
0

Кажется, работает, но проблема с getopts заключается в том, что необязательные аргументы на самом деле не являются необязательными, с вашим кодом, если кто-то не устанавливает значение для -s, и это первый параметр, тогда в обработчике параметров OPTARG получит -p для своего значение. ./myscript -sh -p -ss = p = -s <- обратите внимание, что вы должны закомментировать проверку на null, чтобы увидеть вывод
user4401178 12 март 2015, в 23:26
0

@ A.Danischewski Это дизайн ( getopts ), нет такой вещи как «необязательные аргументы» с getopts . Синтаксический анализатор просто не может знать, является ли следующий токен аргументом текущей опции или самой опцией, поскольку -p может быть предполагаемым значением. Вы можете обойти это, если абсолютно уверены, что параметр option не может выглядеть как другой допустимый параметр, да, но можно сказать, что есть причина, по которой необязательные аргументы не определены в POSIX.
Adrian Frühwirth 13 март 2015, в 09:40
0

getopts плохо спроектирован, на мой взгляд, в документации сказано, что он должен иметь необязательные аргументы с синтаксисом двойного двоеточия: однако Bash его не поддерживает. Не должно быть необходимости делать сложный обходной путь для предоставления необязательных аргументов, на мой взгляд, разумным поведением по умолчанию было бы рассмотрение начальных тире по умолчанию, чтобы указать, что это опция, а не аргумент опции. Затем, если вы хотите использовать начальные тире в качестве аргумента опции, вы можете перепрыгнуть через обручи, чтобы выразить это в getopts.
user4401178 13 март 2015, в 10:31
0

@ A.Danischewski Вы смешиваете getopt и getopts . getopt необязательные аргументы с синтаксисом двойного двоеточия и является внешней утилитой, однако она крайне непереносима и не рекомендуется полагаться на нее (см. ответ Брайана и комментарий stArdustͲ). getopts - это (обычно) встроенная оболочка, и ее поведение определяется POSIX . Это портативно, но не делает причудливые вещи GNU.
Adrian Frühwirth 13 март 2015, в 11:07
0

Я, вероятно, сделал, см. En.wikipedia.org/wiki/Getopts для различий.
user4401178 13 март 2015, в 11:26
0

Почему вы используете фигурные скобки вокруг имен переменных внутри строк? Я думал, что они предназначены для отделения переменных от обычного текста, такого как "${foo}bar" но это не относится ни к одному из ваших применений. Мое понимание неверно?
user1011471 11 авг. 2015, в 18:13
3

@ user1011471 Вы правы! Фигурные скобки, так сказать, просто помогают лексеру bash в определении переменных. Во многих случаях они не нужны, и тот факт, что я всегда ими пользуюсь, является лишь вопросом стиля персонального кодирования. На мой взгляд, проще (и красивее) просто всегда использовать их, а не вспоминать правила синтаксического анализа в отношении неоднозначности. Примерно то же самое, почему можно написать if (foo) { bar; } вместо if (foo) bar; на языке C-стиля (эстетика и / или избежание глупых ошибок).
Adrian Frühwirth 12 авг. 2015, в 09:17
0

@ AdrianFrühwirth - Как я могу проверить одно или оба условия. Любой из -s или -p ИЛИ -s & -p?
S R 20 май 2016, в 03:05
0

Это возможно с числовыми именами аргументов (например, -2 )?
noɥʇʎԀʎzɐɹƆ 11 авг. 2016, в 15:32
0

@ uoɥʇʎPʎzɐɹC Почему бы не попробовать? Подсказка: это действительно поддерживается. getopts следует Руководству по синтаксису getopts программы POSIX, в котором говорится, что «каждое имя опции должно быть одним буквенно-цифровым символом (классификацией символов alnum) из переносимого набора символов ». Это включает в себя однозначные параметры.
Adrian Frühwirth 12 авг. 2016, в 11:17
0

как разобрать длинный вариант? например: --include = file.c
Lion Lai 24 март 2017, в 10:28
1

«не существует такой вещи, как« необязательные аргументы »с getopts» <- К сожалению, именно поэтому я обычно предпочитаю просто использовать while / case… (извините за огромный однострочный): usage() { printf "Usage: %s <req> [<-s|--sopt> <45|90>] [<-p|--popt> <string>]\n" "$0"; return 1; }; main() { req="${1:?$(usage)}"; shift; s=""; p=""; while [ "$#" -ge 1 ]; do case "$1" in -s|--sopt) shift; s="${1:?$(usage)}"; [ "$s" -eq 45 ] || [ "$s" -eq 90 ] || { usage; return 1; } ;; -p|--popt) shift; p="${1:?$(usage)}" ;; *) usage; return 1 ;; esac; shift; done; printf "req = %s\ns = %s\np = %s\n" "$req" "$s" "$p"; }; main "$@"
Mark G. 04 апр. 2017, в 03:23
1

@MarkG. Может быть, вы хотите сделать это ответом вместо комментария? Это, безусловно, действительный.
I0_ol 16 апр. 2017, в 00:15
1

@LionLai Нет способа разобрать длинные параметры в POSIX-совместимом виде. В системах GNU вы можете использовать getopt GNU (который входит в комплект util-linux). Но, конечно, это не портативно.
n.caillou 22 нояб. 2017, в 22:35
1

@MarkG. Это не POSIX-совместимый; он потерпит неудачу, если между параметрами и их аргументом не будет пробела.
n.caillou 22 нояб. 2017, в 22:52
0

@ I0_ol Вопрос, в частности, требует примера «Как использовать getopts», и мой комментарий полностью отклоняет этот запрос. : P (У меня есть личная неприязнь к ответам, которые отвечают «Как мне сделать X?» На «Не делай Y вместо этого», потому что это загрязняет поиски людей, которые законно хотят сделать Х. Итак, я подумал, что я постараюсь не способствовать этому явлению ...) @ n.caillou Правда. Я не пытался сделать его совместимым, потому что однострочник уже становился довольно длинным. Хотя было бы тривиально заставить его соответствовать, например, case "$1" in -s*) s=${1#-s}; if [ -z "$s" ]; shift; s=$1; fi т. д.
Mark G. 23 авг. 2018, в 15:09

Показать ещё 19 комментариев