Using Getopts to Parse Command-Line Arguments in Bash

Getopts is a built-in command in Bash that allows you to parse command-line arguments and options. It provides a simple way to handle various command-line inputs, such as flags, options with values, and positional parameters.

Introduction to Getopts

The basic syntax of getopts is:

getopts OPTSTRING VARNAME [ARGS...]

Here:

• OPTSTRING is a string containing the list of expected arguments.
• VARNAME is the variable that will be set to the current option character.
• [ARGS...] are the command-line arguments.

Understanding OPTSTRING

The OPTSTRING parameter is crucial in defining how getopts behaves. It consists of characters, each representing an option or a flag. If an option requires an argument, it should be followed by a colon (:).

For example:

getopts ":hs:p:" arg

In this case:

• h represents the -h flag (no argument expected).
• s: represents the -s option (requires an argument).
• p: represents the -p option (requires an argument).

Parsing Options and Arguments

To parse options and arguments, you can use a while loop with getopts:

while getopts ":hs:p:" arg; do
  case $arg in
    h)
      # Display help message
      ;;
    s)
      strength=$OPTARG
      # Process the -s option value
      ;;
    p)
      param=$OPTARG
      # Process the -p option value
      ;;
    \?)
      # Handle unknown options
      ;;
  esac
done

Here:

• arg is the variable that will be set to the current option character.
• $OPTARG contains the argument value for the current option (if any).
• The case statement allows you to handle each option and its associated logic.

Example Usage

Let’s create a script that uses getopts to parse command-line arguments:

#!/bin/bash

usage() {
  echo "Usage: $0 [-s <45|90>] [-p <string>]"
  exit 1
}

while getopts ":hs:p:" arg; do
  case $arg in
    h)
      usage
      ;;
    s)
      strength=$OPTARG
      if [ $strength -ne 45 ] && [ $strength -ne 90 ]; then
        echo "Invalid strength value: $strength"
        exit 1
      fi
      ;;
    p)
      param=$OPTARG
      ;;
    \?)
      usage
      ;;
  esac
done

# Check if required options are present
if [ -z "$strength" ] || [ -z "$param" ]; then
  usage
fi

echo "Strength: $strength"
echo "Param: $param"

You can save this script to a file (e.g., myscript.sh) and run it with various command-line arguments:

$ ./myscript.sh -s 45 -p foo
Strength: 45
Param: foo

$ ./myscript.sh -h
Usage: ./myscript.sh [-s <45|90>] [-p <string>]

$ ./myscript.sh -s 10 -p bar
Invalid strength value: 10

Best Practices and Tips

• Always define a usage function to display help messages.
• Use meaningful variable names for options and arguments.
• Handle unknown options using the \? case statement.
• Check for required options and arguments after parsing.
• Keep your getopts loop organized with clear logic and comments.

By following these guidelines and examples, you can effectively use getopts to parse command-line arguments in Bash and create robust, user-friendly scripts.