我给你一个函数parse_params，它将从命令行解析参数。

这是一个纯Bash解决方案，没有额外的实用程序。不会污染全球范围。轻松地返回简单易用的变量，您可以在这些变量上构建进一步的逻辑。params前面的破折号数量无关紧要（--all等于-all等于all=all）

下面的脚本是复制粘贴工作演示。请参见show_use函数以了解如何使用parse_param。

限制：

不支持空格分隔的参数（-d 1）参数名称将丢失破折号，因此--any参数和-anyparam等效eval$（parse_params“$@”）必须在bash函数中使用（它在全局范围内不起作用）

#!/bin/bash

# Universal Bash parameter parsing
# Parse equal sign separated params into named local variables
# Standalone named parameter value will equal its param name (--force creates variable $force=="force")
# Parses multi-valued named params into an array (--path=path1 --path=path2 creates ${path[*]} array)
# Puts un-named params as-is into ${ARGV[*]} array
# Additionally puts all named params as-is into ${ARGN[*]} array
# Additionally puts all standalone "option" params as-is into ${ARGO[*]} array
# @author Oleksii Chekulaiev
# @version v1.4.1 (Jul-27-2018)
parse_params ()
{
    local existing_named
    local ARGV=() # un-named params
    local ARGN=() # named params
    local ARGO=() # options (--params)
    echo "local ARGV=(); local ARGN=(); local ARGO=();"
    while [[ "$1" != "" ]]; do
        # Escape asterisk to prevent bash asterisk expansion, and quotes to prevent string breakage
        _escaped=${1/\*/\'\"*\"\'}
        _escaped=${_escaped//\'/\\\'}
        _escaped=${_escaped//\"/\\\"}
        # If equals delimited named parameter
        nonspace="[^[:space:]]"
        if [[ "$1" =~ ^${nonspace}${nonspace}*=..* ]]; then
            # Add to named parameters array
            echo "ARGN+=('$_escaped');"
            # key is part before first =
            local _key=$(echo "$1" | cut -d = -f 1)
            # Just add as non-named when key is empty or contains space
            if [[ "$_key" == "" || "$_key" =~ " " ]]; then
                echo "ARGV+=('$_escaped');"
                shift
                continue
            fi
            # val is everything after key and = (protect from param==value error)
            local _val="${1/$_key=}"
            # remove dashes from key name
            _key=${_key//\-}
            # skip when key is empty
            # search for existing parameter name
            if (echo "$existing_named" | grep "\b$_key\b" >/dev/null); then
                # if name already exists then it's a multi-value named parameter
                # re-declare it as an array if needed
                if ! (declare -p _key 2> /dev/null | grep -q 'declare \-a'); then
                    echo "$_key=(\"\$$_key\");"
                fi
                # append new value
                echo "$_key+=('$_val');"
            else
                # single-value named parameter
                echo "local $_key='$_val';"
                existing_named=" $_key"
            fi
        # If standalone named parameter
        elif [[ "$1" =~ ^\-${nonspace}+ ]]; then
            # remove dashes
            local _key=${1//\-}
            # Just add as non-named when key is empty or contains space
            if [[ "$_key" == "" || "$_key" =~ " " ]]; then
                echo "ARGV+=('$_escaped');"
                shift
                continue
            fi
            # Add to options array
            echo "ARGO+=('$_escaped');"
            echo "local $_key=\"$_key\";"
        # non-named parameter
        else
            # Escape asterisk to prevent bash asterisk expansion
            _escaped=${1/\*/\'\"*\"\'}
            echo "ARGV+=('$_escaped');"
        fi
        shift
    done
}

#--------------------------- DEMO OF THE USAGE -------------------------------

show_use ()
{
    eval $(parse_params "$@")
    # --
    echo "${ARGV[0]}" # print first unnamed param
    echo "${ARGV[1]}" # print second unnamed param
    echo "${ARGN[0]}" # print first named param
    echo "${ARG0[0]}" # print first option param (--force)
    echo "$anyparam"  # print --anyparam value
    echo "$k"         # print k=5 value
    echo "${multivalue[0]}" # print first value of multi-value
    echo "${multivalue[1]}" # print second value of multi-value
    [[ "$force" == "force" ]] && echo "\$force is set so let the force be with you"
}

show_use "param 1" --anyparam="my value" param2 k=5 --force --multi-value=test1 --multi-value=test2

另一个Shell参数分析器（ASAP）

符合POSIX，无getopt

我受到@bronson相对简单的回答的启发，并试图改进它（不增加太多复杂性）。结果如下：

使用-n[arg]、-abn[arg]，--name[arg]和--name=arg样式中的任意一种选项；参数可以按任何顺序出现，循环后$@中只留下位置参数；使用--强制将剩余的参数视为位置参数；检测无效选项和缺少的参数；不依赖于getopt或外部工具（一个功能使用简单的sed命令）；便携式，紧凑，可读性强，具有独立功能。

# Convenience functions.
usage_error () { echo >&2 "$(basename $0):  $1"; exit 2; }
assert_argument () { test "$1" != "$EOL" || usage_error "$2 requires an argument"; }

# One loop, nothing more.
if [ "$#" != 0 ]; then
  EOL=$(printf '\1\3\3\7')
  set -- "$@" "$EOL"
  while [ "$1" != "$EOL" ]; do
    opt="$1"; shift
    case "$opt" in

      # Your options go here.
      -f|--flag) flag='true';;
      -n|--name) assert_argument "$1" "$opt"; name="$1"; shift;;

      # Arguments processing. You may remove any unneeded line after the 1st.
      -|''|[!-]*) set -- "$@" "$opt";;                                          # positional argument, rotate to the end
      --*=*)      set -- "${opt%%=*}" "${opt#*=}" "$@";;                        # convert '--name=arg' to '--name' 'arg'
      -[!-]?*)    set -- $(echo "${opt#-}" | sed 's/\(.\)/ -\1/g') "$@";;       # convert '-abc' to '-a' '-b' '-c'
      --)         while [ "$1" != "$EOL" ]; do set -- "$@" "$1"; shift; done;;  # process remaining arguments as positional
      -*)         usage_error "unknown option: '$opt'";;                        # catch misspelled options
      *)          usage_error "this should NEVER happen ($opt)";;               # sanity test for previous patterns

    esac
  done
  shift  # $EOL
fi

# Do something cool with "$@"... \o/

注：我知道。。。二进制模式为0x01030307的参数可能会破坏逻辑。但是，如果有人在命令行中传递这样的参数，他们应该得到它。

这也可能很有用：您可以设置一个值，如果有人提供输入，则使用该值覆盖默认值。

myscript.sh-f/serverlist.txt或只是/myscript.sh（它采用默认值）

    #!/bin/bash
    # --- set the value, if there is inputs, override the defaults.

    HOME_FOLDER="${HOME}/owned_id_checker"
    SERVER_FILE_LIST="${HOME_FOLDER}/server_list.txt"

    while [[ $# > 1 ]]
    do
    key="$1"
    shift
    
    case $key in
        -i|--inputlist)
        SERVER_FILE_LIST="$1"
        shift
        ;;
    esac
    done

    
    echo "SERVER LIST   = ${SERVER_FILE_LIST}"

我使用optget和optgets的组合来解析带或不带参数的短选项和长选项，甚至是非选项（不带-或-的选项）：

# catch wrong options and move non-options to the end of the string
args=$(getopt -l "$opt_long" "$opt_short" "$@" 2> >(sed -e 's/^/stderr/g')) || echo -n "Error: " && echo "$args" | grep -oP "(?<=^stderr).*" && exit 1
mapfile -t args < <(xargs -n1 <<< "$(echo "$args" | sed -E "s/(--[^ ]+) /\1=/g")" )
set -- "${args[@]}"

# parse short and long options
while getopts "$opt_short-:" opt; do
  ...
done

# remove all parsed options from $@
shift $((OPTIND-1)

这样，我就可以使用$opt_verbose这样的变量访问所有选项，而非选项可以通过默认变量$1、$2等访问：

echo "help:$opt_help"
echo "file:$opt_file"
echo "verbose:$opt_verbose"
echo "long_only:$opt_long_only"
echo "short_only:$opt_s"
echo "path:$1"
echo "mail:$2"

其中一个主要特点是，我能够以完全随机的顺序传递所有选项和非选项：

#             $opt_file     $1        $2          $opt_... $opt_... $opt_...
# /demo.sh --file=file.txt /dir info@example.com -V -h --long_only=yes -s
help:1
file:file.txt
verbose:1
long_only:yes
short_only:1
path:/dir
mail:info@example.com

更多详情：https://stackoverflow.com/a/74275254/318765

另一个没有getopt[s]、POSIX、旧Unix风格的解决方案

与Bruno Bronosky发布的解决方案类似，这里没有使用getopt。

我的解决方案的主要区别在于，它允许将选项连接在一起，就像tar-xzf foo.tar.gz等于tar-x-z-f foo.tar.gif一样。就像在tar、ps等中一样，前导连字符对于短选项块是可选的（但这可以很容易地更改）。也支持长选项（但当块以一个开始时，则需要两个前导连字符）。

带有示例选项的代码

#!/bin/sh

echo
echo "POSIX-compliant getopt(s)-free old-style-supporting option parser from phk@[se.unix]"
echo

print_usage() {
  echo "Usage:

  $0 {a|b|c} [ARG...]

Options:

  --aaa-0-args
  -a
    Option without arguments.

  --bbb-1-args ARG
  -b ARG
    Option with one argument.

  --ccc-2-args ARG1 ARG2
  -c ARG1 ARG2
    Option with two arguments.

" >&2
}

if [ $# -le 0 ]; then
  print_usage
  exit 1
fi

opt=
while :; do

  if [ $# -le 0 ]; then

    # no parameters remaining -> end option parsing
    break

  elif [ ! "$opt" ]; then

    # we are at the beginning of a fresh block
    # remove optional leading hyphen and strip trailing whitespaces
    opt=$(echo "$1" | sed 's/^-\?\([a-zA-Z0-9\?-]*\)/\1/')

  fi

  # get the first character -> check whether long option
  first_chr=$(echo "$opt" | awk '{print substr($1, 1, 1)}')
  [ "$first_chr" = - ] && long_option=T || long_option=F

  # note to write the options here with a leading hyphen less
  # also do not forget to end short options with a star
  case $opt in

    -)

      # end of options
      shift
      break
      ;;

    a*|-aaa-0-args)

      echo "Option AAA activated!"
      ;;

    b*|-bbb-1-args)

      if [ "$2" ]; then
        echo "Option BBB with argument '$2' activated!"
        shift
      else
        echo "BBB parameters incomplete!" >&2
        print_usage
        exit 1
      fi
      ;;

    c*|-ccc-2-args)

      if [ "$2" ] && [ "$3" ]; then
        echo "Option CCC with arguments '$2' and '$3' activated!"
        shift 2
      else
        echo "CCC parameters incomplete!" >&2
        print_usage
        exit 1
      fi
      ;;

    h*|\?*|-help)

      print_usage
      exit 0
      ;;

    *)

      if [ "$long_option" = T ]; then
        opt=$(echo "$opt" | awk '{print substr($1, 2)}')
      else
        opt=$first_chr
      fi
      printf 'Error: Unknown option: "%s"\n' "$opt" >&2
      print_usage
      exit 1
      ;;

  esac

  if [ "$long_option" = T ]; then

    # if we had a long option then we are going to get a new block next
    shift
    opt=

  else

    # if we had a short option then just move to the next character
    opt=$(echo "$opt" | awk '{print substr($1, 2)}')

    # if block is now empty then shift to the next one
    [ "$opt" ] || shift

  fi

done

echo "Doing something..."

exit 0

有关示例用法，请参阅下面的示例。

带参数选项的位置

不管有什么价值，带参数的选项并不是最后一个（只需要长选项）。因此，虽然在tar（至少在某些实现中）中，f选项需要是最后一个，因为文件名在后面（tar xzf bar.tar.gz有效，但tar xfz bar.tar.gif无效），但这里的情况并非如此（请参阅后面的示例）。

带参数的多个选项

作为另一个奖励，选项参数按选项的顺序由具有所需选项的参数消耗。只需使用命令行abc X Y Z（或-abc X Y Z）查看脚本的输出即可：

Option AAA activated!
Option BBB with argument 'X' activated!
Option CCC with arguments 'Y' and 'Z' activated!

长选项也连接在一起

此外，您也可以在选项块中使用长选项，因为它们出现在选项块的最后。因此，以下命令行都是等效的（包括处理选项及其参数的顺序）：

-cba Z Y Xcba Z Y X-cb-aaa-0-args Z Y X-c-bbb-1-args Z Y X-a--ccc-2-args Z Y-ba Xc Z Y b X a-c Z Y-b X-a--ccc-2-args Z Y--bbb-1-args X--aaa-0-args

所有这些都会导致：

Option CCC with arguments 'Z' and 'Y' activated!
Option BBB with argument 'X' activated!
Option AAA activated!
Doing something...

不在此解决方案中

可选参数

带有可选参数的选项应该可以通过一些工作来实现，例如，通过查看是否有不带连字符的块；然后，用户需要在带有可选参数的块后面的每个块前面加上连字符。也许这太复杂了，无法与用户进行通信，所以在这种情况下，只需要一个前导连字符就可以了。

有了多个可能的参数，事情变得更加复杂。我建议不要让选项试图通过确定某个参数是否适合它来变得聪明（例如，选项只是将数字作为可选参数），因为这可能会在未来中断。

我个人更喜欢附加选项，而不是可选参数。

带等号的选项参数

就像可选参数一样，我不喜欢这个（顺便问一下，是否有讨论不同参数样式利弊的线程？）但如果你想这样做，你可能可以像在http://mywiki.wooledge.org/BashFAQ/035#Manual_loop带--long，arg=？*case语句，然后去掉等号（这是BTW网站，该网站说通过一些努力可以进行参数连接，但“将其作为练习留给读者”，这让我相信他们的话，但我从头开始）。

其他注意事项

POSIX兼容，即使在我必须处理的古老Busybox设置上也能工作（例如，缺少切割、头部和getopts）。

getopt（）/getopts（）是一个很好的选项。从此处复制：

“getopt”的简单用法如下小脚本所示：

#!/bin/bash
echo "Before getopt"
for i
do
  echo $i
done
args=`getopt abc:d $*`
set -- $args
echo "After getopt"
for i
do
  echo "-->$i"
done

我们所说的是，-b、 -c或-d将被允许，但-c后面跟着一个参数（“c:”表示）。如果我们称之为“g”并尝试：

bash-2.05a$ ./g -abc foo
Before getopt
-abc
foo
After getopt
-->-a
-->-b
-->-c
-->foo
-->--

我们从两个参数开始“getopt”将选项和每个人都有自己的论点。它也是添加了“--”。