Linux CLI 61 🐧 modern test version and in (( )) shell scripts - KandZ

⏱️ Estimated read: 16 min | |

#!/bin/bash

var1="test"
var2="test case"

if [[ $var1 = test ]]; then
    echo "Using [[ ]], var1 is 'test'"
fi

if [[ "$var1" == "test" ]]; then
    echo "Using [[ ]], var1 is 'test' with quotes"
fi

if [[ $var2 =~ test.* ]]; then
    echo "Using [[ ]], var2 matches regex 'test.*'"
fi

if [[ 10 -eq 10 ]]; then
    echo "Using [[ ]], 10 is equal to 10"
fi

a=5
b=3
sum=$((a + b))
difference=$((a - b))
product=$((a * b))
quotient=$((a / b))
remainder=$((a % b))

echo "Sum: $sum"
echo "Difference: $difference"
echo "Product: $product"
echo "Quotient: $quotient"
echo "Remainder: $remainder"

num1=20
num2=5
result=$((num1 + num2 * 3))
echo "Result: $result"

counter=0
counter=$((counter + 1))
echo "Counter after increment: $counter"
counter=$((counter - 1))
echo "Counter after decrement: $counter"

base=2
exponent=3
result=$((base ** exponent))
echo "$base raised to the power of $exponent is $result"

The older [ ] test has been around since the earliest days of Unix. [[ ]] is bash’s modern replacement — it fixes the quoting headaches, adds regex and pattern matching, and generally makes conditions safer to write. And (( )) is its arithmetic counterpart — a cleaner way to do integer math than expr or let.

Key point: [[ ]] is bash-specific (also ksh and zsh). It’s not POSIX — so if your script must run under dash or plain sh, stick with [ ]. But for modern bash scripts, [[ ]] is almost always the better choice.

a – extended test command in shell scripts

Unlike the traditional [ ] (or test), which requires spaces around operators, [[ ]] does not have this requirement. It’s generally recommended to use [[ ]] over [ ] for most modern shell scripting needs due to its enhanced functionality and error prevention.

The key differences:

Feature	`[ ]`	`[[ ]]`
POSIX	✅	❌ (bash/ksh/zsh)
Word splitting	Yes	No
Pathname expansion	Yes	No
Quote variables	Required	Optional
`&&` / `\|\|` inside	No	Yes
Regex `=~`	No	Yes
Pattern matching `==`	No	Yes
`<` / `>`	Escape needed	Bare works
Parentheses grouping	No	Yes

String comparison without quotes:

Without quotes, [ $var1 = test ] will fail if var1 is empty or contains spaces:

$ var1=""
$ [ $var1 = test ]
bash: [: =: unary operator expected

But [[ $var1 = test ]] handles it cleanly:

$ var1=""
$ [[ $var1 = test ]]
$ echo $?
[ 1 ]

The reason: [[ ]] doesn’t perform word splitting, so an empty variable is treated as an empty string — not as “nothing at all.”

$ var1="test"
$ if [[ $var1 = test ]]; then echo "match"; fi
[ match ]

$ if [[ "$var1" == "test" ]]; then echo "match quoted"; fi
[ match quoted ]

Both work. The quotes are optional in [[ ]] — but harmless and sometimes clearer.

Pattern matching:

[[ ]] supports glob patterns with ==:

$ file="report.txt"
$ if [[ $file == *.txt ]]; then echo "text file"; fi
[ text file ]

$ name="Alice"
$ if [[ $name == A* ]]; then echo "starts with A"; fi
[ starts with A ]

$ if [[ $name == *ice ]]; then echo "ends with ice"; fi
[ ends with ice ]

With [ ], this would expand the glob against the filesystem — not what you want.

# ❌ In [ ], * is expanded by the shell before the test runs
[ "$file" = *.txt ]       # fragile

# ✅ In [[ ]], * is a pattern
[[ $file == *.txt ]]      # reliable

Regex matching with =~:

$ var2="test case"
$ if [[ $var2 =~ test.* ]]; then echo "matches regex"; fi
[ matches regex ]

$ email="user@example.com"
$ if [[ $email =~ ^[a-z]+@[a-z]+\.[a-z]{2,}$ ]]; then echo "valid"; fi
[ valid ]

$ phone="555-1234"
$ if [[ $phone =~ ^[0-9]{3}-[0-9]{4}$ ]]; then echo "valid phone"; fi
[ valid phone ]

The regex is not quoted — quoting it would make it a literal string. To match a literal, put the pattern in a variable:

$ pattern="test.*"
$ if [[ $var2 =~ $pattern ]]; then echo "match"; fi
[ match ]

Numeric comparisons:

Both [ ] and [[ ]] support numeric comparisons the same way:

$ if [[ 10 -eq 10 ]]; then echo "equal"; fi
[ equal ]

$ a=5
$ b=10
$ if [[ $a -lt $b ]]; then echo "less"; fi
[ less ]

Combining conditions inside [[ ]]:

This is one of the biggest wins — && and || work inside the brackets:

$ a=5
$ b=10
$ if [[ $a -gt 0 && $b -gt 0 ]]; then echo "both positive"; fi
[ both positive ]

$ if [[ $a -gt 100 || $b -gt 5 ]]; then echo "at least one"; fi
[ at least one ]

$ if [[ ! -f /nonexistent ]]; then echo "not a file"; fi
[ not a file ]

With [ ], you need separate brackets:

if [ $a -gt 0 ] && [ $b -gt 0 ]; then ...; fi

Grouping with parentheses:

$ if [[ ($a -gt 0 && $b -gt 0) || $a -eq 100 ]]; then
>     echo "condition met"
> fi
[ condition met ]

< and > without escaping:

In [ ], < and > are redirection operators — you have to escape them:

# ❌ Creates a file called "b"
[ "$a" > "$b" ]

# ✅ Escaped
[ "$a" \> "$b" ]

In [[ ]], they work bare:

$ a="apple"
$ b="banana"
$ if [[ $a < $b ]]; then echo "a comes first"; fi
[ a comes first ]

File tests work the same:

$ if [[ -f /etc/passwd ]]; then echo "file"; fi
[ file ]

$ if [[ -d /etc ]]; then echo "dir"; fi
[ dir ]

$ if [[ -x /usr/bin/ls ]]; then echo "exec"; fi
[ exec ]

When to use [[ ]] vs [ ]:

Use `[[ ]]` when	Use `[ ]` when
Writing bash scripts	Need POSIX portability
You want regex matching	Running under `sh` or `dash`
You want glob patterns	Writing portable scripts
You want `&&` / `
You don’t want to quote
You want safer conditions

Rule of thumb: Default to [[ ]] in modern bash. Only fall back to [ ] if you need portability.

b – `(( ))` in shell scripts

(( )) is used for arithmetic evaluation. It allows you to perform mathematical operations and handle integer arithmetic directly within your scripts.

Syntax:

result=$((expression))

expression can include any valid arithmetic operation involving integers:

Operator	Meaning
`+`	Addition
`-`	Subtraction
`*`	Multiplication
`/`	Division
`%`	Modulus (remainder)
`**`	Exponentiation
`++`	Increment
`--`	Decrement
`+=`, `-=`, `*=`, `/=`	Compound assignment

Key points:

Integer arithmetic only — (( )) supports only integer math. For floating point, use bc or awk.
Expression evaluation — the entire expression is evaluated to a single integer value.
Precedence and associativity — standard math rules apply: multiplication and division before addition and subtraction. Parentheses can change the order.

Example 1 — Simple arithmetic operations:

a=5
b=3
sum=$((a + b))
difference=$((a - b))
product=$((a * b))
quotient=$((a / b))
remainder=$((a % b))

echo "Sum: $sum"
echo "Difference: $difference"
echo "Product: $product"
echo "Quotient: $quotient"
echo "Remainder: $remainder"

[ Sum: 8 ]
[ Difference: 2 ]
[ Product: 15 ]
[ Quotient: 1 ]
[ Remainder: 2 ]

Note: 5 / 3 is 1 — integer division truncates. 5 % 3 is 2 — the remainder.

Example 2 — Using variables and expressions:

num1=20
num2=5
result=$((num1 + num2 * 3))
echo "Result: $result"
[ Result: 35 ]

The multiplication happens first (5 * 3 = 15), then the addition (20 + 15 = 35). To change the order, use parentheses:

$ result=$(( (num1 + num2) * 3 ))
$ echo "Result: $result"
[ Result: 75 ]

Example 3 — Incrementing and decrementing variables:

counter=0
counter=$((counter + 1))
echo "Counter after increment: $counter"
[ Counter after increment: 1 ]

counter=$((counter - 1))
echo "Counter after decrement: $counter"
[ Counter after decrement: 0 ]

The shorter form:

$ counter=0
$ ((counter++))
$ echo $counter
[ 1 ]
$ ((counter--))
$ echo $counter
[ 0 ]

Or with compound assignment:

$ counter=10
$ ((counter += 5))
$ echo $counter
[ 15 ]
$ ((counter -= 3))
$ echo $counter
[ 12 ]
$ ((counter *= 2))
$ echo $counter
[ 24 ]
$ ((counter /= 4))
$ echo $counter
[ 6 ]

Example 4 — Using exponentiation:

base=2
exponent=3
result=$((base ** exponent))
echo "$base raised to the power of $exponent is $result"
[ 2 raised to the power of 3 is 8 ]

Comparing (( )) forms:

There are three ways to use arithmetic in bash:

Form	Purpose	Example
`$((...))`	Produce a value	`x=$((a + b))`
`((...))`	Evaluate, set exit status	`((a > b))`
`let`	Older alternative	`let x=a+b`

$((...)) vs ((...)):

$((...)) produces output — you capture it or print it
((...)) sets an exit status — useful in if

# $(( )) produces a value
$ x=$((5 + 3))
$ echo $x
[ 8 ]

# (( )) sets an exit status
$ ((5 > 3))
$ echo $?
[ 0 ]
$ ((5 < 3))
$ echo $?
[ 1 ]

Using (( )) in conditions:

$ a=5
$ b=10
$ if ((a < b)); then echo "a is less"; fi
[ a is less ]

$ if ((a == 5 && b == 10)); then echo "both match"; fi
[ both match ]

$ if ((a > 0)); then echo "positive"; fi
[ positive ]

This is cleaner than [[ $a -lt $b ]] — you write the comparison the way you’d write it in C.

(( )) vs [[ ]] for arithmetic:

# With [[ ]] — bash test operators
if [[ $a -lt $b ]]; then ...; fi

# With (( )) — C-style operators
if ((a < b)); then ...; fi

Both work. (( )) is more natural for math-heavy conditions.

Floating-point limitation:

(( )) only handles integers. For decimals, use bc or awk:

# ❌ Wrong — bash arithmetic is integer only
$ result=$((10 / 3))
$ echo $result
[ 3 ]

# ✅ With bc
$ result=$(echo "scale=2; 10 / 3" | bc)
$ echo $result
[ 3.33 ]

# ✅ With awk
$ result=$(awk 'BEGIN {print 10 / 3}')
$ echo $result
[ 3.33333 ]

Common uses of (( )):

# Counters in loops
$ for ((i=1; i<=5; i++)); do echo "$i"; done
[ 1 ]
[ 2 ]
[ 3 ]
[ 4 ]
[ 5 ]

# Conditional arithmetic
$ ((count++))
$ ((total += amount))

# Generate a random number
$ echo $((RANDOM % 100))
[ 42 ]

# Index an array
$ arr=(a b c d)
$ i=2
$ echo "${arr[$i]}"
[ c ]

C-style for loop:

#!/bin/bash
for ((i=1; i<=5; i++)); do
    echo "Iteration $i"
done
[ Iteration 1 ]
[ Iteration 2 ]
[ Iteration 3 ]
[ Iteration 4 ]
[ Iteration 5 ]

Arithmetic assignment operators:

$ x=10
$ ((x += 5));   echo $x    # 15
$ ((x -= 3));   echo $x    # 12
$ ((x *= 2));   echo $x    # 24
$ ((x /= 4));   echo $x    # 6
$ ((x %= 4));   echo $x    # 2
$ ((x **= 3));  echo $x    # 8

Bitwise operators (bonus):

Operator	Meaning
`&`	AND
`\|`	OR
`^`	XOR
`~`	NOT
`<<`	Left shift
`>>`	Right shift

$ echo $((5 & 3))
[ 1 ]
$ echo $((5 | 3))
[ 7 ]
$ echo $((5 ^ 3))
[ 6 ]
$ echo $((1 << 4))
[ 16 ]
$ echo $((16 >> 2))
[ 4 ]

Comparison: $(( )) vs expr vs let:

Method	Example	Notes
`$(( ))`	`x=$((a+b))`	Modern, preferred
`(( ))`	`((a++))`	For side effects
`let`	`let x=a+b`	Older, still works
`expr`	`x=$(expr $a + $b)`	Obsolete, avoid
`bc`	`echo "a+b" \| bc`	For floating point

Rule of thumb: Use $(( )) for producing values, (( )) for conditions and side effects. Never use expr in new scripts.

Complete Example Session

# ============================================
# PART 1: [[ ]] WITH STRING COMPARISON
# ============================================

$ var1="test"
$ var2="test case"

$ if [[ $var1 = test ]]; then echo "match"; fi
[ match ]

$ if [[ "$var1" == "test" ]]; then echo "match quoted"; fi
[ match quoted ]

$ if [[ $var1 != other ]]; then echo "not other"; fi
[ not other ]

# ============================================
# PART 2: [[ ]] WITH REGEX
# ============================================

$ if [[ $var2 =~ test.* ]]; then echo "matches regex"; fi
[ matches regex ]

$ email="user@example.com"
$ if [[ $email =~ ^[a-z]+@[a-z]+\.[a-z]{2,}$ ]]; then echo "valid"; fi
[ valid ]

# ============================================
# PART 3: [[ ]] WITH GLOB PATTERNS
# ============================================

$ file="report.txt"
$ if [[ $file == *.txt ]]; then echo "text"; fi
[ text ]

$ name="Alice"
$ if [[ $name == A* ]]; then echo "starts with A"; fi
[ starts with A ]

# ============================================
# PART 4: [[ ]] WITH NUMBERS
# ============================================

$ if [[ 10 -eq 10 ]]; then echo "equal"; fi
[ equal ]

$ a=5
$ b=10
$ if [[ $a -lt $b ]]; then echo "less"; fi
[ less ]

# ============================================
# PART 5: [[ ]] WITH COMBINED CONDITIONS
# ============================================

$ a=5
$ b=10
$ if [[ $a -gt 0 && $b -gt 0 ]]; then echo "both positive"; fi
[ both positive ]

$ if [[ $a -gt 100 || $b -gt 5 ]]; then echo "at least one"; fi
[ at least one ]

$ if [[ ! -f /nonexistent ]]; then echo "not a file"; fi
[ not a file ]

# ============================================
# PART 6: [[ ]] WITH GROUPING
# ============================================

$ if [[ ($a -gt 0 && $b -gt 0) || $a -eq 100 ]]; then
>     echo "condition met"
> fi
[ condition met ]

# ============================================
# PART 7: [[ ]] WITH < AND >
# ============================================

$ a="apple"
$ b="banana"
$ if [[ $a < $b ]]; then echo "a first"; fi
[ a first ]

# ============================================
# PART 8: SIMPLE ARITHMETIC WITH $(( ))
# ============================================

$ a=5
$ b=3
$ echo $((a + b))
[ 8 ]
$ echo $((a - b))
[ 2 ]
$ echo $((a * b))
[ 15 ]
$ echo $((a / b))
[ 1 ]
$ echo $((a % b))
[ 2 ]

# ============================================
# PART 9: PRECEDENCE
# ============================================

$ num1=20
$ num2=5
$ echo $((num1 + num2 * 3))
[ 35 ]
$ echo $(((num1 + num2) * 3))
[ 75 ]

# ============================================
# PART 10: INCREMENT / DECREMENT
# ============================================

$ counter=0
$ ((counter++))
$ echo $counter
[ 1 ]
$ ((counter--))
$ echo $counter
[ 0 ]

# ============================================
# PART 11: COMPOUND ASSIGNMENT
# ============================================

$ x=10
$ ((x += 5));  echo $x
[ 15 ]
$ ((x -= 3));  echo $x
[ 12 ]
$ ((x *= 2));  echo $x
[ 24 ]
$ ((x /= 4));  echo $x
[ 6 ]

# ============================================
# PART 12: EXPONENTIATION
# ============================================

$ base=2
$ exponent=3
$ echo $((base ** exponent))
[ 8 ]

# ============================================
# PART 13: ARITHMETIC IN CONDITIONS
# ============================================

$ a=5
$ b=10
$ if ((a < b)); then echo "less"; fi
[ less ]

$ if ((a == 5 && b == 10)); then echo "both"; fi
[ both ]

# ============================================
# PART 14: C-STYLE FOR LOOP
# ============================================

$ for ((i=1; i<=5; i++)); do echo "$i"; done
[ 1 ]
[ 2 ]
[ 3 ]
[ 4 ]
[ 5 ]

# ============================================
# PART 15: RANDOM NUMBER
# ============================================

$ echo $((RANDOM % 100))
[ 42 ]

# ============================================
# PART 16: INTEGER DIVISION TRUNCATION
# ============================================

$ echo $((10 / 3))
[ 3 ]

# Float requires bc
$ echo "scale=2; 10 / 3" | bc
[ 3.33 ]

# Or awk
$ awk 'BEGIN {print 10 / 3}'
[ 3.33333 ]

# ============================================
# PART 17: BITWISE OPERATORS
# ============================================

$ echo $((5 & 3))
[ 1 ]
$ echo $((5 | 3))
[ 7 ]
$ echo $((5 ^ 3))
[ 6 ]
$ echo $((1 << 4))
[ 16 ]

# ============================================
# PART 18: FULL SCRIPT
# ============================================

$ cat > modern.sh << 'EOF'
#!/bin/bash

var1="test"
var2="test case"

if [[ $var1 = test ]]; then
    echo "Using [[ ]], var1 is 'test'"
fi

if [[ "$var1" == "test" ]]; then
    echo "Using [[ ]], var1 is 'test' with quotes"
fi

if [[ $var2 =~ test.* ]]; then
    echo "Using [[ ]], var2 matches regex 'test.*'"
fi

if [[ 10 -eq 10 ]]; then
    echo "Using [[ ]], 10 is equal to 10"
fi

a=5
b=3
sum=$((a + b))
difference=$((a - b))
product=$((a * b))
quotient=$((a / b))
remainder=$((a % b))

echo "Sum: $sum"
echo "Difference: $difference"
echo "Product: $product"
echo "Quotient: $quotient"
echo "Remainder: $remainder"

num1=20
num2=5
result=$((num1 + num2 * 3))
echo "Result: $result"

counter=0
counter=$((counter + 1))
echo "Counter after increment: $counter"
counter=$((counter - 1))
echo "Counter after decrement: $counter"

base=2
exponent=3
result=$((base ** exponent))
echo "$base raised to the power of $exponent is $result"
EOF

$ chmod +x modern.sh
$ ./modern.sh
[ Using [[ ]], var1 is 'test' ]
[ Using [[ ]], var1 is 'test' with quotes ]
[ Using [[ ]], var2 matches regex 'test.*' ]
[ Using [[ ]], 10 is equal to 10 ]
[ Sum: 8 ]
[ Difference: 2 ]
[ Product: 15 ]
[ Quotient: 1 ]
[ Remainder: 2 ]
[ Result: 35 ]
[ Counter after increment: 1 ]
[ Counter after decrement: 0 ]
[ 2 raised to the power of 3 is 8 ]

Quick Reference

`[ ]` vs `[[ ]]`

Feature	`[ ]`	`[[ ]]`
POSIX	✅	❌
Quote required	Yes	No
Word splitting	Yes	No
Glob expansion	Yes	No
`&&` inside	❌	✅
`\|\|` inside	❌	✅
Regex `=~`	❌	✅
Glob `==`	❌	✅
`<` / `>`	Escape	Bare
Grouping `()`	❌	✅

`[[ ]]` Operators

Operator	Meaning
`=` / `==`	String equality
`!=`	String inequality
`=~`	Regex match
`-eq`–`-ge`	Numeric comparisons
`-f`–`-x`	File tests
`&&`	AND
`\|\|`	OR
`!`	NOT
`(` `)`	Grouping

`(( ))` Arithmetic

Operator	Meaning
`+`	Addition
`-`	Subtraction
`*`	Multiplication
`/`	Integer division
`%`	Modulus
`**`	Exponentiation
`++` / `--`	Increment / decrement
`+= -= *= /=`	Compound assignment
`& \| ^ ~ << >>`	Bitwise

Three Forms of Arithmetic

Form	Purpose	Example
`$(( ))`	Produce a value	`x=$((a+b))`
`(( ))`	Evaluate, set status	`((a > b))`
`let`	Older alternative	`let x=a+b`

`(( ))` in Conditions

Expression	Meaning
`((a < b))`	a less than b
`((a <= b))`	a less or equal
`((a == b))`	a equal to b
`((a != b))`	a not equal
`((a && b))`	both non-zero
`((a \|\| b))`	either non-zero
`((!a))`	a is zero

Floating Point

Tool	Example
`bc`	`echo "scale=2; 10/3" \| bc`
`awk`	`awk 'BEGIN {print 10/3}'`

Best Practices

✅ Do This:

# Use [[ ]] in bash scripts
if [[ $var == "value" ]]; then ...; fi       # ✅

# Use regex for pattern matching
if [[ $email =~ ^[a-z]+@ ]]; then ...; fi    # ✅

# Use glob patterns with ==
if [[ $file == *.txt ]]; then ...; fi        # ✅

# Combine conditions inside [[ ]]
if [[ $a -gt 0 && $b -gt 0 ]]; then ...; fi  # ✅

# Use (( )) for arithmetic conditions
if ((a < b)); then ...; fi                   # ✅

# Use $(( )) for values
sum=$((a + b))                               # ✅

# Use C-style for loops
for ((i=0; i<10; i++)); do ...; done         # ✅

# Use bc or awk for floats
result=$(echo "scale=2; 10/3" | bc)          # ✅

# Use compound assignment for clarity
((count += 1))                               # ✅

❌ Don’t Do This:

# Don't use [[ ]] in sh scripts
#!/bin/sh
[[ $a == b ]]                                # ❌ not POSIX

# Don't quote the regex in [[ =~ ]]
if [[ $s =~ "test.*" ]]; then ...; fi        # ❌ literal match
if [[ $s =~ test.* ]]; then ...; fi          # ✅

# Don't use -eq for strings
[[ "$name" -eq "Alice" ]]                    # ❌ error
[[ "$name" == "Alice" ]]                     # ✅

# Don't use = for numbers in [[ ]]
[[ $a = 5 ]]                                 # ⚠️  string compare
((a == 5))                                   # ✅

# Don't expect floats from (( ))
echo $((10 / 3))                             # ❌ gives 3
echo "scale=2; 10/3" | bc                    # ✅

# Don't use expr in modern scripts
x=$(expr $a + $b)                            # ❌ obsolete
x=$((a + b))                                 # ✅

# Don't forget spaces in (( )) when needed
((a=5))                                      # ⚠️  assignment
((a == 5))                                   # ✅ comparison

Common Pitfalls

Pitfall	Problem	Solution
`[[ ]]` in sh	Not POSIX	Use `[ ]` or bash shebang
Quoted regex	Literal match	Don’t quote the pattern
Floats in `(( ))`	Truncated	Use `bc` or `awk`
`=` vs `==` in `[[ ]]`	Both work	Fine either way
`((a=5))`	Assignment, not compare	Use `((a == 5))`
Missing `$` in `$(( ))`	Variable names OK	`$((a + b))` works
`(( ))` with strings	Error	Use `[[ ]]` for strings

Real-World Examples

1. String Comparison with `[[ ]]`

#!/bin/bash
var1="test"
if [[ $var1 = test ]]; then
    echo "var1 is 'test'"
fi
[ var1 is 'test' ]

2. Quoted Comparison

#!/bin/bash
var1="test"
if [[ "$var1" == "test" ]]; then
    echo "var1 is 'test' with quotes"
fi
[ var1 is 'test' with quotes ]

3. Regex Match

#!/bin/bash
var2="test case"
if [[ $var2 =~ test.* ]]; then
    echo "var2 matches regex 'test.*'"
fi
[ var2 matches regex 'test.*' ]

4. Numeric Comparison

#!/bin/bash
if [[ 10 -eq 10 ]]; then
    echo "10 is equal to 10"
fi
[ 10 is equal to 10 ]

5. Full Arithmetic

#!/bin/bash
a=5
b=3
echo "Sum: $((a + b))"
echo "Difference: $((a - b))"
echo "Product: $((a * b))"
echo "Quotient: $((a / b))"
echo "Remainder: $((a % b))"
[ Sum: 8 ]
[ Difference: 2 ]
[ Product: 15 ]
[ Quotient: 1 ]
[ Remainder: 2 ]

6. Operator Precedence

#!/bin/bash
num1=20
num2=5
result=$((num1 + num2 * 3))
echo "Result: $result"
[ Result: 35 ]

7. Increment / Decrement

#!/bin/bash
counter=0
counter=$((counter + 1))
echo "Counter: $counter"
counter=$((counter - 1))
echo "Counter: $counter"
[ Counter: 1 ]
[ Counter: 0 ]

8. Exponentiation

#!/bin/bash
base=2
exponent=3
result=$((base ** exponent))
echo "$base ^ $exponent = $result"
[ 2 ^ 3 = 8 ]

9. Email Validation

#!/bin/bash
read -p "Email: " email
if [[ $email =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
    echo "Valid"
else
    echo "Invalid"
fi

10. File Extension Check

#!/bin/bash
file="$1"
if [[ $file == *.txt ]]; then
    echo "Text file"
elif [[ $file == *.jpg || $file == *.png ]]; then
    echo "Image file"
else
    echo "Other"
fi

11. Numeric Range

#!/bin/bash
read -p "Score: " score
if ((score >= 90 && score <= 100)); then
    echo "A"
elif ((score >= 80)); then
    echo "B"
else
    echo "C or below"
fi

12. Countdown

#!/bin/bash
for ((i=10; i>0; i--)); do
    echo "$i"
    sleep 0.1
done
echo "Liftoff!"

13. Random Number

#!/bin/bash
echo "Random: $((RANDOM % 100))"
[ Random: 42 ]

14. Accumulator

#!/bin/bash
total=0
for n in 1 2 3 4 5; do
    ((total += n))
done
echo "Total: $total"
[ Total: 15 ]

15. Bitwise Operations

#!/bin/bash
echo "AND: $((5 & 3))"
echo "OR:  $((5 | 3))"
echo "XOR: $((5 ^ 3))"
echo "SHL: $((1 << 4))"
echo "SHR: $((16 >> 2))"
[ AND: 1 ]
[ OR:  7 ]
[ XOR: 6 ]
[ SHL: 16 ]
[ SHR: 4 ]

16. Float with `bc`

#!/bin/bash
a=10
b=3
result=$(echo "scale=2; $a / $b" | bc)
echo "$a / $b = $result"
[ 10 / 3 = 3.33 ]

17. Float with `awk`

#!/bin/bash
result=$(awk 'BEGIN {printf "%.2f", 10 / 3}')
echo "Result: $result"
[ Result: 3.33 ]

18. Power Table

#!/bin/bash
for i in 1 2 3 4 5; do
    echo "2^$i = $((2 ** i))"
done
[ 2^1 = 2 ]
[ 2^2 = 4 ]
[ 2^3 = 8 ]
[ 2^4 = 16 ]
[ 2^5 = 32 ]

19. Modern vs Old Test

#!/bin/bash
# Old way
if [ "$1" = "start" ] && [ -n "$1" ]; then
    echo "old style"
fi

# Modern way
if [[ $1 == "start" && -n $1 ]]; then
    echo "modern style"
fi

20. Full Modern Script

#!/bin/bash

# String tests with [[ ]]
name="Alice"
if [[ $name == A* ]]; then
    echo "Starts with A"
fi

if [[ $name =~ ^[A-Z] ]]; then
    echo "Starts with capital"
fi

# Numeric tests with (( ))
age=30
if ((age >= 18)); then
    echo "Adult"
fi

# Arithmetic
total=$((age * 2))
echo "Double age: $total"

# Counter loop
for ((i=1; i<=3; i++)); do
    echo "Iteration $i"
done
[ Starts with A ]
[ Starts with capital ]
[ Adult ]
[ Double age: 60 ]
[ Iteration 1 ]
[ Iteration 2 ]
[ Iteration 3 ]

Visual: `[ ]` vs `[[ ]]`

┌──────────────────────────────────────────────┐
│           [ ] — old test                     │
│                                              │
│  if [ "$var" = "value" ]; then               │
│      # must quote                            │
│  fi                                          │
│                                              │
│  if [ -f file ] && [ -r file ]; then         │
│      # separate brackets                     │
│  fi                                          │
│                                              │
│  • Word splitting                            │
│  • Glob expansion                            │
│  • No regex                                  │
│  • POSIX                                     │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│           [[ ]] — modern test                │
│                                              │
│  if [[ $var == "value" ]]; then              │
│      # no quotes needed                      │
│  fi                                          │
│                                              │
│  if [[ -f file && -r file ]]; then           │
│      # combine inside                        │
│  fi                                          │
│                                              │
│  if [[ $email =~ @.*\.com$ ]]; then          │
│      # regex!                                │
│  fi                                          │
│                                              │
│  • No word splitting                         │
│  • No glob expansion                         │
│  • Regex and globs                           │
│  • bash / ksh / zsh                          │
│                                              │
└──────────────────────────────────────────────┘

Visual: `$(( ))` vs `(( ))`

┌──────────────────────────────────────────────┐
│           $(( )) — produces a value          │
│                                              │
│  sum=$((a + b))                              │
│  echo "Sum: $sum"                            │
│                                              │
│  The result is captured or printed.          │
│                                              │
└──────────────────────────────────────────────┘

┌──────────────────────────────────────────────┐
│           (( )) — sets exit status           │
│                                              │
│  if ((a < b)); then                          │
│      echo "a is less"                        │
│  fi                                          │
│                                              │
│  ((counter++))                               │
│                                              │
│  Used for conditions and side effects.       │
│                                              │
└──────────────────────────────────────────────┘

Summary

Concept	Syntax	Example
Modern test	`[[ EXPR ]]`	`[[ $a == b ]]`
String equality	`==` / `=`	`[[ $name == Alice ]]`
String inequality	`!=`	`[[ $a != $b ]]`
Regex match	`=~`	`[[ $s =~ pat ]]`
Glob pattern	`==`	`[[ $f == *.txt ]]`
Numeric compare	`-eq`–`-ge`	`[[ $a -lt $b ]]`
File test	`-f`–`-x`	`[[ -f file ]]`
AND	`&&`	`[[ $a && $b ]]`
OR	`\|\|`	`[[ $a \|\| $b ]]`
NOT	`!`	`[[ ! -f f ]]`
Grouping	`( )`	`[[ (a \|\| b) && c ]]`
Arithmetic value	`$(( ))`	`x=$((a+b))`
Arithmetic condition	`(( ))`	`((a < b))`
Increment	`++`	`((i++))`
Decrement	`--`	`((i--))`
Compound assign	`+= -= *= /=`	`((x += 5))`
Exponentiation	`**`	`$((2 ** 3))`
Bitwise	`& \| ^ ~ << >>`	`$((5 & 3))`
C-style for	`for ((...))`	`for ((i=0;i<5;i++))`
Float with bc	`\| bc`	`echo "10/3" \| bc`
Float with awk	`awk`	`awk 'BEGIN{print 10/3}'`

Key takeaways:

[[ ]] is the modern bash test — safer, more powerful, and easier to write than [ ]
No word splitting or glob expansion inside [[ ]] — variables don’t need quotes
=~ enables regex matching; == with a pattern enables glob matching
&& and || work inside [[ ]] — no need for multiple brackets
< and > work bare — no escaping needed
[[ ]] is not POSIX — for sh or dash, use [ ]
$(( )) produces a value — capture it or print it
(( )) sets an exit status — use it in if and for side effects
Arithmetic is integer-only — use bc or awk for floats
Precedence is standard math — use parentheses to change the order
++, --, and compound assignment make counters clean
** is exponentiation — bash-specific but very handy
C-style for loops (for ((i=0;i<n;i++))) are clearer than seq for numeric ranges

Remember: In modern bash, reach for [[ ]] first. It’s safer and more capable than [ ], and it handles empty variables, globs, and regex gracefully. Use $(( )) when you want a value and (( )) when you want a condition. Know that arithmetic is integer-only, and reach for bc or awk when you need decimals. Master these two constructs, and your conditions and calculations become clean, correct, and idiomatic bash.

Was this helpful?

Stop using slow, ad-bloated tool sites! 🤮

🔎 Search “KandZ Tools” on Google to use many professional utilities for free.

KandZ.me is the ultimate minimalist hub for:
✅ Finance (Mortgage, Interest, Inflation)
✅ Tech (Base64, JSON, Dev Suite, IP)
✅ Health (BMI, BMR, TDEE)
✅ Productivity (Timer, Workspace, QR)

⚡️ Fast & Private
🔒 No data leaves your device
💎 100% Free

🔗 Use it now: https://tools.kandz.me
🔖 Bookmark it—you’ll need it later!