What does set -euo pipefail actually do?

-e exits the script immediately if any command fails (returns nonzero) instead of continuing past the error; -u treats referencing an undefined variable as an error instead of silently substituting an empty string; -o pipefail makes a pipeline's exit status the last nonzero exit among its stages instead of just the last command's, so a failure earlier in a pipe (e.g. `cat missing-file | grep x`) isn't masked by a later command succeeding.

Why trap both EXIT and ERR?

The EXIT trap runs cleanup no matter how the script ends, success, an explicit exit, or a signal, making it the right place for guaranteed cleanup like removing a temp directory. The ERR trap fires specifically when a command fails under set -e, and this generator uses it to log the failing line number before the script exits, which the EXIT trap alone wouldn't tell you.

How does the generated getopts loop work?

Each flag you define becomes a case in a `while getopts ":h " opt` loop; a flag configured to take an argument gets a trailing colon in the optstring and its value is captured from $OPTARG, while a flag with no argument just sets its variable to 1. -h is always reserved and wired to print usage and exit cleanly.

What's still left for me to fill in?

The generated script handles shebang, strict-mode flags, error/cleanup trapping, logging, and argument parsing, everything before you'd normally start writing the script's actual purpose. You fill in the cleanup() body if you have real resources to release, and replace the '# Main script logic goes here' comment with your actual commands.

Bash Script Skeleton Generator - set -euo pipefail, traps, getopts

Overview

Introduction

Most Bash scripts start the same way: a shebang, some strict-mode flags to catch mistakes early, a logging helper, and argument parsing, but it's easy to skip one of these under time pressure and end up with a script that fails silently instead of loudly.

This tool generates that boilerplate, including a getopts loop built from the exact flags your script needs, so the actual script logic is the only thing left to write.

What Is Bash Script Generator?

A Bash script skeleton generator producing a shebang line, `set -euo pipefail`, an EXIT trap wired to a cleanup() function, an ERR trap that logs the failing line number, a timestamped log() helper, and a getopts argument-parsing loop.

You define your script's custom flags (a letter, whether it takes a value, a description, and the shell variable it sets), and the generator builds the getopts optstring, the usage text, and the case statement for you.

How Bash Script Generator Works

Flags that take a value get a trailing `:` in the getopts optstring and populate their variable from $OPTARG; flags with no value set their variable to 1 when passed. -h is always added automatically and prints the generated usage() text before exiting 0.

The ERR trap fires whenever a command fails under `set -e`, logging the line number via $LINENO before the script exits; the EXIT trap always runs afterward (or on a clean exit) and is where any actual cleanup (removing a temp file, releasing a lock) belongs.

When To Use Bash Script Generator

Use it any time you're starting a new operational script (a deploy step, a backup, a data migration) that takes command-line flags and should fail loudly and cleanly rather than silently continuing past an error.

It's also a fast way to remind yourself of the exact getopts syntax, easy to get subtly wrong (the leading colon, the $OPTARG variable, the fall-through \? and : cases) if you don't write it often.

Often used alongside POSIX Shell Script Generator, systemd Service Generator and Crontab Generator.

Features

Advantages

Bakes in strict-mode flags and error trapping by default, so a script this generator produces fails fast instead of silently continuing after an error.
Builds a correct getopts loop from a simple flag list, avoiding the easy-to-mistype optstring and case-statement syntax.
Includes a ready-made timestamped logging function so output isn't just bare echo statements.

Limitations

getopts only supports single-character flags (no --long-options), for long-flag parsing you'd need a manual while/case loop over $@ instead.
The generated cleanup() function is a stub, it doesn't know what resources your script will actually create, so you still need to fill in what should be cleaned up.
set -u means every variable must be defined before use, including in edge cases like an empty array expansion on older Bash versions, worth testing on your actual target Bash version.

Examples

A deploy script with a verbose flag and a required environment flag

Input

scriptName: deploy.sh, purpose: Deploys the app to the target environment, flags: [{flag: v, hasArg: false, varName: VERBOSE, description: Enable verbose output}, {flag: e, hasArg: true, varName: ENVIRONMENT, description: Target environment name}]

Output

#!/usr/bin/env bash
#
# deploy.sh - Deploys the app to the target environment
#
set -euo pipefail

SCRIPT_NAME="$(basename "$0")"

log() {
  printf '[%s] %s\n' "$(date '+%Y-%m-%dT%H:%M:%S%z')" "$*" >&2
}

cleanup() {
  local exit_code=$?
  # Add cleanup logic here (e.g. remove temp files, release locks)
  exit "$exit_code"
}

trap cleanup EXIT
trap 'log "Error on line $LINENO"; exit 1' ERR

usage() {
  cat <<EOF
Usage: $SCRIPT_NAME [-h] [-v] [-e value]

  -h          Show this help message
  -v          Enable verbose output
  -e value    Target environment name
EOF
}

VERBOSE=0
ENVIRONMENT=""

while getopts ":hve:" opt; do
  case "$opt" in
    h) usage; exit 0 ;;
    v) VERBOSE=1 ;;
    e) ENVIRONMENT="$OPTARG" ;;
    \?) log "Unknown option: -$OPTARG"; usage; exit 1 ;;
    :) log "Option -$OPTARG requires an argument"; usage; exit 1 ;;
  esac
done
shift $((OPTIND - 1))

log "Starting $SCRIPT_NAME"

# Main script logic goes here

log "Done"

-v sets VERBOSE=1 with no argument, while -e captures its value into ENVIRONMENT via $OPTARG.

Best Practices & Notes

Best Practices

Always fill in cleanup() with anything the script actually creates (temp files, background processes, locks), the trap only helps if it does real work.
Keep flag letters mnemonic (e.g. -e for environment, -v for verbose) so `usage` reads naturally without needing to consult the script source.
Quote all variable expansions ($VAR, not $VAR bare) throughout the logic you add, set -u catches undefined variables but not unintended word-splitting from unquoted expansions.

Developer Notes

The getopts optstring is built as `h` followed by each user-defined flag letter (with a trailing `:` for flags that take a value); -h is never user-configurable and always exits 0 after printing usage, matching the conventional exit-code meaning of a successful help invocation versus an error path. The ERR trap specifically references $LINENO rather than a static message, since knowing which line failed is usually the single most useful piece of debugging information when a strict-mode script aborts.

Bash Script Generator Use Cases

Starting a new deployment, backup, or data-migration script with proper error handling from the first line
Building a small CLI utility that takes a handful of single-letter flags
Standardizing a team's script boilerplate (logging format, trap behavior) across many operational scripts

Common Mistakes

Forgetting `shift $((OPTIND - 1))` after the getopts loop, which leaves already-parsed option arguments in the positional parameters ($1, $2, ...) instead of shifting them out.
Writing to global variables inside cleanup() that depend on script state that may not exist yet if the script fails very early, guard cleanup logic for that case.
Using $* instead of $@ when forwarding arguments elsewhere in the script, $* joins arguments into a single word and loses individual argument boundaries.

Tips

If your script needs to run on a system where /bin/sh isn't Bash (some minimal containers, BusyBox-based images), use the POSIX Shell Script Generator instead, since getopts and this skeleton's array-free logic aren't universally identical across shells but the POSIX tool targets that portability explicitly.
Pair with the systemd Service Generator's ExecStart if this script becomes a long-running or recurring service rather than a one-off.

Bash Script Generator