#!/bin/bash

# $? holds the exit code of the LAST command
ls /etc/hosts
echo "$?"    # 0 (file exists, command succeeded)

ls /nonexistent
echo "$?"    # 2 (ls failed — file not found)

# Check immediately — $? changes after EVERY command
grep "root" /etc/passwd
status=$?    # save $? before it gets overwritten
echo "grep exited with: $status"

# Typical pattern: check and act
if ! cp source.txt dest.txt; then
    echo "Copy failed with exit code $?" >&2
    exit 1
fi

#!/bin/bash

# exit 0: success
# exit 1: general error (most scripts use 1 for all failures)
# exit 2+: meaningful codes for callers to distinguish errors

INPUT="$1"

[[ -z "$INPUT" ]] && { echo "Usage: $0 " >&2; exit 1; }
[[ -f "$INPUT" ]] || { echo "File not found: $INPUT" >&2; exit 2; }
[[ -r "$INPUT" ]] || { echo "Permission denied: $INPUT" >&2; exit 3; }

# Process the file...
echo "Processing $INPUT"
exit 0   # explicit success (optional — script exits 0 if last command succeeded)</code></pre>
</div>

4. set -e, set -u, set -o pipefail

The "strict mode" trio for production scripts:



bash
Copy

#!/bin/bash
set -euo pipefail
# -e: exit immediately if any command fails (non-zero exit)
# -u: treat unset variables as errors
# -o pipefail: pipeline fails if ANY command in it fails (not just the last)

# Without pipefail, this hides the grep failure:
# grep "ERROR" /nonexistent/file | wc -l   → prints 0 and exits 0 (wrong!)
# With pipefail, the script correctly exits non-zero

# -e gotcha: use || true to allow expected failures
rm -f optional-file.txt || true   # won't abort script if file doesn't exist
grep "pattern" file.txt || true   # grep exit 1 if no match — OK here

# -u gotcha: check variable is set before using it
filename="${1:-}"  # use default empty string instead of failing
[[ -n "$filename" ]] || { echo "Filename required" >&2; exit 1; }


5. trap for Cleanup on Exit


#!/bin/bash
set -euo pipefail

TMPDIR=$(mktemp -d)

# cleanup() runs no matter how the script exits (success, error, or Ctrl+C)
cleanup() {
    echo "Cleaning up temporary files..." >&2
    rm -rf "$TMPDIR"
}
trap cleanup EXIT   # EXIT fires on any exit

# SIGINT (Ctrl+C) and SIGTERM handlers
trap 'echo "Interrupted" >&2; exit 130' INT
trap 'echo "Terminated" >&2; exit 143' TERM

# Script body — TMPDIR will be cleaned up regardless
echo "Working in $TMPDIR"
cp /etc/hosts "$TMPDIR/hosts.bak"
# ... do work ...
echo "Done"


6. Complete Error Handling Pattern


#!/bin/bash
set -euo pipefail

# Centralized error handler
error_exit() {
    echo "[ERROR] Line ${2:-unknown}: ${1}" >&2
    exit "${3:-1}"
}
trap 'error_exit "Unexpected failure" $LINENO' ERR

# Cleanup handler
TMPFILE=""
cleanup() { [[ -n "$TMPFILE" ]] && rm -f "$TMPFILE"; }
trap cleanup EXIT

# Input validation
[[ $# -lt 1 ]] && error_exit "Usage: $0 " $LINENO 1
INPUT="$1"
[[ -f "$INPUT" ]] || error_exit "File not found: $INPUT" $LINENO 2

TMPFILE=$(mktemp)
process_data() {
    cp "$INPUT" "$TMPFILE"
    # ... processing ...
    echo "Processed: $TMPFILE"
}

process_data
echo "Script completed successfully"
exit 0</code></pre>
</div>

Exit codes work hand-in-hand with bash functions where functions signal success or failure via return codes. For checking file conditions that might cause non-zero exits, see the bash check if file exists guide.

Summary

$? holds the last exit code. 0 is success, 1 is general error, 127 is command not found. Always use set -euo pipefail in production scripts to catch failures early. Use trap cleanup EXIT to ensure cleanup runs regardless of how the script exits. Define meaningful exit codes (2, 3, etc.) so callers can distinguish failure types.