Robust scripts

#!/usr/bin/env bash is the correct shebang for portable bash scripts. It asks the OS to run whichever bash appears first in $PATH, rather than hardcoding /bin/bash (which does not exist on some systems, notably NixOS and some containers).

#!/usr/bin/env bash
# Always the first line — no blank lines above it

/bin/sh invokes the system POSIX shell, which may be dash, ash, or busybox — not bash. If your script uses [[ ]], arrays, or any bash-specific feature, it must use #!/usr/bin/env bash. Running a bash script under sh produces cryptic parse errors for constructs that are valid bash but not POSIX sh.

set -e exits the script immediately if any command returns a non-zero exit code. Without it, every failed command is silently ignored and execution continues.

set -e
cp /nonexistent /tmp/   # exits here — cp fails
echo "This never runs"  # skipped

set -u treats any reference to an unset variable as an error and exits.

set -u
echo "$UNDEFINED_VAR"   # exits: bash: UNDEFINED_VAR: unbound variable

This catches the typo-variable bug: $TEMP_DIR vs $TMPDIR — one is set, one is not, and without -u the unset one silently expands to an empty string, causing rm -rf "" or cd "" to do something unexpected.

set -o pipefail makes a pipeline fail if any stage fails, not just the last one.

set -o pipefail
grep "pattern" missing_file.txt | wc -l
# Without pipefail: exits 0 (wc succeeded)
# With pipefail:    exits non-zero (grep failed)

Put all three together at the top of every script:

set -euo pipefail

trap 'cleanup_cmd' SIGNAL registers a command to run when the script receives a signal or exits. The most useful signal is EXIT — it fires on any exit, including errors.

#!/usr/bin/env bash
set -euo pipefail

TMPDIR=$(mktemp -d)
trap 'rm -rf "$TMPDIR"' EXIT   # always cleaned up, even on error

# ... script body uses $TMPDIR ...
cp important_data.txt "$TMPDIR/"
process "$TMPDIR/important_data.txt"

Without the trap, a failure midway through leaves $TMPDIR on disk. With it, bash runs rm -rf "$TMPDIR" before the process exits regardless of how it exits — normal completion, exit 1, or an uncaught error.

Multiple signals: trap 'cleanup' EXIT INT TERM also handles Ctrl-C (INT) and kill (TERM).

Functions encapsulate reusable logic. local prevents variables from leaking into the caller’s scope.

#!/usr/bin/env bash
set -euo pipefail

log() {
  local level="$1"
  local msg="$2"
  echo "[$(date +%T)] [$level] $msg" >&2
}

backup_file() {
  local src="$1"
  local dest="${src}.bak.$(date +%s)"
  cp "$src" "$dest"
  log INFO "Backed up $src to $dest"
}

backup_file /etc/nginx/nginx.conf

Without local, level, msg, src, dest are global variables. If a calling function also uses a variable named dest, the inner function overwrites it. local scopes the variable to the function’s stack frame. This is not optional style — it prevents action-at-a-distance bugs in scripts longer than a few functions.

Functions return exit codes like commands do. return 0 is success; return N is failure. The last command’s exit code is the function’s exit code if you don’t call return explicitly.

Three common set -e gotchas that trip up experienced engineers.

Gotcha 1: commands in if conditions are exempt. set -e does not fire when a command is used directly as a condition.

set -e
if grep -q "pattern" file.txt; then echo "found"; fi  # grep exit 1 = not found, no abort
grep -q "pattern" file.txt   # this WILL abort on exit 1

Gotcha 2: the last command in a pipeline determines pipefail. With pipefail, the pipeline’s exit code is the rightmost non-zero exit code. If multiple stages fail, only the last non-zero is reported.

Gotcha 3: local itself is a command with an exit code. This is a subtle trap:

set -e
get_value() {
  local val=$(some_command_that_fails)  # WRONG: local returns 0 even if $() fails
  local val
  val=$(some_command_that_fails)        # CORRECT: assignment separate from declaration
}

local val=$(cmd) evaluates cmd, assigns to val, then local runs and returns 0 regardless — swallowing the failure. Declare local first, then assign on a separate line.