Logical Operators

Beginner ~15 min read

Logical operators let you combine multiple conditions and control command execution flow in Bash. You'll learn to use AND (&&), OR (||), and NOT (!) to build complex conditional logic, plus a powerful technique for command chaining based on success or failure!

Logical Operators in Conditions

Inside [[ ]] or (( )), use && (AND), || (OR), and ! (NOT) to combine conditions.

#!/bin/bash
# Logical Operators in Bash

echo "=== Bash Logical Operators ==="
echo ""

# Variables for testing
a=10
b=5
name="admin"
logged_in=true

echo "Variables: a=$a, b=$b, name='$name', logged_in=$logged_in"
echo ""

# AND operator (&&)
echo "--- AND Operator (&&) ---"
if [[ $a -gt 5 && $b -lt 10 ]]; then
    echo "Both conditions true: a>5 AND b<10"
fi

# Inside (( )) for arithmetic
if ((a > 5 && b > 0)); then
    echo "Arithmetic AND: a>5 && b>0"
fi
echo ""

# OR operator (||)
echo "--- OR Operator (||) ---"
if [[ $name == "admin" || $name == "root" ]]; then
    echo "User is admin OR root: name='$name'"
fi

if ((a == 10 || b == 10)); then
    echo "Either a=10 OR b=10"
fi
echo ""

# NOT operator (!)
echo "--- NOT Operator (!) ---"
if [[ ! $name == "guest" ]]; then
    echo "NOT guest: name='$name'"
fi

empty_var=""
if [[ ! -n $empty_var ]]; then
    echo "Variable is empty (NOT non-empty)"
fi
echo ""

# Combining operators
echo "--- Combined Conditions ---"
age=25
has_license=true
if [[ $age -ge 18 && $has_license == true ]]; then
    echo "Can drive: age=$age, has_license=$has_license"
fi

Output

Click Run to execute your code

Operator	Name	Description	Example
`&&`	AND	True if BOTH conditions are true	`[[ $a -gt 5 && $b -lt 10 ]]`
`\|\|`	OR	True if EITHER condition is true	`[[ $x == "yes" \|\| $x == "y" ]]`
`!`	NOT	Inverts the condition (true becomes false)	`[[ ! -f "$file" ]]`

Operator Precedence: NOT (!) has the highest precedence, then AND (&&), then OR (||). Use parentheses to group conditions: [[ (cond1 || cond2) && cond3 ]].

Command Chaining with && and ||

Outside of [[ ]], these operators chain commands based on exit status. This is one of the most useful patterns in shell scripting!

#!/bin/bash
# Logical Operators with Command Chaining

echo "=== Command Chaining with && and || ==="
echo ""

# && - Run second command only if first succeeds
echo "--- && (AND) - Run on Success ---"
echo "Test 1: mkdir creates directory, cd enters it"
mkdir -p /tmp/test_dir && echo "Directory created successfully"

echo ""
echo "Test 2: Command fails, second not executed"
# false always fails (exit code 1)
false && echo "This won't print"
echo "  (Notice the above line didn't print)"

echo ""
# || - Run second command only if first fails
echo "--- || (OR) - Run on Failure ---"
echo "Test 3: Fallback on failure"
# Try to read non-existent file, fallback to message
cat /nonexistent/file 2>/dev/null || echo "File not found, using fallback"

echo ""
echo "Test 4: Success, fallback not needed"
echo "Hello" || echo "This won't print"

echo ""
# Combining && and ||
echo "--- Ternary-like Pattern: cmd && true || false ---"
value=50
echo "Value: $value"
[[ $value -gt 25 ]] && echo "  Result: Greater than 25" || echo "  Result: 25 or less"

value=10
echo "Value: $value"
[[ $value -gt 25 ]] && echo "  Result: Greater than 25" || echo "  Result: 25 or less"

echo ""
# Practical example: create dir if not exists
echo "--- Practical Example ---"
target_dir="/tmp/my_app_data"
[[ -d $target_dir ]] && echo "Dir exists" || mkdir -p $target_dir && echo "Dir created"

Output

Click Run to execute your code

Pattern	Behavior	Use Case
`cmd1 && cmd2`	Run cmd2 only if cmd1 succeeds (exit 0)	Sequential dependent tasks
`cmd1 \|\| cmd2`	Run cmd2 only if cmd1 fails (exit non-0)	Fallback/error handling
`cmd && true \|\| false`	Ternary-like: do one thing on success, another on failure	Conditional actions

Pro Tip: The cmd && success_action || failure_action pattern is great for one-liners but can be tricky. If success_action itself fails, failure_action will also run! For complex logic, use proper if statements.

Short-Circuit Evaluation

Bash uses short-circuit evaluation, meaning it stops evaluating as soon as the result is determined. This is important for both performance and avoiding errors!

# AND short-circuits on first false
[[ false && echo "This won't run" ]]

# OR short-circuits on first true
[[ true || echo "This won't run" ]]

# Practical use: check variable exists before using
[[ -n "$file" && -f "$file" ]] && cat "$file"
# If file is empty/unset, the -f test never runs

# Safe division: check denominator first
denom=0
[[ $denom -ne 0 && $((10 / denom)) -gt 5 ]]
# Division never executes because first condition is false

Why It Matters:

Performance: Unnecessary checks are skipped
Safety: Prevents errors from invalid operations
Guard Pattern: Check existence before accessing ([[ -f $f && cat $f ]])

POSIX Operators: -a and -o (Legacy)

Inside [ ] (single brackets), the POSIX-compatible operators are -a (AND) and -o (OR). You'll see these in older scripts.

#!/bin/bash
# POSIX-compatible Logical Operators: -a and -o

echo "=== POSIX Operators: -a and -o ==="
echo ""

# Note: -a and -o work inside [ ] but are deprecated
# They're shown here for understanding legacy scripts

a=10
b=5
str="hello"

echo "Variables: a=$a, b=$b, str='$str'"
echo ""

echo "--- Using -a (AND) in [ ] ---"
# -a is AND inside single brackets
if [ $a -gt 5 -a $b -lt 10 ]; then
    echo "[ \$a -gt 5 -a \$b -lt 10 ] = true"
fi

echo ""
echo "--- Using -o (OR) in [ ] ---"
# -o is OR inside single brackets
if [ "$str" = "hello" -o "$str" = "world" ]; then
    echo "[ \$str = 'hello' -o \$str = 'world' ] = true"
fi

echo ""
echo "--- Modern Equivalent (Preferred) ---"
# Prefer [[ ]] with && and ||
if [[ $a -gt 5 && $b -lt 10 ]]; then
    echo "[[ \$a -gt 5 && \$b -lt 10 ]] = true"
fi

if [[ "$str" == "hello" || "$str" == "world" ]]; then
    echo "[[ \$str == 'hello' || \$str == 'world' ]] = true"
fi

echo ""
echo "NOTE: Prefer && and || over -a and -o"
echo "The -a and -o operators are deprecated in [[ ]]"

Output

Click Run to execute your code

Caution: The -a and -o operators are deprecated and can cause issues with certain inputs. Always prefer && and || inside [[ ]] for modern scripts. Only use -a and -o when writing strictly POSIX-compliant scripts for non-Bash shells.

Common Mistakes

1. Using && and || in single brackets [ ]

# Wrong - && is command chaining, not logical AND in [ ]
[ $a -gt 5 && $b -lt 10 ]  # Syntax error or wrong behavior

# Correct - use -a inside [ ]
[ $a -gt 5 -a $b -lt 10 ]

# Better - use [[ ]] with &&
[[ $a -gt 5 && $b -lt 10 ]]

2. Misunderstanding the ternary-like pattern

# Potentially wrong behavior
[[ condition ]] && echo "success" || echo "fail"
# If echo "success" fails somehow, "fail" also prints!

# Safer alternative for complex logic
if [[ condition ]]; then
    echo "success"
else
    echo "fail"
fi

3. Forgetting parentheses for precedence

# Confusing precedence
[[ $a == "x" || $b == "y" && $c == "z" ]]
# This is: a=="x" OR (b=="y" AND c=="z")

# Use parentheses for clarity
[[ ($a == "x" || $b == "y") && $c == "z" ]]
# This is: (a=="x" OR b=="y") AND c=="z"

Exercise: Access Control Script

Task: Create a script that checks multiple conditions for access control!

Requirements:

Check if user is "admin" OR user is "root"
Check if age is 18+ AND has permission flag
Use NOT to check if user is NOT banned
Use command chaining to create a log file only on success

Show Solution

#!/bin/bash
# Access Control Script

user="admin"
age=25
has_permission=true
banned_users="guest blocked"

echo "=== Access Control Check ==="
echo "User: $user, Age: $age, Has Permission: $has_permission"
echo ""

# Check 1: Admin OR Root
echo "--- Check 1: Admin or Root ---"
if [[ "$user" == "admin" || "$user" == "root" ]]; then
    echo "PASS: User is admin or root"
else
    echo "FAIL: User is not admin or root"
fi

# Check 2: Age AND Permission
echo ""
echo "--- Check 2: Age and Permission ---"
if [[ $age -ge 18 && "$has_permission" == "true" ]]; then
    echo "PASS: User is 18+ with permission"
else
    echo "FAIL: Age or permission check failed"
fi

# Check 3: NOT Banned
echo ""
echo "--- Check 3: Not Banned ---"
if [[ ! "$banned_users" =~ $user ]]; then
    echo "PASS: User is not banned"
else
    echo "FAIL: User is banned"
fi

# Command chaining: Log success
echo ""
echo "--- Command Chaining ---"
[[ "$user" == "admin" ]] && echo "Access granted" || echo "Access denied"

Summary

AND (&&): Both conditions must be true; in command chaining, runs second only if first succeeds
OR (||): Either condition can be true; in command chaining, runs second only if first fails
NOT (!): Inverts the condition's truth value
Short-Circuit: Evaluation stops when result is determined
Precedence: ! > && > || (use parentheses for clarity)
Legacy: -a and -o for POSIX compatibility (prefer && and ||)
Command Chaining: cmd1 && cmd2 || cmd3 for conditional execution

What's Next?

Now that you can combine conditions, let's learn about File Test Operators. You'll discover how to check if files exist, are readable, writable, executable, and much more. These are essential for any script that works with files!

Previous Comparison Operators

Next File Test Operators