Skip to content
An "upgrade" to BASH built-in getopts, with support for GNU-style long option.
Shell Dockerfile HCL
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.

getopts_long logo

stable branch latest release test coverage donate link


This is a pure BASH implementation of getopts_long function, which "upgrades" the built-in getopts with support for GNU-style long options, such as:

  • --option
  • --option value
  • --option=value

This function is 100% compatible with the built-in getopts. It is implemented with no external dependencies, and relies solely on BASH built-in tools to provide all of its functionality.

Table of Content


The function is distributed via a single self-contained file:


There are a number of ways to make it available to your script, all of them come with their own advantages and disadvantages. Consider carefully all of the following and pick the method of installation that suits your needs best.

Source the library

This is the recommended way of providing getopts_long functionality to your script. To use it, clone this repository somewhere on your system:

git clone

Then update your script to source the function code:

. "__PATH_TO__/getopts_long/lib/getopts_long.bash"

This method allows you to receive any future updates and all fixes to the function by simply running git pull within the repository. However, if you customise the function for your own needs, you might end up having to fix git merge conflicts in the future.

Paste the content

An alternative method of installation is to simply copy-n-paste the content of lib/getopts_long.bash into your script.

This will make the function available to a single script and you will easily be able to customise it for your own needs. However, you will need to keep an eye on this repository and manually upgrade the function whenever an update is released.

Run in docker

A more advanced way to run your script with getopts_long is to mount its directory into the getopts_long docker container:

docker container run --rm --init -it -v ${YOUR_SCRIPT_DIR}:/mnt umkadk/getopts_long -l

Your script will be available in /mnt directory, and getopts_long function can be sourced from /home/lib/getopts_long.bash.


The syntax for getopts_long is the same as the syntax for the built-in getopts:

getopts_long OPTSPEC VARNAME [ARGS...]


Name Description
OPTSPEC An extended list of expected options and their arguments.
VARNAME A shell-variable to use for option reporting.
ARGS An optional list of arguments to parse. If omitted, then getopts_long will parse arguments supplied to the script.

Extended OPTSPEC

An OPTSPEC string tells getopts_long which options to expect and which of them must have an argument. The syntax is very simple:

  • single-character options are named first (identical to the built-in getopts);
  • long options follow the single-character options, they are named as is and are separated from each other and the single-character options by a space.

Just like with the original getopts, when you want getopts_long to expect an argument for an option, just place a : (colon) after the option.

For example, given 'af: all file:' as the OPTSPEC string, getopts_long will recognise the following options:

  • -a - a single character (short) option with no argument;
  • -f ARG - a single character (short) option with an argument;
  • --all - a multi-character (long) option with no argument;
  • --file ARG - a multi-character (long) option with an argument.

If the very first character of the optspec-string is a : (colon), which would normally be nonsense because there's no option letter preceding it, getopts_long switches to "silent error reporting mode" (See Error Reporting for more info).

In production scripts, "silent mode" is usually what you want because it allows you to handle errors yourself without being distracted by default error messages. It's also easier to handle, since the failure cases are indicated by assigning distinct characters to VARNAME.

Example script

A good example is worth a thousand words, so here is an example of how you could use the function within a script:

#!/usr/bin/env bash
source "${PATH_TO_REPO}/lib/getopts_long.bash"

while getopts_long ':af: all file:' OPTKEY; do
    case ${OPTKEY} in
            echo 'all triggered'
            echo "file supplied -- ${OPTARG}"
            echo "INVALID OPTION -- ${OPTARG}" >&2
            exit 1
            echo "MISSING ARGUMENT for option -- ${OPTARG}" >&2
            exit 1
            echo "UNIMPLEMENTED OPTION -- ${OPTKEY}" >&2
            exit 1

shift $(( OPTIND - 1 ))
[[ "${1}" == "--" ]] && shift


How it works

In general the use of getopts_long is identical to that of the built-in getopts. Just like the built-in function, you need to call getopts_long several times. Each time it will use the next positional parameter and a possible argument, if parsable, and provide it to you. The function will not change the set of positional parameters. If you want to shift them, it must be done manually:

shift $(( OPTIND - 1 ))
# now do something with $@

Just like getopts, getopts_long sets an exit status to FALSE when there's nothing left to parse. Thus, it's easy to use in a while-loop:

while getopts ...; do

Identical to getopts, getopts_long will parse options and their possible arguments. It will stop parsing on the first non-option argument (a string that doesn't begin with a hyphen (-) that isn't an argument for any option in front of it). It will also stop parsing when it sees the -- (double-hyphen), which means end of options.

Internal variables

Like the original getopts, getopts_long sets the following variables:

Variable Description
OPTIND Holds the index to the next argument to be processed. This is how the function "remembers" its own status between invocations. OPTIND is initially set to 1, and needs to be re-set to 1 if you want to parse anything again with getopts.
OPTARG This variable is set to any argument for an option found by getopts_long. It also contains the option flag of an unknown option.
OPTERR (Values 0 or 1) Indicates if Bash should display error messages generated by getopts_long. The value is initialised to 1 on every shell startup - so be sure to always set it to 0 if you don't want to see annoying messages!

OPTERR is not specified by POSIX for the getopts built-in utility — only for the C getopt() function in unistd.h (opterr). OPTERR is bash-specific and not supported by shells such as ksh93, mksh, zsh, or dash.

Error reporting

Regarding error-reporting, there are two modes getopts_long can run in:

  • verbose mode
  • silent mode

In production scripts I recommend using the silent mode, because it allows you to handle errors yourself without being distracted by default error messages. It's also easier to handle, since the failure cases are indicated by assigning distinct characters to VARNAME.

Verbose mode

Error type What happens
invalid option VARNAME is set to ? (question-mark) and OPTARG is unset.
required argument not found VARNAME is set to ? (question-mark), OPTARG is unset and an error message is printed.

Silent mode

Error type What happens
invalid option VARNAME is set to ? (question-mark) and OPTARG is set to the (invalid) option character.
required argument not found VARNAME is set to : (colon) and OPTARG contains the option in question.


Even though I consider this function feature complete, contributions are always welcome. New ideas, bugs, and pull requests, all will be very much appreciated. The only thing I ask is that if you're submitting a PR, please:

  1. Ensure that all existing tests pass;
  2. Add all tests required by your PR.

Test suite

Tests for this function live in the ./test subdirectory of the project root. They are implemented using BATS (unit tests), and Kcov (coverage report), which are provided by the included Dockerfile.

If required, a local docker image can be built using the following command:

docker image build --tag umkadk/getopts_long .

Executing the container with no arguments will run all tests and generate a coverage report in the coverage subdirectory of the projects root:

docker container run --rm --init -it -v ${PWD}:/mnt umkadk/getopts_long
ls -l ./coverage/index.html

Individual tests could be run by passing a relative path of the BATS test file as an argument to docker run command:

docker container run --rm --init -it -v ${PWD}:/mnt umkadk/getopts_long ./test/no_arguments.bats

Container shell

By supplying -l or --login as a parameter to docker run command you can start the container with the login shell.

docker container run --rm --init -it -v ${PWD}:/mnt getopts_long -l

Inside the container, getopts_long source code is available under /home, while your current working directory on the host will be mounted under /mnt. This setup can be used to experiment with your own script which rely on getopts_long functionality.

You can’t perform that action at this time.