Bash focus guide

Bash Operators Explained

Bash operators help scripts make decisions. This guide explains file tests, string checks, numeric comparisons, logic operators and practical if statement patterns for Linux beginners.

Bash Hub Bash Cheat Sheet Beginner Part 2 Bash For Loops

On this page

What are operators? File test operators String operators Number operators Logic operators Arithmetic operators Example scripts Common errors Cheat table

Basics

What are Bash operators?

Operators are symbols or flags that compare values or test conditions. They are usually used inside if statements.

if [ -f "$FILE" ]; then
  echo "File exists"
fi

In that example, -f is a file test operator. It checks whether the path is a regular file.

Spacing matters. Use [ -f "$FILE" ], not [-f "$FILE"].

Files

File test operators

Operator	Meaning	Example
`-f`	Path is a regular file	`[ -f "$FILE" ]`
`-d`	Path is a directory	`[ -d "$DIR" ]`
`-e`	Path exists	`[ -e "$PATH_TO_CHECK" ]`
`-x`	File is executable	`[ -x "$SCRIPT" ]`
`-s`	File exists and is not empty	`[ -s "$LOG" ]`
`-r`	File is readable	`[ -r "$FILE" ]`
`-w`	File is writable	`[ -w "$FILE" ]`

FILE="/etc/passwd"

if [ -f "$FILE" ]; then
  echo "Regular file exists: $FILE"
fi

$ ./file-test.sh

Regular file exists: /etc/passwd

Strings

String operators

Operator	Meaning	Example
`-z`	String is empty	`[ -z "$NAME" ]`
`-n`	String is not empty	`[ -n "$NAME" ]`
`=`	Strings are equal	`[ "$A" = "$B" ]`
`!=`	Strings are not equal	`[ "$A" != "$B" ]`

SERVICE="$1"

if [ -z "$SERVICE" ]; then
  echo "Usage: $0 service-name"
  exit 1
fi

$ ./check-service.sh

Usage: ./check-service.sh service-name

Numbers

Numeric comparison operators

Operator	Meaning	Example
`-eq`	Equal	`[ "$A" -eq "$B" ]`
`-ne`	Not equal	`[ "$A" -ne "$B" ]`
`-gt`	Greater than	`[ "$A" -gt "$B" ]`
`-ge`	Greater than or equal	`[ "$A" -ge "$B" ]`
`-lt`	Less than	`[ "$A" -lt "$B" ]`
`-le`	Less than or equal	`[ "$A" -le "$B" ]`

USE=94

if [ "$USE" -ge 90 ]; then
  echo "Disk critical: ${USE}%"
fi

$ ./disk-check.sh

Disk critical: 94%

Logic

Logic operators

You can combine conditions using logical operators.

Operator	Meaning	Example
`&&`	Run next command only if previous command succeeds	`mkdir backup && echo "created"`
`\|\|`	Run next command only if previous command fails	`systemctl is-active --quiet nginx \|\| echo "nginx down"`
`!`	Negates a condition	`if ! systemctl is-active --quiet nginx; then`

if [ -f "$FILE" ] && [ -s "$FILE" ]; then
  echo "File exists and is not empty"
fi

Arithmetic

Arithmetic operators

For arithmetic, Bash commonly uses (( ... )).

Operator	Meaning	Example
`+`	Add	`((total = a + b))`
`-`	Subtract	`((left = total - used))`
`*`	Multiply	`((size = count * 10))`
`/`	Divide	`((avg = total / count))`
`++`	Increment	`((count++))`

count=0
((count++))
echo "$count"

$ ./count.sh

Practical scripts

Example script: classify a path

#!/usr/bin/env bash

TARGET="$1"

if [ -z "$TARGET" ]; then
  echo "Usage: $0 path"
  exit 1
fi

if [ -f "$TARGET" ]; then
  echo "Regular file: $TARGET"
elif [ -d "$TARGET" ]; then
  echo "Directory: $TARGET"
elif [ -e "$TARGET" ]; then
  echo "Exists, but is not a regular file or directory: $TARGET"
else
  echo "Missing: $TARGET"
  exit 1
fi

$ ./classify-path.sh /etc/passwd

Regular file: /etc/passwd

Example script: disk threshold check

#!/usr/bin/env bash

USE="$1"

if [ -z "$USE" ]; then
  echo "Usage: $0 percentage"
  exit 1
fi

if [ "$USE" -ge 90 ]; then
  echo "[CRITICAL] disk usage is ${USE}%"
elif [ "$USE" -ge 80 ]; then
  echo "[WARN] disk usage is ${USE}%"
else
  echo "[OK] disk usage is ${USE}%"
fi

$ ./disk-threshold.sh 84

[WARN] disk usage is 84%

Common errors

Common Bash operator mistakes

Wrong	Why it breaks	Correct
`[-f "$FILE"]`	Missing spaces around brackets.	`[ -f "$FILE" ]`
`[ $FILE = test ]`	Unquoted variable can break if empty or contains spaces.	`[ "$FILE" = "test" ]`
`[ "$USE" > 90 ]`	String comparison, not numeric comparison.	`[ "$USE" -gt 90 ]`
`[ "$NAME" -eq "bob" ]`	`-eq` is for numbers, not strings.	`[ "$NAME" = "bob" ]`

$ ./broken.sh

./broken.sh: line 3: [-f: command not found

Quick reference

Bash operators quick reference

Category	Operators
Files	`-f`, `-d`, `-e`, `-x`, `-s`, `-r`, `-w`
Strings	`-z`, `-n`, `=`, `!=`
Numbers	`-eq`, `-ne`, `-gt`, `-ge`, `-lt`, `-le`
Logic	`&&`, `\|\|`, `!`
Arithmetic	`+`, `-`, `*`, `/`, `++`, `--`

Keep learning Bash

Decision helper

Which Bash operator should you use?

Need to check	Use	Example
File exists and is a regular file	`-f`	`[ -f "$file" ]`
Directory exists	`-d`	`[ -d "$path" ]`
String is empty	`-z`	`[ -z "$name" ]`
String is not empty	`-n`	`[ -n "$name" ]`
Numbers are equal	`-eq`	`[ "$count" -eq 10 ]`
Command succeeded	`$?` or direct `if command`	`if systemctl is-active --quiet nginx; then ...`

Output example

Example: combine file and string checks

#!/usr/bin/env bash

file="$1"

if [ -z "$file" ]; then
  echo "Usage: $0 /path/to/file"
  exit 1
fi

if [ -f "$file" ]; then
  echo "OK: file exists"
else
  echo "ERROR: not a regular file"
  exit 2
fi

Example output:

$ ./check-file.sh
Usage: ./check-file.sh /path/to/file

$ ./check-file.sh /var/log/messages
OK: file exists

FAQ

Frequently Asked Questions

What is the difference between -eq and = in Bash?

-eq compares numbers, while = compares strings inside test brackets.

Should I quote variables in Bash tests?

Yes. Quoting variables helps avoid errors when values are empty or contain spaces.

What does -z mean in Bash?

-z checks whether a string has zero length, meaning it is empty.

Can I use command results directly in if statements?

Yes. A common pattern is if command; then ... because Bash uses the command exit status.

$ practise_next --topic bash

Practise this next

Turn the guide into practice with a related quiz, builder, cheat sheet or learning path.

[1]Open the Bash Scripting HubFollow the main Bash learning path.[2]Try the Bash Script CheckerCheck simple Bash scripts and practise safer habits.[3]Read: Bash Functions ExplainedLearn how to organise scripts with functions.[4]Open the Bash Cheat SheetReview common Bash syntax and scripting patterns.