Arguments and Functions

Positional parameters

When you run a script with arguments, the shell numbers them ¹:

me@linuxbox:~$ ./tag-photos -v ~/photos "Summer 2026"

By the time your script sees them, the shell has already expanded ~ and wildcards and removed the quotes, which is why "Summer 2026" arrives as one argument ¹.

"$@" is the one to use for passing arguments on, to a loop or another command. It keeps each argument intact, spaces and all; unquoted $@ or $* would split them ^{1 2}:

for f in "$@"; do
    echo "processing $f"
done

shift drops $1 and moves everything down one: $2 becomes $1, and $# goes down by one. It’s how you peel arguments off the front ¹.

Defaults and required arguments

Bash’s parameter expansions handle missing arguments in one line ³:

dir="${1:-.}"                                  # $1, or . if it's missing or empty
name="${2:?usage: greet DIR NAME}"             # stop with this message if $2 is missing

For more than a quick check, write a usage function, print it to stderr, and exit with status 2, the convention for “used wrongly”:

usage() {
    echo "Usage: $(basename "$0") [-v] DIR..." >&2
    exit 2
}
[[ $# -ge 1 ]] || usage

Options with getopts

getopts handles single-letter options like -v and -k 30, in any order and combined like -vk 30 ^{3 2}:

verbose=false
keep=14
while getopts ":vk:" opt; do
    case "$opt" in
        v) verbose=true ;;
        k) keep="$OPTARG" ;;
        *) usage ;;
    esac
done
shift $((OPTIND - 1))     # remove the options; now $1 is the first real argument

The option string ":vk:" lists the letters; a colon after a letter (k:) means it takes a value, delivered in $OPTARG. The leading colon lets your *) branch handle bad options quietly. After the loop, shift $((OPTIND - 1)) discards the options so the remaining arguments start at $1.

Functions

A function is a named block of commands, written before it’s used ^{1 2}:

log() {
    echo "$(date '+%F %T') $*"
}

human_size() {
    local path="$1"
    du -sh -- "$path" | cut -f1
}

log "starting"
size=$(human_size ~/photos)
log "photos take up $size"

Inside a function, $1, $2, and "$@" are the function’s arguments, not the script’s ³.

• local makes a variable belong to the function. Without it, every variable in bash is global, and a function can silently overwrite a variable the rest of the script uses ².
• A function’s exit status is that of its last command, or set it with return 0, return 1. That makes functions usable in if and && ¹.
• To get a value out, have the function print it and capture it with $( ), as with size=$(human_size ...) above.

Arrays

When you need a list whose items may contain spaces, use an array, not a space-separated string ^{1 3}:

sources=("$HOME/Documents" "$HOME/photos" "$HOME/My Projects")
sources+=("$HOME/shell-course")            # add one

echo "${#sources[@]} folders"               # how many: 4
for src in "${sources[@]}"; do               # each item, intact
    echo "will back up: $src"
done
rsync -a "${sources[@]}" /media/me/backup/   # all items as separate arguments

"${array[@]}" works exactly like "$@": each item becomes one word. Arrays are also the clean way to build up a command’s options a piece at a time, as the project in the next lesson does.

Temporary files and cleanup

Scripts often need a scratch file. mktemp creates one with a unique name, so two runs can’t collide. trap runs a command when the script exits, whether it finishes, fails, or is stopped with Ctrl-C ^{4 3}:

tmp=$(mktemp)
trap 'rm -f "$tmp"' EXIT

sort "$1" | uniq -c > "$tmp"
sort -rn "$tmp" | head

The temporary file is removed no matter how the script ends.

The main “$@” layout

Google’s style guide recommends that any script with functions put its top-level code in a function called main, called on the last line with all the arguments ²:

#!/bin/bash
# tidy: one-line description
set -euo pipefail

usage() { ...; }
log()   { ...; }

main() {
    local verbose=false
    # parse options, check arguments, do the work
}

main "$@"

Everything reads top to bottom: settings, helpers, the main logic, and one line that starts it. Variables in main can be local too.

Your turn

So

Arguments arrive as $1, $2, …, counted by $#; pass them on with "$@", peel them off with shift, default them with ${1:-...}, and parse options with getopts. Functions take arguments the same way, keep their variables local, report success with their exit status, and return values by printing. Use arrays for lists, mktemp and trap ... EXIT for temporary files, and main "$@" to organize it all.