File Test Operators

Beginner ~20 min read

File test operators are essential for any script that works with files and directories. They let you check if files exist, verify permissions, determine file types, and compare files. These operators are used constantly in real-world shell scripts for validation and conditional logic!

Existence and Permission Tests

The most common file tests check whether files exist and what permissions they have. These are the foundation of defensive scripting!

#!/bin/bash
# File Test Operators in Bash

echo "=== File Test Operators ==="
echo ""

# Create test files for demonstration
test_file="/tmp/test_file.txt"
test_dir="/tmp/test_dir"
echo "Hello World" > "$test_file"
mkdir -p "$test_dir"

echo "Test file: $test_file"
echo "Test directory: $test_dir"
echo ""

# File existence tests
echo "--- Existence Tests ---"
if [[ -e "$test_file" ]]; then
    echo "-e: '$test_file' exists"
fi

if [[ -f "$test_file" ]]; then
    echo "-f: '$test_file' is a regular file"
fi

if [[ -d "$test_dir" ]]; then
    echo "-d: '$test_dir' is a directory"
fi

if [[ ! -e "/nonexistent" ]]; then
    echo "-e: '/nonexistent' does not exist"
fi
echo ""

# Permission tests
echo "--- Permission Tests ---"
if [[ -r "$test_file" ]]; then
    echo "-r: '$test_file' is readable"
fi

if [[ -w "$test_file" ]]; then
    echo "-w: '$test_file' is writable"
fi

# Make file executable for demo
chmod +x "$test_file"
if [[ -x "$test_file" ]]; then
    echo "-x: '$test_file' is executable"
fi
echo ""

# Size tests
echo "--- Size Tests ---"
if [[ -s "$test_file" ]]; then
    echo "-s: '$test_file' has size > 0"
fi

empty_file="/tmp/empty_file.txt"
touch "$empty_file"
if [[ ! -s "$empty_file" ]]; then
    echo "-s: '$empty_file' is empty (size = 0)"
fi

# Cleanup
rm -f "$test_file" "$empty_file"
rmdir "$test_dir" 2>/dev/null

Output

Click Run to execute your code

Existence Operators

Operator	Description	Example
`-e`	File exists (any type)	`[[ -e "$file" ]]`
`-f`	Exists and is a regular file	`[[ -f "$file" ]]`
`-d`	Exists and is a directory	`[[ -d "$dir" ]]`
`-L` or `-h`	Exists and is a symbolic link	`[[ -L "$link" ]]`

Permission Operators

Operator	Description	Example
`-r`	File is readable	`[[ -r "$file" ]]`
`-w`	File is writable	`[[ -w "$file" ]]`
`-x`	File is executable	`[[ -x "$script" ]]`
`-s`	File exists and size > 0	`[[ -s "$file" ]]`

Best Practice: Always check if a file exists before trying to read or modify it. Use [[ -f "$file" ]] && cat "$file" to avoid errors when the file doesn't exist.

File Type Tests

Beyond regular files and directories, Unix has several special file types. These operators help you identify them.

#!/bin/bash
# File Type Tests in Bash

echo "=== File Type Tests ==="
echo ""

# Create various file types for testing
regular_file="/tmp/regular.txt"
directory="/tmp/test_directory"
symlink="/tmp/symlink"

echo "Creating test files..."
echo "content" > "$regular_file"
mkdir -p "$directory"
ln -sf "$regular_file" "$symlink"
echo ""

echo "Test files created:"
echo "  Regular file: $regular_file"
echo "  Directory: $directory"
echo "  Symlink: $symlink -> $regular_file"
echo ""

echo "--- File Type Detection ---"

# Regular file
if [[ -f "$regular_file" ]]; then
    echo "-f '$regular_file': Regular file"
fi

# Directory
if [[ -d "$directory" ]]; then
    echo "-d '$directory': Directory"
fi

# Symbolic link
if [[ -L "$symlink" ]]; then
    echo "-L '$symlink': Symbolic link"
fi

# Note: -f follows symlinks, so symlink to file returns true
if [[ -f "$symlink" ]]; then
    echo "-f '$symlink': File (follows symlink)"
fi
echo ""

echo "--- Special File Types ---"
# Block device (typically /dev/sda or similar)
if [[ -b "/dev/null" ]]; then
    echo "-b: /dev/null is NOT a block device"
else
    echo "-b: /dev/null is not a block device (it's character device)"
fi

# Character device
if [[ -c "/dev/null" ]]; then
    echo "-c: /dev/null is a character device"
fi

# Named pipe check (create one for demo)
pipe="/tmp/test_pipe"
mkfifo "$pipe" 2>/dev/null
if [[ -p "$pipe" ]]; then
    echo "-p: '$pipe' is a named pipe (FIFO)"
fi
rm -f "$pipe"

# Cleanup
rm -f "$regular_file" "$symlink"
rmdir "$directory" 2>/dev/null

Output

Click Run to execute your code

Operator	Description	Common Examples
`-f`	Regular file	Scripts, text files, configs
`-d`	Directory	/home, /tmp, /var
`-L`	Symbolic link	/usr/bin/python -> python3
`-b`	Block device	/dev/sda, /dev/nvme0n1
`-c`	Character device	/dev/null, /dev/tty
`-p`	Named pipe (FIFO)	Inter-process communication
`-S`	Socket	/var/run/docker.sock

Pro Tip: The -f operator follows symbolic links. To check if something is a symlink regardless of what it points to, use -L. To check if a symlink points to a valid target, combine them: [[ -L "$link" && -e "$link" ]].

File Comparison Operators

These operators compare files by modification time and identity (same inode). Perfect for backup scripts and synchronization!

#!/bin/bash
# File Comparison Tests in Bash

echo "=== File Comparison Tests ==="
echo ""

# Create test files
file1="/tmp/file1.txt"
file2="/tmp/file2.txt"
file3="/tmp/file3.txt"

echo "Creating test files..."
echo "content" > "$file1"
sleep 1  # Ensure different timestamps
echo "content" > "$file2"
echo "different" > "$file3"

# Create a hard link (same inode)
hardlink="/tmp/hardlink.txt"
ln "$file1" "$hardlink"
echo ""

echo "Files created:"
echo "  file1: $file1"
echo "  file2: $file2 (created after file1)"
echo "  file3: $file3 (different content)"
echo "  hardlink: $hardlink (hard link to file1)"
echo ""

echo "--- Timestamp Comparisons ---"
# Newer than
if [[ "$file2" -nt "$file1" ]]; then
    echo "-nt: file2 is newer than file1"
fi

# Older than
if [[ "$file1" -ot "$file2" ]]; then
    echo "-ot: file1 is older than file2"
fi
echo ""

echo "--- Identity Test (Same File) ---"
# Same file (by inode)
if [[ "$file1" -ef "$hardlink" ]]; then
    echo "-ef: file1 and hardlink are the same file (same inode)"
fi

if [[ ! "$file1" -ef "$file2" ]]; then
    echo "-ef: file1 and file2 are NOT the same file"
fi
echo ""

echo "--- Practical Example: Backup Check ---"
source_file="$file1"
backup_file="$file2"

if [[ "$source_file" -nt "$backup_file" ]]; then
    echo "Source is newer - backup needed!"
else
    echo "Backup is up to date"
fi

# Cleanup
rm -f "$file1" "$file2" "$file3" "$hardlink"

Output

Click Run to execute your code

Operator	Description	Use Case
`file1 -nt file2`	file1 is newer than file2	Backup/sync decisions
`file1 -ot file2`	file1 is older than file2	Cache invalidation
`file1 -ef file2`	Same file (same device & inode)	Hard link detection

Caution: The -nt and -ot operators return false if either file doesn't exist. Always check existence first with -e if you're not sure the files exist!

String Length Tests

While not strictly file operators, -z and -n are often used alongside file tests to check variable values.

# -z: String is zero length (empty)
filename=""
if [[ -z "$filename" ]]; then
    echo "No filename provided"
fi

# -n: String is non-zero length (not empty)
filename="script.sh"
if [[ -n "$filename" ]]; then
    echo "Filename: $filename"
fi

# Common pattern: validate before using
if [[ -n "$1" && -f "$1" ]]; then
    echo "Processing file: $1"
else
    echo "Please provide a valid filename"
fi

Remember:

-z = Zero length (empty string)
-n = Non-zero length (has content)

Common Mistakes

1. Forgetting to quote the filename

# Wrong - breaks on spaces or special chars
file="my file.txt"
[[ -f $file ]]   # Error!

# Correct - always quote
[[ -f "$file" ]]  # Works correctly

2. Confusing -e and -f

# -e returns true for directories too
[[ -e "/tmp" ]]  # True (exists)
[[ -f "/tmp" ]]  # False (not a regular file)

# Use -f when you specifically need a regular file
# Use -e when any file type is acceptable

3. Not checking existence before operations

# Wrong - may fail silently or with error
cat "$config_file"

# Correct - check first
if [[ -f "$config_file" ]]; then
    cat "$config_file"
else
    echo "Config file not found!"
    exit 1
fi

4. Using -nt/-ot without checking existence

# Risky - returns false if file doesn't exist
[[ "$backup" -nt "$source" ]]

# Safer - verify both exist
if [[ -f "$backup" && -f "$source" ]]; then
    [[ "$backup" -nt "$source" ]] && echo "Backup is current"
fi

Exercise: File Validation Script

Task: Create a comprehensive file validation script!

Requirements:

Check if a file path was provided (not empty)
Verify the file exists
Check if it's a regular file (not a directory)
Verify it's readable
Check if it's not empty (size > 0)
Report all findings

Show Solution

#!/bin/bash
# File Validation Script

file="$1"  # Get filename from argument

echo "=== File Validation Report ==="
echo ""

# Check 1: Path provided?
if [[ -z "$file" ]]; then
    echo "ERROR: No file path provided"
    echo "Usage: $0 "
    exit 1
fi
echo "File: $file"
echo ""

# Check 2: Exists?
echo -n "Exists: "
if [[ -e "$file" ]]; then
    echo "YES"
else
    echo "NO - File not found!"
    exit 1
fi

# Check 3: Regular file?
echo -n "Regular file: "
if [[ -f "$file" ]]; then
    echo "YES"
else
    echo "NO (might be directory or special file)"
fi

# Check 4: Readable?
echo -n "Readable: "
if [[ -r "$file" ]]; then
    echo "YES"
else
    echo "NO - Permission denied"
fi

# Check 5: Non-empty?
echo -n "Has content: "
if [[ -s "$file" ]]; then
    echo "YES (size > 0)"
else
    echo "NO (empty file)"
fi

# Check 6: Writable?
echo -n "Writable: "
if [[ -w "$file" ]]; then
    echo "YES"
else
    echo "NO"
fi

echo ""
echo "Validation complete!"

Summary

Existence: -e (any), -f (file), -d (directory), -L (symlink)
Permissions: -r (readable), -w (writable), -x (executable)
Size: -s (size > 0)
Types: -b (block), -c (char), -p (pipe), -S (socket)
Comparison: -nt (newer), -ot (older), -ef (same file)
Strings: -z (empty), -n (not empty)
Always Quote: Use [[ -f "$file" ]] to handle spaces and special characters

What's Next?

Congratulations! You've completed the Operators & Arithmetic module. You now know how to perform calculations, compare values, combine conditions, and test files. Next, we'll dive into Control Flow with if statements, case statements, and loops to put all these operators to work!

Previous Logical Operators

Next If Statements

Existence and Permission Tests

Existence Operators

Permission Operators

File Type Tests

File Comparison Operators

String Length Tests

Common Mistakes

1. Forgetting to quote the filename

2. Confusing -e and -f

3. Not checking existence before operations

4. Using -nt/-ot without checking existence

Exercise: File Validation Script

Summary

What's Next?

Enjoying these tutorials?