# Bash Strict Mode Best Practices: Writing Safer Shell Scripts > **Enable `set -euo pipefail` at the start of every Bash script to force immediate exits on errors, undefined variables, and pipeline failures, dramatically reducing silent bugs and data corruption risks.** - Repository: [Joshua Levy/the-art-of-command-line](https://github.com/jlevy/the-art-of-command-line) - Tags: - Published: 2026-02-24 --- **Enable `set -euo pipefail` at the start of every Bash script to force immediate exits on errors, undefined variables, and pipeline failures, dramatically reducing silent bugs and data corruption risks.** The `jlevy/the-art-of-command-line` repository defines a battle-tested pattern known as "strict mode" that transforms fragile shell scripts into production-grade tools. This approach combines specific `set` options documented in [`README.md`](https://github.com/jlevy/the-art-of-command-line/blob/main/README.md) to surface errors immediately rather than allowing them to propagate through downstream commands. ## The Essential Strict Mode Trio According to the source code in [`README.md`](https://github.com/jlevy/the-art-of-command-line/blob/main/README.md) (lines 128-130), three specific options form the foundation of Bash strict mode best practices: **`set -e` (or `-o errexit`)** exits the script immediately when any command returns a non-zero status. This prevents the dangerous anti-pattern where a failed command is ignored and subsequent commands execute against an inconsistent or corrupted state. **`set -u` (or `-o nounset`)** treats references to undefined variables as fatal errors. This catches typos in variable names and ensures required environment variables are present before execution proceeds, eliminating subtle bugs caused by empty string expansion. **`set -o pipefail`** returns the exit status of the *first* failing command in a pipeline, rather than only the last command's status. Without this option, a construct like `cmd1 | cmd2` would report success even if `cmd1` failed catastrophically and produced no output. ## Optional Debugging and Error Handling Beyond the core trio, the guide suggests two optional additions for enhanced observability and debugging: **`set -x` (or `-v`)** prints each command and its arguments to `stderr` before execution. Enable this temporarily during troubleshooting to trace exactly which command failed in complex scripts. **`trap ... ERR`** allows custom error handlers that execute whenever a command triggers an exit due to `-e`. As referenced at lines 130-132 in [`README.md`](https://github.com/jlevy/the-art-of-command-line/blob/main/README.md), this centralizes error reporting and provides precise context about where and why the script terminated. ## Practical Implementation Examples The following patterns demonstrate how to apply these Bash strict mode best practices in real-world scenarios. ### Minimal Strict Mode Header Every production script should begin with this canonical header defined in the repository: ```bash #!/usr/bin/env bash set -euo pipefail ``` This single line eliminates entire classes of bugs. For example, attempting to copy a file with an unset variable immediately aborts rather than executing `cp` with invalid arguments: ```bash #!/usr/bin/env bash set -euo pipefail src="$1" dst="$2" # If $1 or $2 is missing, -u triggers an error before cp runs cp -- "$src" "$dst" echo "✅ $src copied to $dst" ``` ### Enhanced Error Diagnostics with Traps Add the `trap` built-in to provide actionable failure messages when strict mode aborts execution: ```bash #!/usr/bin/env bash set -euo pipefail trap 'echo "❌ $0 failed at line $LINENO: $BASH_COMMAND"' ERR mkdir /tmp/example cd /nonexistent # Triggers errexit, invoking the trap ``` Output: ``` ❌ ./script.sh failed at line 6: cd /nonexistent ``` ### Debugging Complex Logic When troubleshooting, temporarily insert `set -x` to observe expansion and execution: ```bash #!/usr/bin/env bash set -euo pipefail set -x grep "pattern" "$(ls *.txt)" ``` Each line prints to `stderr` before execution, revealing exactly how variables expand and which specific command returns a non-zero exit code. ### Safely Processing Files with Whitespace The guide notes at lines 126-127 that strict mode requires careful handling of filenames containing spaces. Combine `IFS` adjustments with strict mode: ```bash #!/usr/bin/env bash set -euo pipefail IFS=$'\n' # Split on newlines only for file in $(find . -type f -print0 | xargs -0 -n1 echo); do echo "Processing: $file" done ``` Setting `IFS=$'\n'` prevents word-splitting on spaces while iterating over filenames, maintaining safety under strict mode constraints. ## Summary - **Use `set -euo pipefail`** as the standard header in every Bash script to catch errors, undefined variables, and pipeline failures immediately. - **Reference [`README.md`](https://github.com/jlevy/the-art-of-command-line/blob/main/README.md) lines 128-130** in `the-art-of-command-line` for the authoritative definition of this strict mode pattern. - **Add `trap '...' ERR`** (lines 130-132) to centralize error reporting and improve debuggability without removing safety guards. - **Employ `set -x`** temporarily when tracing execution flow during complex troubleshooting sessions. - **Adjust `IFS`** when processing filenames to prevent word-splitting issues under strict mode constraints. ## Frequently Asked Questions ### What does `set -euo pipefail` do in Bash? This combination enables **errexit** (exit on error), **nounset** (error on undefined variables), and **pipefail** (catch errors in pipelines). According to `jlevy/the-art-of-command-line`, these three options form the canonical "strict mode" documented at lines 128-130 that prevents silent failures and data corruption in shell scripts. ### Is `set -e` safe to use in all Bash scripts? While `set -e` catches many errors, it requires careful handling of commands intended to fail (like `grep` used for testing existence). The repository recommends this pattern for most automation tasks, though you may need to append `|| true` to specific commands that are allowed to fail, or use explicit conditional checks to maintain script robustness. ### How do I debug a script that exits immediately with `set -e`? Temporarily add `set -x` before the problematic section or use a `trap 'echo "Failed at: $BASH_COMMAND"' ERR` handler. As documented in the Art of Command Line (lines 130-132), this trap catches the specific command that triggered the errexit condition, revealing the exact failure point and line number without removing the safety guard. ### Why does my script fail on undefined variables with strict mode? `set -u` (nounset) treats unset parameters as errors. This catches typos like `$VAR` vs `$var` early. To handle potentially undefined variables intentionally, use default values with `${VAR:-default}` syntax, which satisfies strict mode while providing fallback behavior.