getopt, getopts or manual parsing - what to use when I want to support both short and long options?

Question

Currently I'm writing a Bash script which has the following requirements:

• it should run on a wide variety of Unix/Linux platforms
• it should support both short and (GNU) long options

I know that getopts would be the preferred way in terms of portability but AFAIK it doesn't support long options.

getopt supports long options but the BashGuide recommends strongly against it:

Never use getopt(1). getopt cannot handle empty arguments strings, or arguments with embedded whitespace. Please forget that it ever existed.

So, there still is the option of manual parsing. This is error-prone, produces quite some boilerplate code, and I need to handle errors by myself (I guess getopt(s) do error-handling by themselves).

So, what would be the preferred choice in this case?

Answer 1

getopt vs getopts seems to be a religious issue. As for the arguments against getopt in the Bash FAQ:

• "getopt cannot handle empty arguments strings" seems to refer to a known issue with optional arguments, which it looks like getopts doesn't support at all (at least from reading help getopts for Bash 4.2.24). From man getopt:

  getopt(3) can parse long options with optional arguments that are given an empty optional argument (but can not do this for short options). This getopt(1) treats optional arguments that are empty as if they were not present.

Many "traditional" implementations of getopt indeed cannot parse arguments with embedded whitespace, but that's not the case with the one from util-linux or the one included in Busybox:

• test.sh:

  #!/usr/bin/env bash
  getopt -T
  if [ "$?" != 4 ]; then
      echo 2>&1 "Wrong version of 'getopt' detected, exiting..."
      exit 1
  fi
  set -o errexit -o noclobber -o nounset -o pipefail
  params="$(getopt -o ab:c -l alpha,bravo:,charlie --name "$0" -- "$@")"
  eval set -- "$params"
  while true
  do
      case "$1" in
          -a|--alpha)
              echo alpha
              shift
              ;;
          -b|--bravo)
              echo "bravo=$2"
              shift 2
              ;;
          -c|--charlie)
              echo charlie
              shift
              ;;
          --)
              shift
              break
              ;;
          *)
              echo "Not implemented: $1" >&2
              exit 1
              ;;
      esac
  done
  

• run:

  $ ./test.sh -
  $ ./test.sh -acb '   whitespace   FTW   '
  alpha
  charlie
  bravo=   whitespace   FTW   
  $ ./test.sh -ab '' -c
  alpha
  bravo=
  charlie
  $ ./test.sh --alpha --bravo '   whitespace   FTW   ' --charlie
  alpha
  bravo=   whitespace   FTW   
  charlie
  

Of course the portability issue still stands; you'll have to decide how much time is worth investing in platforms without that version of getopt. My own tip is to use the YAGNI and KISS guidelines - Only develop for those specific platforms which you know are going to be used. Shell code portability generally goes to 100% as development time goes to infinity.

Answer 2

If it has to be portable to a range of Unices, you'd have to stick to POSIX sh. And AFAIU there you just have no choice but rolling argument handling by hand.

Answer 3

There's this getopts_long written as a POSIX shell function that you may embed inside your script.

Note that the Linux getopt (from util-linux) works correctly when not in traditional mode and supports long options, but is probably not an option for you if you need to be portable to other Unices.

Recent versions of ksh93 (getopts) and zsh (zparseopts) have built-in support for parsing long options which might be an option for you as those are available for most Unices (though often not installed by default).

Another option would be to use perl and its Getopt::Long module both of which should be available on most Unices nowadays, either by writing the whole script in perl or just call perl just to parse the option and feed the extracted information to the shell. Something like:

parsed_ops=$(
  perl -MGetopt::Long -le '

    @options = (
      "foo=s", "bar", "neg!"
    );

    Getopt::Long::Configure "bundling";
    $q="'\''";
    GetOptions(@options) or exit 1;
    for (map /(\w+)/, @options) {
      eval "\$o=\$opt_$_";
      $o =~ s/$q/$q\\$q$q/g;
      print "opt_$_=$q$o$q"
    }' -- "$@"
) || exit
eval "$parsed_ops"
# and then use $opt_foo, $opt_bar...

See perldoc Getopt::Long for what it can do and how it differs from other option parsers.

Answer 4

Every discussion on this matter highlight the option to write the parsing code manually - only then you can be sure about the functionality and portability. I advise you not to write code that you can have generated and re-generated by easy-to-use open-source code generators. Use Argbash, which has been designed to provide the definitive answer to your problem. It is a well-documented code generator available as a command-line application, online or as a Docker image.

I advise against bash libraries, some of them use getopt (which makes quite unportable) and it is a pain to bundle a gigantic unreadable shell blob with your script.

Answer 5

You could use getopt on systems that support it and use a fall back for systems that don't.

For instance pure-getopt is implemented in pure Bash to be a drop-in replacement for GNU getopt.