Bash Script Validation: File Testing, String Checking and Input Validation

Ever wondered how senior developers seem to have magical powers when it comes to bash? They write scripts that validate data, find patterns like Sherlock Holmes, and handle files with surgical precision. The secret isn’t years of experience — it’s mastering the advanced features that most people never learn.

Think of these advanced bash features as upgrading from a basic toolkit to a professional laboratory. You’ll go from “I hope this works” to “I know exactly what this will do” — and your scripts will become bulletproof, intelligent, and impressively professional.

Why Should You Master These Advanced Features?

🚀 Immediate Benefits:

• Write scripts that validate inputs like a professional application
• Find and process data with pattern-matching superpowers
• Handle files and directories with surgical precision
• Create bulletproof automation that handles edge cases gracefully
• Build scripts colleagues will actually trust in production environments

File and Directory Testing: Your Digital Sherlock Holmes

File testing operators are like having X-ray vision for your file system. Instead of blindly running commands and hoping files exist, you can inspect, validate, and make intelligent decisions.

Essential File Test Operators

# Check if items exist and their types
if [ -f "config.txt" ]; then
    echo "✅ Config file exists"
fi
if [ -d "/backup" ]; then
    echo "✅ Backup directory exists"
else
    echo "📁 Creating backup directory..."
    mkdir -p "/backup"
fi
if [ -x "deploy.sh" ]; then
    echo "✅ Deploy script is executable"
else
    echo "🔧 Making deploy script executable..."
    chmod +x deploy.sh
fi

Real-World File Testing Examples

1. Intelligent Backup Validator:

validate_backup() {
    local backup_file=$1
    
    # Check if backup file was provided
    if [ -z "$backup_file" ]; then
        echo "❌ Error: Backup file path required"
        return 1
    fi
    
    # Check if backup exists and is a regular file
    if [ ! -f "$backup_file" ]; then
        echo "❌ Backup file doesn't exist: $backup_file"
        return 1
    fi
    
    # Check if file is not empty
    if [ ! -s "$backup_file" ]; then
        echo "⚠️  WARNING: Backup file is empty!"
        return 1
    fi
    
    # Check if file is readable
    if [ ! -r "$backup_file" ]; then
        echo "❌ Cannot read backup file (permission denied)"
        return 1
    fi
    
    # Check file age (warn if older than 24 hours)
    if [ $(find "$backup_file" -mtime +1 2>/dev/null | wc -l) -gt 0 ]; then
        echo "⚠️  WARNING: Backup is older than 24 hours"
    fi
    
    # Get file size and validate it's reasonable
    local file_size=$(stat -f%z "$backup_file" 2>/dev/null || stat -c%s "$backup_file" 2>/dev/null)
    if [ $file_size -lt 1024 ]; then
        echo "⚠️  WARNING: Backup file seems very small (${file_size} bytes)"
    else
        echo "✅ Backup validation passed"
        echo "📊 Backup size: $(numfmt --to=iec $file_size)"
    fi
}

# Usage
validate_backup "/backups/database_20240115.sql.gz"

String Testing and Validation

validate_user_input() {
    local username=$1
    local email=$2
    
    # Check if strings are not empty
    if [ -z "$username" ]; then
        echo "❌ Username cannot be empty"
        return 1
    fi
    
    if [ -z "$email" ]; then
        echo "❌ Email cannot be empty"
        return 1
    fi
    
    # Check string length
    if [ ${#username} -lt 3 ]; then
        echo "❌ Username must be at least 3 characters"
        return 1
    fi
    
    echo "✅ Input validation passed"
    return 0
}

Regular Expressions: Pattern-Matching Superpowers

Regex in bash lets you find, validate, and extract data with surgical precision. It’s like having a smart search that understands patterns, not just exact matches.

Basic Regex with =~ Operator

# Must use [[ ]] for regex matching
validate_data() {
    local input=$1
    
    # Check if input is a number
    if [[ $input =~ ^[0-9]+$ ]]; then
        echo "✅ '$input' is a valid number"
    elif [[ $input =~ ^[a-zA-Z]+$ ]]; then
        echo "✅ '$input' contains only letters"
    elif [[ $input =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
        echo "✅ '$input' looks like a valid email"
    else
        echo "❌ '$input' doesn't match any expected pattern"
    fi
}

# Test different inputs
validate_data "12345"          # Number
validate_data "HelloWorld"     # Letters only
validate_data "user@email.com" # Email

Real-World Regex Examples

1. Data Validation and Extraction:

process_user_data() {
    local data_file=$1
    local valid_count=0
    local invalid_count=0
    
    echo "🔍 Processing user data from $data_file..."
    
    while IFS= read -r line; do
        # Skip empty lines and comments
        [[ $line =~ ^[[:space:]]*$ ]] && continue
        [[ $line =~ ^[[:space:]]*# ]] && continue
        
        # Validate email format
        if [[ $line =~ ^([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})$ ]]; then
            local username="${BASH_REMATCH[1]}"
            local domain="${BASH_REMATCH[2]}"
            
            echo "✅ Valid: $username @ $domain"
            ((valid_count++))
        else
            echo "❌ Invalid email format: $line"
            ((invalid_count++))
        fi
    done < "$data_file"
    
    echo ""
    echo "📊 Processing complete:"
    echo "   Valid emails: $valid_count"
    echo "   Invalid emails: $invalid_count"
}

Advanced Variable Management and Environment Control

Export and Environment Variables

setup_deployment_environment() {
    local environment=$1
    
    # Make variables available to child processes
    export APP_ENV="$environment"
    export LOG_LEVEL="INFO"
    export DATABASE_URL="postgresql://localhost:5432/myapp_${environment}"
    
    # Set environment-specific configurations
    case $environment in
        "development")
            export DEBUG="true"
            export API_TIMEOUT="30"
            ;;
        "production")
            export DEBUG="false"
            export API_TIMEOUT="10"
            export MONITORING_ENABLED="true"
            ;;
    esac
    
    echo "🔧 Environment configured for: $environment"
    echo "   APP_ENV: $APP_ENV"
    echo "   DEBUG: $DEBUG"
    echo "   DATABASE_URL: $DATABASE_URL"
}

cleanup_environment() {
    # Remove sensitive variables after use
    unset DATABASE_URL
    unset API_SECRET_KEY
    unset ADMIN_PASSWORD
    
    echo "🧹 Sensitive environment variables cleared"
}

Aliases and Command Shortcuts

No more typing of long commands for a single use case, use alias and make it faster. 

setup_development_aliases() {
    # Productivity aliases
    alias ll='ls -la --color=auto'
    alias la='ls -A'
    alias l='ls -CF'
    
    # Git shortcuts
    alias gs='git status'
    alias ga='git add'
    alias gc='git commit -m'
    alias gp='git push origin main'
    alias gl='git log --oneline --graph'
    
    # Docker shortcuts
    alias dps='docker ps'
    alias dimg='docker images'
    alias dcup='docker-compose up -d'
    alias dcdown='docker-compose down'
    
    # System shortcuts
    alias df='df -h'
    alias du='du -h'
    alias free='free -h'
    
    echo "🚀 Development aliases loaded!"
    echo "💡 Tip: Add these to your ~/.bashrc to make them permanent"
}

# Load aliases
setup_development_aliases

Return Codes and Error Handling

Do you know whether your command executed successfully or failed miserably?

robust_deployment() {
    local app_name=$1
    
    echo "🚀 Starting deployment of $app_name..."
    
    # Step 1: Build application
    echo "📦 Building application..."
    if ! ./build.sh; then
        echo "❌ Build failed (exit code: $?)"
        return 1
    fi
    
    # Step 2: Run tests
    echo "🧪 Running tests..."
    if ! ./run_tests.sh; then
        echo "❌ Tests failed (exit code: $?)"
        return 2
    fi
    
    # Step 3: Deploy
    echo "🚀 Deploying..."
    if ! ./deploy.sh "$app_name"; then
        echo "❌ Deployment failed (exit code: $?)"
        return 3
    fi
    
    # Step 4: Health check
    echo "🏥 Running health check..."
    if ! ./health_check.sh; then
        echo "❌ Health check failed (exit code: $?)"
        echo "🔄 Rolling back..."
        ./rollback.sh
        return 4
    fi
    
    echo "🎉 Deployment successful!"
    return 0
}

# Use the function with proper error handling
if robust_deployment "myapp"; then
    echo "✅ All systems go!"
else
    exit_code=$?
    case $exit_code in
        1) echo "💔 Fix build issues and try again" ;;
        2) echo "🧪 Fix failing tests and try again" ;;
        3) echo "🚀 Check deployment configuration" ;;
        4) echo "🏥 Application health check failed" ;;
    esac
    exit $exit_code
fi

Working with Positional Arguments Like a Pro

Automate deployment to different environments based on the positional argumgents given to the script

#!/bin/bash
# Advanced argument handling

show_usage() {
    echo "Usage: $0 <action> <environment> [options]"
    echo ""
    echo "Actions:"
    echo "  deploy    Deploy the application"
    echo "  rollback  Rollback to previous version"
    echo "  status    Check application status"
    echo ""
    echo "Environments:"
    echo "  dev, staging, prod"
    echo ""
    echo "Options:"
    echo "  --force   Force action without confirmation"
    echo "  --verbose Enable detailed output"
}
# Parse command line arguments
ACTION=$1
ENVIRONMENT=$2
FORCE=false
VERBOSE=false
# Parse options
shift 2  # Remove first two arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --force)
            FORCE=true
            shift
            ;;
        --verbose)
            VERBOSE=true
            shift
            ;;
        *)
            echo "❌ Unknown option: $1"
            show_usage
            exit 1
            ;;
    esac
done
# Validate required arguments
if [ -z "$ACTION" ] || [ -z "$ENVIRONMENT" ]; then
    echo "❌ Missing required arguments"
    show_usage
    exit 1
fi
echo "🎯 Action: $ACTION"
echo "🌍 Environment: $ENVIRONMENT"
echo "⚡ Force: $FORCE"
echo "📝 Verbose: $VERBOSE"

TLDR Cheat Sheet

🔧 File Testing Essentials:

• -f file - Check if regular file exists
• -d directory - Check if directory exists
• -x file - Check if file is executable
• -r file - Check if file is readable
• -w file - Check if file is writable
• -s file - Check if file is not empty
• ! - Reverse test result: [ ! -f file ]

🔧 String Testing Essentials:

• -z string - Check if string is empty
• -n string - Check if string is not empty
• [ "$a" = "$b" ] - String equality
• [[ $var =~ pattern ]] - Regex pattern matching

🔧 Regex Essentials:

• ^ - Start of string, `# The Secret Weapons That Separate Bash Beginners from Command Line Legends

• [0-9]+ - One or more digits
• [a-zA-Z] - Any letter
• * - Zero or more, + - One or more
• ${BASH_REMATCH[1]} - Capture groups in regex

🔧 Advanced Features:

• export VAR=value - Make variable available to child processes
• unset variable - Remove variable from environment
• alias name='command' - Create command shortcuts
• echo $? - Check exit code of last command
• $1 $2 $3 - Positional arguments