Script Arguments and Options ($@, $#, getopts)

Ever used a command like ls -l or cp file1 file2? The -l, file1, and file2 are all arguments! They tell the command what to do or what to act upon.

In Bash scripting, arguments make your scripts flexible. Instead of hardcoding values, your script can accept input directly from the command line when it's run.

When you run a script with arguments, Bash automatically assigns them to special variables called positional parameters.

• The first argument is $1.
• The second argument is $2.
• And so on, up to $9.

For arguments beyond 9, you'd use curly braces like ${10}, ${11}, etc. These variables hold the values passed to your script.

Let's see how to access these arguments in a script. Save this as greet.sh and run it with ./greet.sh Alice Bob.

Bash provides a few more special variables that give you information about the script itself and its arguments:

• $0: This holds the name of the script being executed. It's useful for error messages or logging.
• $#: This variable contains the total number of positional arguments passed to the script.

These help make your scripts more robust and user-friendly.

Run this script with different numbers of arguments, e.g., ./info.sh one two three or just ./info.sh.

Sometimes you need to refer to all the arguments at once. Bash offers two ways:

• $@: Expands to separate arguments. When double-quoted ("$@"), each argument remains a distinct word, even if it contains spaces. This is usually preferred for loops.
• $*: Expands to a single string of all arguments. When double-quoted ("$*"), all arguments are combined into one single word, separated by the first character of IFS (Internal Field Separator, usually space).

Always use "$@" when iterating through arguments to preserve spaces!

This script demonstrates how "$@" correctly handles arguments with spaces. Run it like: ./loop_args.sh hello "world wide" web

Positional arguments are great for simple cases, but what if your script needs optional flags or named parameters, like -v for verbose or -f filename?

This is where command-line options come in. They make scripts more flexible and user-friendly, allowing users to specify settings in any order.

Bash provides the getopts command specifically for parsing these types of options.

The basic syntax for getopts is: getopts optstring variable.

• optstring: A string of valid option characters. If an option requires an argument (like -f filename), follow the character with a colon (e.g., f:).
• variable: A variable name where getopts will store the currently processed option character (e.g., opt).

getopts also sets OPTARG for option arguments and OPTIND for the next argument index.

This script processes -v (verbose) and -f (file) options. Try running it: ./options.sh -v -f mydata.txt -x or ./options.sh -vf mydata.txt

Consider the following script and how it's executed:

#!/bin/bash
echo "Script: $0"
echo "Count: $#"
for arg in "$@"; do
  echo "Arg: $arg"
done

If you run: ./myscript.sh "Hello World" 123

What would be the output?

Great job! You've learned how to make your Bash scripts much more versatile:

• Positional Arguments: Use $1, $2, etc., to access arguments directly.
• Special Variables: $0 for the script name, $# for the argument count, and "$@" to safely iterate through all arguments.
• Command-line Options: Use getopts to parse named options (like -v) and their arguments (-f filename), making your scripts more robust and user-friendly.

Practice using these in your own scripts to build powerful, flexible command-line tools!