
Getopts

codice_1 is a built-in Unix shell command for parsing command-line arguments. It is designed to process command line arguments that follow the POSIX Utility Syntax Guidelines, based on the C interface of getopt.
The predecessor to was the external program by Unix System Laboratories.
History.
The original had several problems: it could not handle whitespace or shell metacharacters in arguments, and there was no ability to disable the output of error messages.
codice_1 was first introduced in 1986 in the Bourne shell shipped with Unix SVR3. It uses the shell's own variables to track the position of current and argument positions, and , and returns the option name in a shell variable. Earlier versions of the Bourne shell did not have "getopts".
In 1995, codice_1 was included in the Single UNIX Specification version 1 / X/Open Portability Guidelines Issue 4. As a result, codice_1 is now available in shells including the Bourne shell, KornShell, Almquist shell, Bash and Zsh.
The command has also been ported to the IBM i operating system.
The modern usage of was partially revived mainly due to an enhanced implementation in util-linux. This version, based on the BSD , not only fixed the two complaints around the old , but also introduced the capability for parsing GNU-style long options and optional arguments for options, features that lacks. The various BSD distributions, however, stuck to the old implementation.
Usage.
The usage synopsis of getopt and getopts is similar to its C sibling:
 getopt "optstring" "[parameters]"
 getopts "optstring" "varname" "[parameters]"
The way one uses the commands however varies a lot:
Enhancements.
In various getopts.
In spring 2004 (Solaris 10 beta development), the libc implementation for was enhanced to support long options. As a result, this new feature was also available in the built-in command codice_1 of the Bourne Shell. This is triggered by parenthesized suffixes in the "optstring" specifying long aliases.
KornShell and Zsh both have an extension for long arguments. The former is defined as in Solaris, while the latter is implemented via a separate command.
KornShell additionally implements "optstring" extensions for options beginning with instead of .
In Linux getopt.
An alternative to codice_1 is the Linux enhanced version of codice_7, the external command line program.
The Linux enhanced version of codice_7 has the extra safety of codice_1 plus more advanced features. It supports long option names (e.g. codice_10) and the options do not have to appear before all the operands (e.g. codice_11 is permitted by the Linux enhanced version of codice_7 but does not work with codice_1). It also supports escaping metacharacters for shells (like tcsh and POSIX sh) and optional arguments.
Examples.
Suppose we are building a Wikipedia downloader in bash that takes three options and zero extra arguments:
 wpdown -a "article name" -l "[language]" -v
When possible, we allow the following long arguments:
 -a --article
 -l --language, --lang
 -v --verbose
For clarity, no help text is included, and we assume there is a program that downloads any webpage. In addition, all programs are of the form:
VERBOSE=0
ARTICLE="
LANG=en
if ((VERBOSE > 2)); then
 printf '%s\n' 'Non-option arguments:'
 printf '%q ' "${remaining[@]]}"
fi
if ((VERBOSE > 1)); then
 printf 'Downloading %s:%s\n' "$LANG" "$ARTICLE"
fi
if ! $ARTICLE ; then
 printf '%s\n' "No articles!">&2
 exit 1
fi
save_webpage "https://${LANG}.wikipedia.org/wiki/${ARTICLE}"
Using old getopt.
The old getopt does not support optional arguments:
args=`getopt 'a:l:v' $*` || exit
set -- $args
while true; do
 case $1 in
 (-v) ((VERBOSE++)); shift;;
 (-a) ARTICLE=$2; shift 2;;
 (-l) LANG=$2; shift 2;;
 (--) shift; break;;
 (*) exit 1;; # error
 esac
done
remaining=("$@")
This script will also break with any article title with a space or a shell metacharacter (like ? or *) in it.
Using getopts.
Getopts give the script the look and feel of the C interface, although in POSIX optional arguments are still absent:
while getopts ':a:l:v' opt; do
 case $opt in
 (v) ((VERBOSE++));;
 (a) ARTICLE=$OPTARG;;
 (l) LANG=$OPTARG;;
 (:) # "optional arguments" (missing option-argument handling)
 case $OPTARG in
 (a) exit 1;; # error, according to our syntax
 (l) :;; # acceptable but does nothing
 esac;;
 esac
done
shift "$OPTIND"
Since we are no longer operating on shell options directly, we no longer need to shift them. However, a slicing operating is required to get the remaining arguments now.
It is possible, but tedious to emulate long argument support by treating as an argument to an option .
Using Linux getopt.
Linux getopt escapes its output and an "eval" command is needed to have the shell interpret it. The rest is unchanged:
ARGS=$(getopt -o 'a:l::v' --long 'article:,language::,lang::,verbose' -- "$@") || exit
eval "set -- $ARGS"
while true; do
 case $1 in
 (-v|--verbose)
 ((VERBOSE++)); shift;;
 (-a|--article)
 ARTICLE=$2; shift 2;;
 (-l|--lang|--language)
 # handle optional: getopt normalizes it into an empty string
 if [ -n "$2" ]; then
 LANG=$2; shift;
 fi
 shift;;
 (--) shift; break;;
 (*) exit 1;; # error
 esac
done
remaining=("$@")