There's a great answer here but OP clearly asked for simpler processing of command line options. I think there can not be simpler way of parsing complex shell options than using getopt from util-linux:
$ cat opts.sh
#!/bin/bash
# Print usage and exit
usage() {
exec >&2 # Write everything to STDERR (consistent with getopt errors)
(($#)) && echo "$@"
echo "Usage: $0 [opts...] [args...]"
exit 1
}
# Use getopt to validate options and reorder them. On error print usage
OPTS=$(getopt -s bash -o 'ab:c' -l 'longopt,longopt2,longwitharg:' -- "$@") || usage
# Replace our arguments with the reordered version
eval set -- "$OPTS"
# At this point everything up to "--" is options
declare opt_a opt_c longopt longopt2 longwitharg
declare -a opt_b # Array to accumulate -b arguments
while (($#))
do
case $1 in
-a) opt_a=1;;
-b) opt_b+=("$2"); shift;;
-c) ((++opt_c));;
--longopt) longopt=1;;
--longopt2) ((++longopt2));;
--longwitharg) longwitharg=$2; shift;;
--) shift; break;; # We're done with options, shift over "--" and move on...
*) usage "Unknown argument: $1" # Should not happen unless getopt errors are ignored.
esac
# Always shift once (for options with arguments we already shifted in the case so it's the 2nd shift)
shift
done
echo "Remaining arguments after parsing options: $#"
# Now you can work directly with "$@" or slurp it in an array
args=("$@")
# Here's what we're left with:
declare -p opt_a opt_b opt_c longopt longopt2 longwitharg
# This is how you iterate over an array which may contain spaces and other field separators
for file in "${args[@]}"
do
echo "File arg: $file"
done
getopt will do its validation and return error (unless you tell it not to, then you can catch them yourself). For example:
$ ./opts.sh --badopt
getopt: unrecognized option '--badopt'
Everything else is ordered and quoted properly:
$ ./opts.sh -ab3 -b8 file1 -ccc --longopt --longwitharg=abc --longwitharg "abc def" "file with spaces"
Remaining arguments after parsing options: 2
declare -- opt_a="1"
declare -a opt_b=([0]="3" [1]="8")
declare -- opt_c="3"
declare -- longopt="1"
declare -- longopt2
declare -- longwitharg="abc def"
File arg: file1
File arg: file with spaces
The arguments here:
-a is a flag - set to 1 if present-b and be repeated, each instance is added to the opt_b array-c is a counter, counts the 3 occurrences--longopt is a flag like -a--longopt2 is a counter like -c (not used in this example, so unset; it will still be treated as 0 in Arithmetic Expansion).--longwitharg is a normal option with argument. In this example we override its value later on the command linefile1 and file with spaces are the remaining arguments, and although they're specified at random places they both end up at the end after -- once getopt reorders the command line.
Note that quoting variables is very important to properly handle arguments with spaces, although I've voluntarily avoided quotes where it's not needed such as:
- Direct variable assignment:
longwitharg=$2
- Switch case:
case $1 in
If unsure, extra quotes generally won't hurt.
getopts. I had to accept it's limitations, but it's a POSIX shell standard, so it felt like a worthwhile trade off. I also avoid using shell loops, and agree they are generally inefficient, but I just bit the bullet forgetopts. I still might be able to point you in a solid direction. What are your goals? Efficiency? Portability? Features? Simplicity? Which are your willing to compromise, to achieve the others?