Bash Getopts – Parsing Options After a Non-Option Argument

bashgetoptsshell-script

I have a bash script as below in a file nepleaks_upd.sh, that I want to run as ./nepleaks_upd.sh bootstrap --branch off. Couldn't make it to take --branch , but what it works with is ./nepleaks_upd.sh bootstrap -b off.

usage() { echo "Usage: $0 [prepare | up | down]  [-b <on/off>]" 1>&2; exit 1; }                                                                                                 

case "$1" in                                                                                           
               bootstrap)                                                                                  
                  while getopts ":b:" o; do                                                            
                   case "${o}" in                                                                      
                    b)                                                                                 
                        b=${OPTARG}                                                                    
                        if [ ${b} == "off" ]; then                                                      
                               echo "git clone https://github.com/iPrayag/dotfiles.git"  
                               ## logic                                                      
                        fi                                                                             
                        ;;                                                                             
                    *)                                                                                 
                        echo ${o}                                                                      
                        usage                                                                          
                        ;;                                                                             
                   esac                                                                                
                  done                                                                                 
                  shift $((OPTIND-1))                                                                  
                  echo "option1 = ${o}" 
                  echo "option2 = ${b}"                                                                      
                  if [ -z "${b}" ]; then                                                               
                         usage                                                                         
                  fi                                                                                   

                    ;;                                                                                 
                up)                                                                                         
                     echo "up"     
                     ##logic                                                                    
                     ;;                                                                                
                down)                                                                                  
                     echo "down" 
                     ##logic                                                                     
                    ;;                                                                                 
                *)                                                                                     
                    echo "Usage: $0 {up | down} dev"                                                
                    exit 1                                                                             
                    ;;                                                                                 
esac

Without first case .. in .... esac, it works fine. With case ... in ... esac, it gives blank option for -b,

$ ./nepleaks_upd.sh bootstrap -b off
option1 = ?
option2 = 
Usage: ./nepleaks_upd.sh [bootstrap | up | down]  [-b <on/off>]

Best Answer

getopts starts parsing at the first argument and stops at the first non-option arguments. That's the standard convention — some GNU utilities accept options after arguments, but the normal thing is that in somecommand foo -bar qux, -bar is not parsed as an option.

If you want to start parsing options after bootstrap, you need to indicate that. getopts uses the OPTIND variable to remember what position it's at. OPTIND starts out with the value 1. To skip the first argument, set it to 2.

case "$1" in
   bootstrap)
      OPTIND=2
      while getopts ":b:" o; do
          …

Alternatively, you could shift the arguments that you've already processed.

subcommand=$1; shift
case "$subcommand" in
    bootstrap)
      while getopts ":b:" o; do
          …

Put quotes around multiple arguments

In this case getopts will treat them as one argument, but you will be able to split it later on. You can even put all arguments in the array at once:

#!/bin/bash  

while getopts ":hr:l:" opt; do
    case $opt in
        r ) echo "Run Numbers - argument = $OPTARG "
            set -f # disable glob
            IFS=' ' # split on space characters
            array=($OPTARG) ;; # use the split+glob operator
        l ) echo "Latency range - argument = $OPTARG" ;;
        h ) helptext
            graceful_exit ;;
        * ) usage
            clean_up
            exit 1
    esac
done

echo "Number of arguments: ${#array[@]}"
echo -n "Arguments are:"
for i in "${array[@]}"; do
  echo -n " ${i},"
done
printf "\b \n"

The example of run:

./script -r "123 456 789"

And output:

Run Numbers - argument = 123 456 789 
Number of arguments: 3
Arguments are: 123, 456, 789

Use comma (or other preferred character) as a delimiter
```
./script -r 123,456,789
```
and you just replace IFS=" " with IFS=, in the code above. That one has the advantage of allowing empty elements. As pointed out in the comments section this solution is chosen by some common programs e.g. lsblk -o NAME,FSTYPE,SIZE.
Allow multiple -r options

Multiple -r, but each taking only one argument:
```
./script -r 123 -r 456 -r 789
```
Then arguments would be added to array one by one
```
array+=("$OPTARG")
```
That one has the advantage of not having limitations on what characters the elements may contain. This one is also used by some standard linux tools e.g. awk -v var1=x -v var2=y.

Shell – Execute default option when no options are specified in getopts

Adding a default option to the case statement won't help because it won't be executed if getopts doesn't have options to parse. You can see how many options it processed with the OPTIND shell variable. From help getopts:

Each time it is invoked, getopts will place the next option in the
shell variable $name, initializing name if it does not exist, and
the index of the next argument to be processed into the shell
variable OPTIND.  OPTIND is initialized to 1 each time the shell or
a shell script is invoked.

So if OPTIND is 1, no options were processed. Add this after your while loop:

if (( $OPTIND == 1 )); then
   echo "Default option"
fi

Best Answer

Related Solutions

Shell Script Options Array Getopts – Provide Two Arguments to One Option Using Getopts

Put quotes around multiple arguments

Use comma (or other preferred character) as a delimiter

Allow multiple -r options

Shell – Execute default option when no options are specified in getopts

Related Question

Allow multiple `-r` options