Parsing Command Line Arguments in Bash

Parsing command line arguments is a crucial aspect of writing robust and flexible shell scripts. In this tutorial, we will explore how to parse command line arguments in Bash, covering various methods and best practices.

Introduction to Command Line Arguments

Command line arguments are the inputs passed to a script when it is executed from the terminal. These arguments can be options (flags) or positional parameters (data). Options typically start with a hyphen (-) and are used to modify the behavior of the script, while positional parameters are the actual data being processed.

Method 1: Using Case Statement

One common way to parse command line arguments in Bash is by using a case statement within a while loop. The basic structure of this approach involves iterating through each argument ($1, $2, …) and checking its value against predefined options.

while [[ $# -gt 0 ]]; do
  case $1 in
    -v|--verbose)
      VERBOSE=true
      shift # past argument
      ;;
    -f|--file)
      FILE=$2
      shift # past argument
      shift # past value
      ;;
    --help)
      echo "Usage: script.sh [-v] [-f file]"
      exit 0
      ;;
    *)
      echo "Unknown option $1"
      exit 1
      ;;
  esac
done

Method 2: Using getopts

The getopts command is a built-in Bash utility that simplifies the process of parsing options. It automatically handles the shifting of arguments and provides an easy way to define valid options.

while getopts ":hvf:" opt; do
  case $opt in
    h) 
      echo "Usage: script.sh [-h] [-v] [-f file]"
      exit 0
      ;;
    v) 
      VERBOSE=true
      ;;
    f) 
      FILE=$OPTARG
      ;;
    \?) 
      echo "Invalid option -$OPTARG"
      exit 1
      ;;
  esac
done

Method 3: Using getopt (External Command)

For more complex scenarios or when you need to support long options, the external getopt command can be used. However, it’s essential to note that getopt has limitations in older versions and may not handle certain edge cases as expected.

getopt -o hvf: -- "$@"

Best Practices

When parsing command line arguments, keep the following best practices in mind:

• Use meaningful option names.
• Support both short (-) and long (– ) options for better usability.
• Provide clear usage messages or help texts.
• Validate user inputs to prevent unexpected behavior.

By mastering these methods and adhering to best practices, you can write more robust and user-friendly shell scripts that effectively handle command line arguments.

Example Use Case

Consider a script named backup.sh that takes options for verbose mode (-v), specifying a file to backup (-f), and an output directory (-o).

#!/bin/bash

VERBOSE=false
FILE=""
OUTPUT_DIR=""

while getopts ":hvf:o:" opt; do
  case $opt in
    h) 
      echo "Usage: backup.sh [-h] [-v] [-f file] [-o output_dir]"
      exit 0
      ;;
    v) 
      VERBOSE=true
      ;;
    f) 
      FILE=$OPTARG
      ;;
    o) 
      OUTPUT_DIR=$OPTARG
      ;;
    \?) 
      echo "Invalid option -$OPTARG"
      exit 1
      ;;
  esac
done

# Backup logic here
if [ "$VERBOSE" = true ]; then
  echo "Backing up $FILE to $OUTPUT_DIR"
fi

This example demonstrates how to parse command line arguments in a real-world scenario, making your scripts more flexible and easier to use.