Conditionals🔗

Part of a deep dive: Bash Scripting

Consult the map

Bash Scripting — step 4 of 6

← Arguments and Exit Codes · you are here · Loops →

Start the deep dive →

Every real script makes decisions: does this file exist? Did that command succeed? Is this variable set? Bash conditionals are the logic layer that turns a list of commands into a real program.

Where You Might Have Seen This🔗

The if/elif/else structure is the same as every other scripting language. The one mental shift: Bash conditions are exit codes, not booleans. A command that exits 0 is "true"; non-zero is "false." Once that clicks, the rest follows.

if / elif / else🔗

The syntax is straightforward. What matters more is the pattern: in real scripts, conditionals are mostly guard clauses — check what could go wrong at the top and exit immediately if it does. The rest of the script then runs with confidence that its preconditions are met.

Basic if Structure
if [[ condition ]]; then
    command            # (1)!
elif [[ other_condition ]]; then
    command            # (2)!
else
    command            # (3)!
fi

Runs if condition is true.
Runs if the first condition was false and this one is true.
Runs if no condition was true.

fi closes every if. The then keyword requires either a ; before it on the same line, or a newline — both are valid, the single-line form is more common in scripts.

The `[[ ]]` Test Operator🔗

[[ ]] is Bash's built-in test expression. It evaluates a condition and exits 0 (true) or 1 (false) — which means it works directly inside if, while, and &&/|| chains.

File ExistencePermissionsStringsNumeric

Before operating on a file, confirm it exists and is what you expect. The -f and -d tests are the most common in production scripts:

File Existence Tests
[[ -e "/path/to/thing" ]]    # (1)!
[[ -f "/path/to/file" ]]     # (2)!
[[ -d "/path/to/dir" ]]      # (3)!
[[ -L "/path/to/link" ]]     # (4)!
[[ -s "/path/to/file" ]]     # (5)!

Exists — file or directory.
Exists and is a regular file.
Exists and is a directory.
Exists and is a symlink.
Exists and is non-empty (size > 0).

Validate your script has the access it needs before attempting an operation. A permission failure mid-script is harder to debug than a clear error at the start — see File Permissions:

Permission Tests
[[ -r "/path/to/file" ]]     # (1)!
[[ -w "/path/to/file" ]]     # (2)!
[[ -x "/path/to/file" ]]     # (3)!

Readable by the current user.
Writable by the current user.
Executable by the current user.

Use string tests to validate variables before using them. An empty variable used in a destructive command is the most common source of production incidents:

String Tests
[[ -z "${VAR}" ]]              # (1)!
[[ -n "${VAR}" ]]              # (2)!
[[ "${A}" == "${B}" ]]         # (3)!
[[ "${A}" != "${B}" ]]         # (4)!
[[ "${STR}" == *"substr"* ]]   # (5)!
[[ "${STR}" =~ ^[0-9]+$ ]]    # (6)!

True if VAR is empty or unset.
True if VAR is non-empty.
String equality.
String inequality.
Contains substring — == with a glob pattern.
Matches regex — the pattern is unquoted on the right-hand side.

Use -eq, -lt, -gt for numeric comparisons. == does string comparison — [[ 10 == 9 ]] is false but [[ 10 > 9 ]] does a string sort, not a numeric one:

Numeric Tests
[[ $a -eq $b ]]    # (1)!
[[ $a -ne $b ]]    # (2)!
[[ $a -lt $b ]]    # (3)!
[[ $a -gt $b ]]    # (4)!
[[ $a -le $b ]]    # (5)!
[[ $a -ge $b ]]    # (6)!

Equal.
Not equal.
Less than.
Greater than.
Less than or equal.
Greater than or equal.

Combining Conditions🔗

Use && and || inside [[ ]] to express complex guards in a single test rather than nesting multiple if blocks:

Logical Operators
if [[ -f "${config}" && -r "${config}" ]]; then   # (1)!
    echo "Config is readable"
fi

if [[ "${env}" == "production" || "${env}" == "staging" ]]; then  # (2)!
    echo "Deploying to a live environment"
fi

if [[ ! -d "${output_dir}" ]]; then   # (3)!
    mkdir -p "${output_dir}"
fi

Both conditions must be true — file exists AND is readable.
Either condition satisfies — production OR staging.
! inverts the test — runs the body when the directory does NOT exist.

`[[ ]]` vs `[ ]`🔗

You'll see both in existing scripts:

Feature	`[[ ]]`	`[ ]`
Word splitting on variables	❌ No — safer	✅ Yes — requires careful quoting
Pattern matching with `==`	✅ Glob patterns	❌ No
Regex with `=~`	✅ Yes	❌ No
`&&` and `\\|\\|` inside the test	✅ Yes	❌ No
Portability	Bash only	POSIX sh compatible

Use [[ ]] in Bash scripts. Use [ ] only when you need POSIX sh portability (scripts starting with #!/bin/sh).

Testing Command Success🔗

This is where Bash conditionals become uniquely powerful. Because if evaluates exit codes, any command works as a condition — not just [[ ]] tests. You can branch directly on whether a command succeeded or failed, without capturing its output or checking $?:

Commands as Conditions
if grep -q "error" /var/log/app.log; then   # (1)!
    echo "Errors found in log"
fi

if ! systemctl is-active --quiet nginx; then  # (2)!
    echo "nginx is not running — starting it"
    systemctl start nginx
fi

if ! command -v jq &>/dev/null; then   # (3)!
    echo "Error: jq is required but not installed" >&2
    exit 1
fi

grep -q runs silently — the exit code is the condition. 0 if the pattern was found, 1 if not.
! inverts the exit code — this block runs when nginx is NOT active.
command -v is the portable way to check whether a program exists in PATH.

Real-World Patterns🔗

File System ChecksString Comparisons

Any script that reads a config file or writes to a directory should validate its paths before doing any work. Fail with a clear message rather than letting the script crash mid-way:

Validate Before Running
#!/usr/bin/env bash

config_file="${1:-/etc/myapp/config.yml}"

if [[ ! -f "${config_file}" ]]; then       # (1)!
    echo "Error: config file not found: ${config_file}" >&2
    exit 1
fi

if [[ ! -r "${config_file}" ]]; then       # (2)!
    echo "Error: config file not readable: ${config_file}" >&2
    exit 1
fi

echo "Config OK: ${config_file}"

Guard against a missing file before trying to read it.
Guard against a permission problem separately — the error message tells the user exactly what's wrong.

Validate string arguments as soon as you receive them — before any logic that depends on their value. An invalid value caught early gives a clear error; one caught late produces confusing behaviour:

Validate String Arguments
#!/usr/bin/env bash

env="$1"

if [[ -z "${env}" ]]; then    # (1)!
    echo "Error: environment argument required" >&2
    exit 1
fi

if [[ "${env}" != "production" && "${env}" != "staging" && "${env}" != "dev" ]]; then  # (2)!
    echo "Error: invalid environment '${env}'. Must be: production, staging, dev" >&2
    exit 1
fi

echo "Target environment: ${env}"

Check for empty before checking the value — an empty variable would pass most value checks silently.
Allowlist validation — reject anything not explicitly permitted.

flowchart TD
    A["Script starts"] --> B{"Required vars set?"}
    B -->|"No"| X1["exit 1"]
    B -->|"Yes"| C{"Required tools installed?"}
    C -->|"No"| X2["exit 1"]
    C -->|"Yes"| D{"Connection works?"}
    D -->|"No"| X3["exit 1"]
    D -->|"Yes"| E["Main work runs"]

    style A fill:#2d3748,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style B fill:#1a202c,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style C fill:#1a202c,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style D fill:#1a202c,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style X1 fill:#c53030,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style X2 fill:#c53030,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style X3 fill:#c53030,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style E fill:#2f855a,stroke:#cbd5e0,stroke-width:2px,color:#fff

Preflight Checks

Consolidate everything that must be true before a script's main work begins. A preflight block at the top means the script either starts with confidence or fails immediately with a clear reason:

Preflight Check
#!/usr/bin/env bash

if [[ -z "${DB_HOST}" || -z "${API_KEY}" ]]; then   # (1)!
    echo "Error: DB_HOST and API_KEY must be set" >&2
    exit 1
fi

if ! command -v psql &>/dev/null; then              # (2)!
    echo "Error: psql is not installed" >&2
    exit 1
fi

if ! psql -h "${DB_HOST}" -c "SELECT 1" &>/dev/null; then  # (3)!
    echo "Error: cannot connect to database at ${DB_HOST}" >&2
    exit 1
fi

echo "All checks passed — starting deployment"

Check required environment variables first — cheapest check, most common failure.
Check required tools before trying to use them.
Verify the actual connection — the most expensive check, so it comes last.

Practice Exercises🔗

Exercise 1: File Validation Script

Write a script that accepts a file path as its argument and:

Exits with code 1 if no argument is provided
Exits with code 2 if the path exists but is a directory, not a file
Exits with code 3 if the file doesn't exist
Prints "File OK: {path}" and exits with code 0 if the file exists and is readable

Solution

validate-file.sh
#!/usr/bin/env bash

if [[ $# -lt 1 ]]; then
    echo "Usage: $0 <file-path>" >&2
    exit 1
fi

path="$1"

if [[ -d "${path}" ]]; then
    echo "Error: ${path} is a directory, not a file" >&2
    exit 2
fi

if [[ ! -f "${path}" ]]; then
    echo "Error: ${path} does not exist" >&2
    exit 3
fi

echo "File OK: ${path}"
exit 0

Exercise 2: OS Family Detector

Write a script that detects the Linux distribution family:

If /etc/debian_version exists, print "Debian-based system"
If /etc/redhat-release exists, print "Red Hat-based system"
If /etc/arch-release exists, print "Arch Linux"
Otherwise, print "Unknown distribution"

Solution

detect-os.sh
#!/usr/bin/env bash

if [[ -f "/etc/debian_version" ]]; then
    echo "Debian-based system"
elif [[ -f "/etc/redhat-release" ]]; then
    echo "Red Hat-based system"
elif [[ -f "/etc/arch-release" ]]; then
    echo "Arch Linux"
else
    echo "Unknown distribution"
fi

Quick Recap🔗

Guard-first: check what can go wrong at the top, exit early, then run the main logic with confidence
if [[ condition ]]; then ... elif ... else ... fi — fi closes every if
Use [[ ]] not [ ] in Bash scripts — no word splitting, supports globs and regex
File tests: -f (regular file), -d (directory), -e (exists), -r/-w/-x (permissions), -s (non-empty)
String tests: -z (empty), -n (non-empty), ==, !=, =~ (regex), == with * (glob)
Numeric tests: -eq, -ne, -lt, -gt, -le, -ge
Any command works as a condition — its exit code is the test
&& and || combine conditions; ! inverts them

What's Next?🔗

Head to Loops — for and while, iterating over files and command output, and the patterns that make repetition reliable.

Conditionals🔗

Where You Might Have Seen This🔗

if / elif / else🔗

The `[[ ]]` Test Operator🔗

Combining Conditions🔗

`[[ ]]` vs `[ ]`🔗

Testing Command Success🔗

Real-World Patterns🔗

Practice Exercises🔗

Quick Recap🔗

What's Next?🔗

Further Reading🔗

Command References🔗

Deep Dives🔗

Official Documentation🔗

Exploring Python🔗

Conditionals🔗

Where You Might Have Seen This🔗

if / elif / else🔗

The [[ ]] Test Operator🔗

Combining Conditions🔗

[[ ]] vs [ ]🔗

Testing Command Success🔗

Real-World Patterns🔗

Practice Exercises🔗

Quick Recap🔗

What's Next?🔗

Further Reading🔗

Command References🔗

Deep Dives🔗

Official Documentation🔗

Exploring Python🔗

The `[[ ]]` Test Operator🔗

`[[ ]]` vs `[ ]`🔗