Mastering Bash Script Options with Getopts

Are you tired of writing bash scripts that are difficult to customize and reuse? If so, it’s time to discover the magic of options with getopts!

What is Getopts?

Getopts is a built-in bash command that allows you to parse command line options and arguments passed to a script. It takes the form of a loop that reads each option and argument and sets variables accordingly. This makes it easy to create flexible scripts that can be customized by the user.

How to Use Getopts

Using getopts is simple. Just follow these steps:

1. Define a string of valid options for your script. For example, if you want to allow the user to specify a file name and verbose output, you might define the options as “f:v”. The colon after the “f” option indicates that it requires an argument (i.e. the file name).
2. Initialize a variable to hold the current option. This is typically done using the OPTIND variable.
3. Use a while loop to read each option and argument. Inside the loop, use the getopts command to parse the options. The getopts command takes two arguments: the string of valid options, and the name of the variable to hold the current option.
4. Use a case statement to handle each option. The case statement should check the value of the variable holding the current option and execute the appropriate code for that option.

Here’s an example script that demonstrates how to use getopts:

# Define valid options
options=":f:v"

# Initialize option variable
OPTIND=1

# Parse options
while getopts $options opt; do
  case $opt in
    f)
      file=$OPTARG
      ;;
    v)
      verbose=1
      ;;
    \\?)
      echo "Invalid option: -$OPTARG" >&2
      exit 1
      ;;
    :)
      echo "Option -$OPTARG requires an argument." >&2
      exit 1
      ;;
  esac
done

# Shift parsed options
shift $((OPTIND-1))

# Do something with the options
if [ "$verbose" = 1 ]; then
  echo "Verbose mode enabled."
fi

if [ -n "$file" ]; then
  echo "Processing file: $file"
else
  echo "No file specified."
fi

If we run this script with the -f option and a file name, we should see the following output:

$ ./myscript -f itvraag.nl
Processing file: itvraag.nl

And if we add the -v option for verbose output, we should see the following:

$ ./myscript -f itvraag.nl -v
Verbose mode enabled.
Processing file: itvraag.nl

Key Take-aways

• Getopts is a built-in bash command for parsing command line options and arguments in scripts
• Getopts requires you to define a string of valid options and initialize a variable to hold the current option
• Getopts is used in a while loop with the getopts command to parse options
• A case statement is used to handle each option
• Getopts can be used to create flexible and customizable bash scripts

Examples and Tips for Increased Productivity

1. Use short and long options for added flexibility. For example, allow the user to specify the f or -file option for specifying a file name.
2. Use the : character to indicate required arguments for options. This will ensure that the user provides the necessary information for your script to run correctly.
3. Use the \\? and : cases in the case statement to handle invalid options and missing arguments. This will make your script more user-friendly and prevent errors.
4. Use the shift command to remove parsed options from the command line arguments. This will make it easier to process the remaining arguments.
5. Use the $OPTIND variable to keep track of the current option index. This can be useful if you want to process multiple options in a specific order.

Additional Resources

For more information on getopts, you can check out the bash man page with the command man bash. You can also check out the getopts built-in command with help getopts.

Challenge

Try creating a bash script that uses getopts to allow the user to specify a file name, a verbose output flag, and a number of iterations. Use the case statement to handle each option and output the results.