쉘 스크립트를 사용하여 길고 짧은 형태의 명령 행 옵션을 호출하고 싶습니다.

나는 그것이 getopts사용될 수 있다는 것을 알고 있지만 Perl과 마찬가지로 쉘로도 똑같이 할 수 없었습니다.

이 작업을 수행하는 방법에 대한 아이디어는 다음과 같은 옵션을 사용할 수 있습니다.

./shell.sh --copyfile abc.pl /tmp/
./shell.sh -c abc.pl /tmp/

위의 두 명령 모두 내 쉘과 동일한 것을 의미하지만을 사용 getopts하면이를 구현할 수 없습니까?

고려할 수있는 세 가지 구현이 있습니다.

• 배쉬 내장 getopts. 이중 대시 접두사가있는 긴 옵션 이름은 지원하지 않습니다. 단일 문자 옵션 만 지원합니다.

• 독립형 getopt명령 의 BSD UNIX 구현 (MacOS가 사용하는 것). 긴 옵션도 지원하지 않습니다.

• 독립형 GNU 구현 getopt. GNU getopt(3)( getopt(1)Linux 의 명령 행 에서 사용)는 긴 옵션 구문 분석을 지원합니다.

다른 답변 getopts은 긴 옵션을 모방하기 위해 bash 내장 을 사용하는 솔루션을 보여줍니다 . 이 솔루션은 실제로 문자가 "-"인 짧은 옵션을 만듭니다. 따라서 플래그로 "-"를 얻습니다. 그런 다음 그 뒤에 OPTARG가되고 중첩으로 OPTARG를 테스트합니다 case.

이것은 영리하지만주의 사항이 있습니다.

• getoptsopt 사양을 시행 할 수 없습니다. 사용자가 잘못된 옵션을 제공하면 오류를 반환 할 수 없습니다. OPTARG를 구문 분석 할 때 고유 한 오류 점검을 수행해야합니다.
• OPTARG는 긴 옵션 이름에 사용되므로 긴 옵션 자체에 인수가있는 경우 사용법이 복잡해집니다. 추가 사례로 직접 코딩해야합니다.

따라서 긴 옵션에 대한 지원 부족을 해결하기 위해 더 많은 코드를 작성할 수는 있지만 훨씬 더 많은 작업이며 getopt 파서를 사용하여 코드를 단순화하는 목적을 부분적으로 무효화합니다.

getopt그리고 getopts다른 짐승이 있고, 사람들은 무슨 오해의 조금을 갖고있는 것 같다. getopts는 bash명령 행 옵션을 루프로 처리하고 찾은 각 옵션과 값을 내장 변수에 차례로 지정하여 추가로 처리 할 수있는 내장 명령입니다. getopt그러나 외부 유틸리티 프로그램이며 bash , Perl 모듈 또는 Python / 모듈 과 같은 옵션을 실제로 처리하지는 않습니다 . 이 모든 수행은 규범화에게 전달되는 옵션입니다 - 즉, 그것이 그들을 처리하는 쉘 스크립트 쉽게 그래서, 더 표준 형태로 변환. 예를 들어의 응용 프로그램은 다음을 변환 할 수 있습니다.getoptsGetoptoptparseargparsegetoptgetopt

myscript -ab infile.txt -ooutfile.txt

이것으로 :

myscript -a -b -o outfile.txt infile.txt

실제 처리를 직접 수행해야합니다. getopt옵션을 지정할 수있는 방법에 대해 다양한 제한을 설정 한 경우 전혀 사용할 필요가 없습니다 .

• 인수 당 하나의 옵션 만 넣으십시오.
• 모든 옵션은 위치 매개 변수 (즉, 옵션이 아닌 인수)보다 우선합니다.
• 값이있는 옵션 (예 : -o위)의 경우 값은 공백 뒤에 별도의 인수로 가야합니다.

왜 getopt대신에 사용 getopts합니까? 기본적인 이유는 GNU만이 getopt긴 이름의 명령 줄 옵션을 지원하기 때문입니다 . ¹ ( getoptLinux에서는 GNU 가 기본값입니다. Mac OS X 및 FreeBSD는 기본적이고 유용 getopt하지는 않지만 GNU 버전을 설치할 수 있습니다 (아래 참조).

예를 들어, 다음 getopt은 내 스크립트에서 GNU를 사용하는 예입니다 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

이를 통해 유사 --verbose -dm4096 --minh=20 --maxhe 40 --debugfi="/Users/John Johnson/debug.txt"하거나 유사한 옵션을 지정할 수 있습니다 . 호출의 효과는 getopt옵션을 --verbose -d -m 4096 --minheap 20 --maxheap 40 --debugfile "/Users/John Johnson/debug.txt"보다 쉽게 ​​처리 할 수 ​​있도록 옵션을 정규화하는 것입니다. 주위에 인용 "$1"하고 "$2"그들에 공백이 제대로 처리 얻을과 그 인수를 보장하므로 중요하다.

처음 9 줄을 삭제하면 (모든 eval set줄 을 통해 ) 코드가 계속 작동합니다 ! 그러나 코드는 어떤 종류의 옵션을 받아 들일지 결정하기가 훨씬 쉽습니다. 특히, 위에서 설명한 "정식"형식으로 모든 옵션을 지정해야합니다. 의 사용으로 getopt, 그러나, 당신은 그룹의 단일 문자 옵션은 긴 옵션을 사용하여 하나의 짧은 비 모호한 형태로 사용할 수 있습니다 --file foo.txt또는 --file=foo.txt중 스타일, 사용 -m 4096또는 -m4096스타일, 임의의 순서로 옵션이 아닌 옵션을 혼합 등 getopt인식 할 수 없거나 모호한 옵션이있는 경우 오류 메시지를 출력합니다.

참고 : 실제로 기능과 호출 규칙이 서로 다른 완전히 다른getopt 기본 버전 getopt과 GNU 버전이 getopt있습니다. ² 기본 getopt은 상당히 깨졌습니다 : 긴 옵션을 처리 할뿐만 아니라 인수 또는 빈 인수 내부에 포함 된 공백도 처리 할 수 ​​없지만 getopts올바른 작업을 수행합니다. 위 코드는 기본적으로 작동하지 않습니다 getopt. GNU getopt는 기본적으로 Linux에 설치되지만 Mac OS X 및 FreeBSD에는 별도로 설치해야합니다. Mac OS X의 경우 MacPorts ( http://www.macports.org ) sudo port install getopt를 설치 한 다음 GNU getopt(일반적으로로 /opt/local/bin) 를 설치 하고 /opt/local/bin셸 경로 앞에 있어야 합니다./usr/bin. FreeBSD에서 설치하십시오 misc/getopt.

자신의 프로그램에 대한 예제 코드를 수정하기위한 빠른 안내서 : 처음 몇 줄 중에서 모두 "보일러 판"은 호출하는 줄을 제외하고 동일하게 유지되어야합니다 getopt. 뒤에 프로그램 이름을 변경하고 뒤에 -n짧은 옵션을 지정 -o하고 뒤에 긴 옵션을 지정해야 --long합니다. 값을 취하는 옵션 뒤에 콜론을 넣으십시오.

마지막으로, set대신에 코드가 있으면 eval setBSD 용으로 작성된 것입니다 getopt. eval set두 가지 버전 모두에서 잘 작동 하는 스타일 을 사용하도록 변경해야 getopt하지만 일반 set은 GNU에서 제대로 작동하지 않습니다 getopt.

¹ 실제로 는 긴 이름의 옵션 getopts을 ksh93지원하지만이 쉘은 자주 사용되지 않습니다 bash. 에서 zsh사용 zparseopts이 기능을 얻을 수 있습니다.

² 기술적으로 "GNU getopt"는 잘못된 이름입니다. 이 버전은 실제로 GNU 프로젝트가 아닌 Linux 용으로 작성되었습니다. 그러나 모든 GNU 규칙을 따르며 getopt" GNU " 라는 용어 가 일반적으로 사용됩니다 (예 : FreeBSD에서).

Bash 내장 getopts 함수는 대시 문자와 콜론을 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

현재 작업 디렉토리getopts_test.sh 에서 실행 파일 이름 = 에 복사 한 후 다음 과 같은 출력을 생성 할 수 있습니다

$ ./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'

분명히 getopts OPTERR는 긴 옵션에 대해 검사 또는 옵션 인수 구문 분석을 수행 하지 않습니다. 위의 스크립트 조각은이를 수동으로 수행하는 방법을 보여줍니다. 기본 원칙은 데비안 Almquist 쉘 ( "대시")에서도 작동합니다. 특수한 경우를 참고하십시오.

getopts -- "-:"  ## without the option terminator "-- " bash complains about "-:"
getopts "-:"     ## this works in the Debian Almquist shell ("dash")

http://mywiki.wooledge.org/BashFAQ 에서 GreyCat이 처음부터 지적했듯이이 트릭은 옵션 인수를 허용하는 쉘의 비표준 동작 (예 : "-f filename"의 파일 이름)을 이용합니다. "-ffilename"에서와 같이 옵션에 연결됩니다. POSIX의 "- longoption"옵션 구문 분석을 종료 할 비 옵션 인수에 모든 longoptions를 켜 표준의 경우 그 사이에 공간이 있어야합니다 말한다.

내장 getopts명령은 여전히 ​​AFAIK이며 단일 문자 옵션으로 만 제한됩니다.

getopt파싱하기 쉽도록 옵션 세트를 재구성 하는 외부 프로그램 이 있습니다. 긴 옵션도 처리하도록 해당 디자인을 조정할 수 있습니다. 사용법 예 :

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
...

getoptlong명령 과 함께 비슷한 구성표를 사용할 수 있습니다 .

외부 getopt프로그램 의 근본적인 약점 은 공백이있는 인수를 처리하고 해당 공백을 정확하게 보존하는 데 어려움이 있다는 점에 유의하십시오 . 이것이 getopts단일 문자 옵션 만 처리한다는 사실에 의해 제한 되기는하지만 내장 기능 이 우수한 이유 입니다.

긴 옵션과 함께 getopt를 실제로 사용하는 예는 다음과 같습니다.

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

표준 getopts내장에서는 -"옵션" 의 " 인수"로 긴 옵션을 구문 분석 할 수 있습니다.

이것은 이식 가능한 기본 POSIX 셸이므로 외부 프로그램이나 bashism이 필요하지 않습니다.

받는 인수로이 가이드 구현 긴 옵션 -옵션은, 그래서 --alpha으로 볼 getopts로 -인수 alpha와 --bravo=foo같이 보인다 -인수 bravo=foo. 간단한 인수로 진정한 인수를 얻을 수 있습니다 ${OPTARG#*=}.

이 예에서 -b및 -c(및 긴 형식 --bravo및 --charlie)에는 필수 인수가 있습니다. 긴 옵션에 대한 인수는 등호 뒤에옵니다 --bravo=foo( 예 : 긴 옵션에 대한 공백 구분 기호는 구현하기 어렵습니다 (아래 참조)).

이것은 사용하기 때문에 getopts내장을 , 같은이 솔루션 지원 사용 cmd --bravo=foo -ac FILE(옵션 결합했다 -a그리고 -c여기에 하나 투쟁을하는 동안 대부분의 다른 답변을 인터리빙 표준 옵션 긴 옵션) 또는 실패는 그렇게 할 수 있습니다.

die() { echo "$*" >&2; exit 2; }  # complain to STDERR and exit with error
needs_arg() { if [ -z "$OPTARG" ]; then die "No arg for --$OPT option"; fi; }

while getopts ab:c:-: OPT; do
  # support long options: https://stackoverflow.com/a/28466267/519360
  if [ "$OPT" = "-" ]; then   # long option: reformulate OPT and OPTARG
    OPT="${OPTARG%%=*}"       # extract long option name
    OPTARG="${OPTARG#$OPT}"   # extract long option argument (may be empty)
    OPTARG="${OPTARG#=}"      # if long option argument, remove assigning `=`
  fi
  case "$OPT" in
    a | alpha )    alpha=true ;;
    b | bravo )    needs_arg; bravo="$OPTARG" ;;
    c | charlie )  needs_arg; charlie="$OPTARG" ;;
    ??* )          die "Illegal option --$OPT" ;;  # bad long option
    \? )           exit 2 ;;  # bad short option (error reported via getopts)
  esac
done
shift $((OPTIND-1)) # remove parsed options and args from $@ list

옵션이 대시 ( -)이면 긴 옵션입니다. getopts실제 long 옵션 ( $OPTARG예 : --bravo=foo원래 sets OPT='-'및) 을 구문 분석했습니다 OPTARG='bravo=foo'. if스 D 자 세트 $OPT의 내용에 $OPTARG최초의 등호 기호 전에 ( bravo다음 예에서)과의 처음부터 것을 제거 $OPTARG(항복하지 =foo아니가있는 경우이 단계, 또는 빈 문자열 =). 마지막으로, 논증의 선두를 제거합니다 =. 이 시점에서 $OPT짧은 옵션 (한 문자) 또는 긴 옵션 (2 자 이상)입니다.

그런 case다음 짧거나 긴 옵션과 일치합니다. 짧은 옵션의 경우 getopts옵션과 누락 된 인수에 대해 자동으로 불평하므로 비어 needs_arg있을 때 치명적으로 종료되는 함수를 사용하여 수동으로 복제해야합니다 $OPTARG. ??*조건은 남아있는 긴 옵션 (일치 ?하나의 문자와 일치와 *일치하는 0 개 이상의, 그래서 ??*우리가 종료하기 전에 "잘못된 옵션"오류를 발행 할 수 있도록 2 + 문자와 일치).

(대문자 변수 이름에 대한 참고 사항 : 일반적으로 시스템 사용을 위해 모든 대문자 변수를 예약하는 것이 좋습니다. 나는 $OPT이를 대문자로 유지하기 위해이를 대문자로 유지하고 $OPTARG있지만,이 규칙을 위반합니다. 이것은 시스템이 수행해야 할 일이기 때문에 적합하며 그러한 변수를 사용하는 표준 (afaik)이 없기 때문에 안전해야합니다.)

긴 옵션에 대한 예기치 않은 인수에 대해 불평하려면 필수 인수에 대해 수행 한 작업을 모방하십시오. 도우미 함수를 사용하십시오. 예상치 못한 인수에 대해 불평하기 위해 테스트를 뒤집기 만하면됩니다.

no_arg() { if [ -n "$OPTARG" ]; then die "No arg allowed for --$OPT option"; fi; }

이 답변 의 이전 버전은 공백으로 구분 된 인수로 긴 옵션을 수락하려고 시도했지만 신뢰할 수 없었습니다. getopts인수가 범위를 벗어 $OPTIND났고 모든 쉘에서 수동 증분 이 작동하지 않는다는 가정하에 조기 종료 할 수 있습니다.

이것은 다음 기술 중 하나를 사용하여 수행됩니다.

• POSIX 평가 : eval "bravo=\"\$$OPTIND\""
• 배쉬 간접 확장 :bravo="${!OPTIND}"
• Zsh 매개 변수 확장 P플래그 :bravo="${(P)OPTIND}"

그리고 다음과 같이 결론지었습니다. [ $# -gt $OPTIND ] && OPTIND=$((OPTIND+1))

이식 가능한 쉘 라이브러리 인 shFlags 를 살펴보십시오 (즉, Linux, Solaris 등의 경우 sh, bash, dash, ksh, zsh).

스크립트에 한 줄을 추가하는 것만 큼 간단하게 새 플래그를 추가 할 수 있으며 자동 생성 사용 기능을 제공합니다.

다음은 shFlag를Hello, world! 사용한 간단한 것입니다. .

#!/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}!"

긴 옵션 (예 : Linux)을 지원하는 향상된 getopt가있는 OS의 경우 다음을 수행 할 수 있습니다.

$ ./hello_world.sh --name Kate
Hello, Kate!

나머지는 짧은 옵션을 사용해야합니다.

$ ./hello_world.sh -n Kate
Hello, Kate!

새 플래그를 추가하는 것은 새 플래그를 추가하는 것만 큼 간단 DEFINE_ call합니다.

사용 getopts짧고 긴 옵션 및 인수와 함께

다음과 같은 모든 조합에서 작동합니다.

• foobar -f --bar
• foobar --foo -b
• foobar -bf --bar --foobar
• foobar -fbFBAshorty --bar -FB-인수 = 롱혼
• foobar -fA "텍스트 shorty"-B --arguments = "텍스트 longhorn"
• 배쉬 foobar -F --barfoo
• sh foobar -B --foobar-...
• bash ./foobar -F --bar

이 예제에 대한 일부 선언

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 "

getops 긴 / 짧은 플래그와 긴 인수

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

산출

##################################################################
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"

위의 내용을 응집력있는 스크립트로 결합

#!/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

또 다른 방법...

# 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

나는 이런 식으로 해결했다.

# 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;

내가 멍청한거야? getopt그리고 getopts혼란된다.

getopt종속성을 원하지 않는 경우 다음을 수행 할 수 있습니다.

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

물론 하나의 대시로 긴 스타일 옵션을 사용할 수 없습니다. 또한 단축 버전을 추가하려면 (예 : --verbose 대신 --verbos) 수동으로 추가해야합니다.

그러나 getopts긴 옵션과 함께 기능 을 얻으려는 경우 간단한 방법입니다.

나는 또한이 발췌 문장을 요점 에 넣었다 .

내장 getopts은 이것을 할 수 없습니다. 이를 수행 할 수 있는 외부 getopt (1) 프로그램이 있지만 util-linux 패키지의 Linux에서만 얻을 수 있습니다 . getopt-parse.bash 예제 스크립트가 제공됩니다. .

getopts_long쉘 함수로 작성된 것도 있습니다.

#!/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

에서 ksh93, getopts긴 이름을 지원 ...

while getopts "f(file):s(server):" flag
do
    echo "$flag" $OPTIND $OPTARG
done

또는 내가 찾은 자습서가 말했습니다. 사용해보십시오.

나는 단지 쉘 스크립트를 작성하고 실제로는 실용적이지 않으므로 모든 의견을 부탁드립니다.

@Arvid Requate가 제안한 전략을 사용하여 일부 사용자 오류를 발견했습니다. 값을 포함하지 않은 사용자는 실수로 다음 옵션의 이름이 값으로 취급됩니다.

./getopts_test.sh --loglevel= --toc=TRUE

"loglevel"의 값이 "--toc = TRUE"로 표시됩니다. 이것은 피할 수 있습니다.

수동 구문 분석에 대한 http://mwiki.wooledge.org/BashFAQ/035 토론 에서 CLI의 사용자 오류 확인에 대한 몇 가지 아이디어를 수정했습니다 . "-"및 "-"인수를 모두 처리 할 때 오류 검사를 삽입했습니다.

그런 다음 구문을 다루기 시작 했으므로 여기의 오류는 원래 작성자가 아닌 내 잘못입니다.

내 접근 방식은 등호의 유무에 관계없이 오랫동안 입력하는 것을 선호하는 사용자에게 도움이됩니다. 즉, "--loglevel = 9"와 같은 "--loglevel 9"에 대한 응답이 있어야합니다. -/ space 방법에서는 사용자가 인수를 잊었는지 확실하게 알 수 없으므로 약간의 추측이 필요합니다.

1. 사용자가 long / equal sign 형식 (--opt =)을 갖는 경우 인수가 제공되지 않았기 때문에 공백 뒤에 =가 있으면 오류가 발생합니다.
2. 사용자에게 긴 / 공백 인수가있는 경우 (--opt) 인수가 뒤에 없거나 (명령 끝) 인수가 대시로 시작하면이 스크립트는 실패를 발생시킵니다.

이것부터 시작한다면, "--opt = value"와 "--opt value"형식 사이에 흥미로운 차이점이 있습니다. 등호를 사용하면 명령 줄 인수는 "opt = value"로 표시되고 문자열 구문 분석을 처리하는 작업은 "="에서 분리됩니다. 반대로 "--opt value"와 함께 인수 이름은 "opt"이며 명령 행에 다음 값을 제공해야하는 문제가 있습니다. 여기서 @Arvid Requate는 간접 참조 인 $ {! OPTIND}를 사용했습니다. 나는 아직도 그것을 잘 이해하지 못하고 BashFAQ의 의견은 그 스타일에 대해 경고하는 것 같습니다 ( http://mywiki.wooledge.org/BashFAQ/006 ). BTW, OPTIND = $ (($ OPTIND + 1))의 중요성에 대한 이전 포스터의 의견은 정확하지 않다고 생각합니다. 내 말은

이 스크립트의 최신 버전에서 플래그 -v는 VERBOSE 출력을 의미합니다.

"cli-5.sh"라는 파일에 파일을 저장하고 실행 가능하게 만들면 원하는 방식으로 작동하거나 실패합니다

./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

다음은 사용자 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

OPTIND 및 OPTARG의 내부를 인쇄하므로 -v를 켜는 것이 좋습니다.

#/usr/bin/env bash

## Paul Johnson
## 20171016
##

## Combines ideas from
## /programming/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"

바퀴의 또 다른 버전을 발명 ...

이 기능은 GNU getopt를 대체하는 POSIX 호환 플레인 버논 쉘입니다. 필수 / 선택 / 인수를 받아 들일 수있는 short / long 옵션을 지원하며 옵션 지정 방식은 GNU getopt와 거의 동일하므로 변환이 쉽지 않습니다.

물론 이것은 여전히 ​​스크립트에 삽입 할 수있는 상당한 크기의 코드이지만, 잘 알려진 getopt_long 쉘 함수의 약 절반에 해당하며 기존 GNU getopt 사용을 대체하려는 경우에 바람직 할 수 있습니다.

이것은 매우 새로운 코드이므로 YMMV입니다 (이것이 실제로 POSIX와 호환되지 않는지 알려주세요. 이식성은 처음부터 의도 였지만 유용한 POSIX 테스트 환경은 없습니다).

코드 및 예제 사용법은 다음과 같습니다.

#!/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
}

사용법 예 :

# 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

허용 된 답변은 bash built-in의 모든 단점을 지적하는 훌륭한 일을 getopts합니다. 대답은 다음과 같이 끝납니다.

따라서 긴 옵션에 대한 지원 부족을 해결하기 위해 더 많은 코드를 작성할 수는 있지만 훨씬 더 많은 작업이며 getopt 파서를 사용하여 코드를 단순화하는 목적을 부분적으로 무효화합니다.

그리고 나는 그 진술에 원칙적으로 동의하지만, 우리가 다양한 스크립트에서이 기능을 구현 한 횟수는 "표준화 된"테스트를 거친 솔루션을 만드는 데 약간의 노력을 기울이는 것을 정당화한다고 생각합니다.

따라서 외부 종속성없이 순수한 bash getopts로 구현 getopts_long하여 bash를 "업그레이드"했습니다 . 이 기능의 사용은 내장과 100 % 호환됩니다 getopts.

포함하여 getopts_long(되는 GitHub의에서 호스팅 스크립트에서), 원래의 질문에 대한 대답은 간단하게 구현 될 수 있습니다 :

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

아직 솔루션에 대해 의견을 말하거나 투표 할 담당자가 충분하지 않지만 sme의 답변 은 나에게 매우 효과적이었습니다. 내가 만난 유일한 문제는 인수가 작은 따옴표로 묶여 있다는 것입니다 (따라서 스트립이 있습니다).

또한 몇 가지 예제 사용법과 도움말 텍스트를 추가했습니다. 여기에 약간 확장 된 버전이 포함됩니다 :

#!/bin/bash

# getopt example
# from: /programming/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

bash에서 복잡한 옵션 구문 분석에 대한 몇 가지 접근 방식을 찾을 수 있습니다. http://mywiki.wooledge.org/ComplexOptionParsing

나는 다음 중 하나를 만들었으며 코드가 적고 길고 짧은 옵션이 모두 작동하기 때문에 좋은 것이라고 생각합니다. 긴 옵션은이 방법으로 여러 인수를 가질 수도 있습니다.

#!/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

나는 그 주제에 대해 오랫동안 오랫동안 연구 해 왔으며 ... 내 자신의 라이브러리를 만들었고 메인 스크립트에서 소싱해야합니다. 예제는 libopt4shell 및 cd2mpc 를 참조하십시오 . 그것이 도움이되기를 바랍니다!

개선 된 솔루션 :

# 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

긴 명령 행 옵션이 필요한 경우 getopts 부분에 대해서만 ksh를 사용하는 것이 더 간단 할 수 있습니다.

# 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

엄격한 bash 지원 (-u)을 사용하여 외부 종속성이없는 것을 원했으며 이전 bash 버전에서도 작동해야했습니다. 이것은 다양한 유형의 매개 변수를 처리합니다.

• 짧은 부울 (-h)
• 짧은 옵션 (-i "image.jpg")
• 긴 바보 (-도움말)
• 옵션과 동일 (--file = "filename.ext")
• 공간 옵션 (--file "filename.ext")
• 연결된 부울 (-hvm)

스크립트 상단에 다음을 삽입하십시오.

# 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
}

그리고 그렇게 사용하십시오 :

# 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 $*

크로스 플랫폼 호환성을 유지하고 외부 실행 파일에 대한 의존을 피하기 위해 다른 언어에서 일부 코드를 이식했습니다.

사용하기가 매우 쉽다는 것을 알았습니다. 예는 다음과 같습니다.

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 )"

필요한 BASH는 예상보다 조금 길지만 BASH 4의 연관 배열에 의존하지 않기를 원했습니다. 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

모든 긴 옵션에 고유하고 일치하는 첫 문자가 짧은 옵션 인 경우, 예를 들어

./slamm --chaos 23 --plenty test -quiet

와 같다

./slamm -c 23 -p test -q

getars가 $ 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
    .....

영감을 얻은 mtvee에게 감사합니다 ;-)

단순히 이것이 당신이 스크립트를 호출하는 방법이라면

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

그런 다음 getopt 및 --longoptions를 사용하여 가장 간단한 방법으로이를 달성 할 수 있습니다.

이것을 시도하십시오, 이것이 유용하기를 바랍니다

# 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

getopts는 인수가 없을 것으로 예상되는 한 긴 옵션을 구문 분석하기 위해 "사용될 수 있습니다"...

방법은 다음과 같습니다.

$ cat > longopt
while getopts 'e:-:' OPT; do
  case $OPT in
    e) echo echo: $OPTARG;;
    -) #long option
       case $OPTARG in
         long-option) echo long option;;
         *) echo long option: $OPTARG;;
       esac;;
  esac
done

$ bash longopt -e asd --long-option --long1 --long2 -e test
echo: asd
long option
long option: long1
long option: long2
echo: test

long 옵션에 대한 매개 변수를 얻기 위해 OPTIND를 사용하려고하면 getopts는이를 선택 사항이 아닌 첫 번째 선택적 위치 매개 변수로 취급하고 다른 매개 변수의 구문 분석을 중지합니다. 이 경우 간단한 case 문을 사용하여 수동으로 처리하는 것이 좋습니다.

이것은 "항상"작동합니다.

$ cat >longopt2
while (($#)); do
    OPT=$1
    shift
    case $OPT in
        --*) case ${OPT:2} in
            long1) echo long1 option;;
            complex) echo comples with argument $1; shift;;
        esac;;

        -*) case ${OPT:1} in
            a) echo short option a;;
            b) echo short option b with parameter $1; shift;;
        esac;;
    esac
done


$ bash longopt2 --complex abc -a --long -b test
comples with argument abc
short option a
short option b with parameter test

getopts만큼 유연하지는 않지만 사례 인스턴스 내에서 직접 오류 검사 코드를 수행해야합니다 ...

그러나 옵션입니다.

내장getopts 은 짧은 옵션 만 구문 분석하지만 (ksh93 제외) getopts가 긴 옵션을 처리하도록 몇 줄의 스크립팅을 추가 할 수 있습니다.

다음은 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))