Comparison Operators

Beginner ~25 min read

Comparison operators are the foundation of conditional logic in Bash. They let you compare numbers, strings, and patterns to make decisions in your scripts. You'll learn about the [[ ]] test construct, numeric comparison flags, string operators, and powerful pattern matching with regex!

Integer Comparison Operators

Bash provides two main ways to compare integers: using (( )) with C-style operators, or using [[ ]] with flag-based operators. Both are widely used.

#!/bin/bash
# Comparison Operators in Bash

echo "=== Bash Comparison Operators ==="
echo ""

# Integer comparisons with (( ))
a=10
b=5
echo "Variables: a=$a, b=$b"
echo ""

echo "--- Integer Comparisons with (( )) ---"
if ((a > b)); then
    echo "a > b: true ($a is greater than $b)"
fi

if ((a >= b)); then
    echo "a >= b: true"
fi

if ((a < b)); then
    echo "a < b: true"
else
    echo "a < b: false ($a is not less than $b)"
fi

if ((a == b)); then
    echo "a == b: true"
else
    echo "a == b: false ($a is not equal to $b)"
fi

if ((a != b)); then
    echo "a != b: true ($a is not equal to $b)"
fi
echo ""

# Integer comparisons with [[ ]] using flags
echo "--- Integer Comparisons with [[ ]] flags ---"
x=20
y=20
echo "Variables: x=$x, y=$y"

if [[ $x -eq $y ]]; then
    echo "-eq: $x equals $y"
fi

if [[ $x -ne 15 ]]; then
    echo "-ne: $x does not equal 15"
fi

if [[ $x -gt 10 ]]; then
    echo "-gt: $x is greater than 10"
fi

if [[ $x -ge 20 ]]; then
    echo "-ge: $x is greater than or equal to 20"
fi

Output

Click Run to execute your code

C-Style Operators in (( ))

Operator	Description	Example
`==`	Equal to	`((a == b))`
`!=`	Not equal to	`((a != b))`
`<`	Less than	`((a < b))`
`>`	Greater than	`((a > b))`
`<=`	Less than or equal	`((a <= b))`
`>=`	Greater than or equal	`((a >= b))`

Flag-Based Operators in [[ ]] or [ ]

Operator	Description	Example
`-eq`	Equal to	`[[ $a -eq $b ]]`
`-ne`	Not equal to	`[[ $a -ne $b ]]`
`-lt`	Less than	`[[ $a -lt $b ]]`
`-gt`	Greater than	`[[ $a -gt $b ]]`
`-le`	Less than or equal	`[[ $a -le $b ]]`
`-ge`	Greater than or equal	`[[ $a -ge $b ]]`

Key Point: Use (( )) for arithmetic comparisons (looks cleaner, supports C-style operators). Use [[ ]] when mixing with string tests or when you need the flag-based operators for POSIX compatibility.

String Comparison Operators

String comparisons check text values. Always quote your variables inside [[ ]] to handle empty strings and spaces correctly!

#!/bin/bash
# String Comparison Operators in Bash

echo "=== String Comparisons ==="
echo ""

str1="hello"
str2="world"
str3="hello"
empty=""

echo "Variables:"
echo "  str1='$str1'"
echo "  str2='$str2'"
echo "  str3='$str3'"
echo "  empty='$empty'"
echo ""

echo "--- String Equality ---"
if [[ "$str1" == "$str3" ]]; then
    echo "str1 == str3: true ('$str1' equals '$str3')"
fi

if [[ "$str1" != "$str2" ]]; then
    echo "str1 != str2: true ('$str1' not equal '$str2')"
fi
echo ""

echo "--- String Length Tests ---"
if [[ -z "$empty" ]]; then
    echo "-z empty: true (string is empty/zero length)"
fi

if [[ -n "$str1" ]]; then
    echo "-n str1: true (string is not empty)"
fi
echo ""

echo "--- Lexicographic Comparison ---"
if [[ "$str1" < "$str2" ]]; then
    echo "str1 < str2: true ('$str1' comes before '$str2' alphabetically)"
fi

if [[ "apple" < "banana" ]]; then
    echo "'apple' < 'banana': true (alphabetically)"
fi

if [[ "zebra" > "apple" ]]; then
    echo "'zebra' > 'apple': true (alphabetically)"
fi

Output

Click Run to execute your code

Operator	Description	Example
`==` or `=`	String equality	`[[ "$a" == "$b" ]]`
`!=`	String inequality	`[[ "$a" != "$b" ]]`
`<`	Less than (lexicographic)	`[[ "$a" < "$b" ]]`
`>`	Greater than (lexicographic)	`[[ "$a" > "$b" ]]`
`-z`	String is empty (zero length)	`[[ -z "$str" ]]`
`-n`	String is not empty	`[[ -n "$str" ]]`

Pro Tip: Always quote variables in string comparisons: [[ "$var" == "text" ]]. This prevents errors when variables are empty or contain spaces. Inside [[ ]], word splitting doesn't occur, but quoting is still a good habit!

Pattern Matching and Regex

The [[ ]] construct supports glob-style pattern matching with == and full regex matching with =~. These are powerful tools for string validation!

#!/bin/bash
# Pattern Matching and Regex in [[ ]]

echo "=== Pattern Matching in [[ ]] ==="
echo ""

filename="script.sh"
email="user@example.com"
text="Hello World 123"

echo "Variables:"
echo "  filename='$filename'"
echo "  email='$email'"
echo "  text='$text'"
echo ""

echo "--- Glob Pattern Matching (==) ---"
if [[ "$filename" == *.sh ]]; then
    echo "'$filename' matches *.sh pattern"
fi

if [[ "$filename" == script* ]]; then
    echo "'$filename' starts with 'script'"
fi

if [[ "$email" == *@* ]]; then
    echo "'$email' contains @ symbol"
fi
echo ""

echo "--- Regex Matching (=~) ---"
# Check if string contains numbers
if [[ "$text" =~ [0-9]+ ]]; then
    echo "'$text' contains numbers"
    echo "  Matched: ${BASH_REMATCH[0]}"
fi

# Email validation (simple)
if [[ "$email" =~ ^[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z]+$ ]]; then
    echo "'$email' looks like a valid email"
fi

# Extract parts with regex groups
version="v2.5.10"
if [[ "$version" =~ v([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
    echo "Version '$version' parsed:"
    echo "  Major: ${BASH_REMATCH[1]}"
    echo "  Minor: ${BASH_REMATCH[2]}"
    echo "  Patch: ${BASH_REMATCH[3]}"
fi

Output

Click Run to execute your code

Pattern Matching Types:

Glob patterns with ==: Use * (any chars), ? (one char), [...] (character class)
Regex patterns with =~: Full extended regex support
BASH_REMATCH: Array containing regex matches (index 0 = full match, 1+ = capture groups)

Caution: When using =~ for regex, do NOT quote the pattern! Quoting turns it into a literal string match. Write [[ $str =~ ^[0-9]+$ ]] not [[ $str =~ "^[0-9]+$" ]].

The test Command and [ ]

The test command and [ ] are the POSIX-compliant, portable way to do comparisons. They work in any shell, not just Bash.

# test command and [ ] are equivalent
test 5 -eq 5 && echo "Equal"
[ 5 -eq 5 ] && echo "Equal"

# String tests
test -n "hello" && echo "Not empty"
[ -z "" ] && echo "Empty"

# Combining with && and ||
[ "$USER" = "root" ] && echo "You are root" || echo "Not root"

# IMPORTANT: Spaces are required!
# [ "$a"="$b" ]   # WRONG - no spaces
# [ "$a" = "$b" ] # CORRECT - spaces around =

Pro Tip: Prefer [[ ]] over [ ] in Bash scripts. It's more powerful (supports regex, pattern matching), safer (no word splitting), and doesn't require escaping < and >. Use [ ] only when writing portable POSIX scripts.

Common Mistakes

1. Using = vs == for strings

# In [ ], use single =
[ "$str" = "hello" ]   # Correct for [ ]

# In [[ ]], prefer ==
[[ "$str" == "hello" ]]  # Preferred for [[ ]]

# Don't use -eq for strings!
[[ "$str" -eq "hello" ]]  # Wrong! -eq is for numbers

2. Missing spaces in [ ]

# Wrong - no spaces
[$a -eq $b]      # Error: command not found
[ $a -eq$b ]     # Error

# Correct - spaces required
[ $a -eq $b ]    # Works
[[ $a -eq $b ]]  # Works

3. Quoting regex patterns

# Wrong - pattern is quoted, treated as literal
[[ "test123" =~ "^[a-z]+[0-9]+$" ]]  # Fails

# Correct - don't quote regex patterns
[[ "test123" =~ ^[a-z]+[0-9]+$ ]]    # Works

4. Comparing numbers as strings

# Problematic - string comparison
[[ "10" > "9" ]]    # False! '10' < '9' lexicographically

# Correct - numeric comparison
[[ 10 -gt 9 ]]      # True
((10 > 9))          # True

Exercise: Input Validation Script

Task: Create a script that validates different types of input!

Requirements:

Check if a number is within a range (1-100)
Validate that a string is not empty
Check if a filename has a specific extension (.sh)
Use regex to validate a simple email format

Show Solution

#!/bin/bash
# Input Validation Script

echo "=== Input Validation ==="
echo ""

# Number range check
number=50
echo "Checking number: $number"
if ((number >= 1 && number <= 100)); then
    echo "  Valid: $number is between 1 and 100"
else
    echo "  Invalid: Out of range"
fi
echo ""

# String not empty
username="alice"
echo "Checking username: '$username'"
if [[ -n "$username" ]]; then
    echo "  Valid: Username is not empty"
else
    echo "  Invalid: Username is empty"
fi
echo ""

# Filename extension
filename="script.sh"
echo "Checking filename: '$filename'"
if [[ "$filename" == *.sh ]]; then
    echo "  Valid: File has .sh extension"
else
    echo "  Invalid: Not a shell script"
fi
echo ""

# Email validation (simple regex)
email="[email protected]"
echo "Checking email: '$email'"
if [[ "$email" =~ ^[a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z]+$ ]]; then
    echo "  Valid: Looks like an email"
else
    echo "  Invalid: Not a valid email format"
fi

Summary

Integer Comparisons: Use (( )) with ==, !=, <, >, <=, >= or [[ ]] with -eq, -ne, -lt, -gt, -le, -ge
String Comparisons: Use ==, !=, <, > inside [[ ]]; check empty with -z and -n
Pattern Matching: Use == with glob patterns (*, ?, [...])
Regex Matching: Use =~ with unquoted regex; access matches via BASH_REMATCH
[[ ]] vs [ ]: Prefer [[ ]] for Bash; use [ ] for POSIX portability
Always Quote: Quote variables in comparisons to handle empty values safely

What's Next?

Now that you can compare values, let's learn about Logical Operators. You'll discover how to combine conditions using AND (&&), OR (||), and NOT (!) to build complex conditional logic in your scripts!

Previous Arithmetic Operations

Next Logical Operators

Integer Comparison Operators

C-Style Operators in (( ))

Flag-Based Operators in [[ ]] or [ ]

String Comparison Operators

Pattern Matching and Regex

The test Command and [ ]

Common Mistakes

1. Using = vs == for strings

2. Missing spaces in [ ]

3. Quoting regex patterns

4. Comparing numbers as strings

Exercise: Input Validation Script

Summary

What's Next?

Enjoying these tutorials?