Bash Basics #3: Control Structures in Bash

┌─────────────────────────────────────────────────────────────┐
│                 CONTROL FLOW OF IF-ELIF-ELSE                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  [ Condition 1 true (Exit 0)? ]                             │
│         ├── YES ──> Execute THEN block 1 ──┐                │
│         │                                  │                │
│         └── NO                              │                │
│              │                              │                │
│              ▼                              │                │
│  [ Condition 2 true (Exit 0)? ]            │                │
│         ├── YES ──> Execute ELIF block 2 ──┤                │
│         │                                  │                │
│         └── NO                              │                │
│              │                              │                │
│              ▼                              │                │
│  [ Execute ELSE fallback block ] ───────────┤                │
│                                            ▼                │
│                                    [ Continue after FI ]    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

if [[ condition1 ]]; then
    # Executed when condition 1 is true
elif [[ condition2 ]]; then
    # Executed when condition 2 is true
else
    # Fallback: Executed when no condition is met
fi

if [[ $age -ge 18 ]]
then
    echo "Of legal age"
fi

┌─────────────────────────────────────────────────────────────┐
│                 COMPARISON: [[ ... ]] VS. [ ... ]           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Property                 POSIX [ ... ]  Bash [[ ... ]]    │
│   ───────────────────────────────────────────────────────   │
│   Word Splitting           YES (crash!)   NO (safe)         │
│   Regex Matching (=~)      NO             YES               │
│   Pattern Matching         NO             YES (*.txt)       │
│   Logical Operators        -a / -o        && / ||           │
│   String Comparisons       \< / \>        < / >             │
│   Type of construct        External/Builtin Shell keyword   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

       echo "Access granted."

       echo "This is a compressed tar archive."

       echo "Valid IP format."

if (( a >= 18 )); then
    echo "Of legal age via arithmetic evaluation."
fi

case "$VARIABLE" in
    pattern1)
        # Commands for pattern1
        ;;
    pattern2|pattern3)
        # Multiple patterns linked with pipe (|)
        ;;
    *)
        # Default branch (equivalent to 'else')
        ;;
esac

#!/usr/bin/env bash
set -euo pipefail

ACTION="${1:-status}"
SERVICE="${2:-nginx}"

case "$ACTION" in
    start)
        echo "Starting service $SERVICE..."
        sudo systemctl start "$SERVICE"
        ;;
    stop)
        echo "Stopping service $SERVICE..."
        sudo systemctl stop "$SERVICE"
        ;;
    restart|reload)
        echo "Reloading service $SERVICE..."
        sudo systemctl restart "$SERVICE"
        ;;
    status)
        sudo systemctl status "$SERVICE" --no-pager
        ;;
    *)
        echo "Error: Unknown action '$ACTION'!" >&2
        echo "Usage: $0 {start|stop|restart|status} [service-name]" >&2
        exit 1
        ;;
esac

# Iterate over an indexed array
SERVERS=("web01" "web02" "db01" "cache01")

for server in "${SERVERS[@]}"; do
    echo "Checking reachability of $server..."
done

# Count from 1 to 5
for i in {1..5}; do
    echo "Iteration: $i"
done

# Count in steps of 5 from 0 to 20 ({start..end..step}):
for port in {8080..8090..2}; do
    echo "Testing port $port..."
done

for (( i=0; i<10; i++ )); do
    echo "Index: $i"
done

# Process all log files in /var/log
for logfile in /var/log/*.log; do
    # Important: Check if the file actually exists (in case no .log files are present)
    [[ -f "$logfile" ]] || continue
    
    echo "Compressing: $logfile..."
    gzip -k "$logfile"
done

counter=1

while [[ $counter -le 5 ]]; do
    echo "Step $counter of 5"
    (( counter++ ))
done

#!/usr/bin/env bash
set -euo pipefail

HOSTS_FILE="/etc/hosts"

# IFS= prevents trimming of leading whitespace
# -r prevents misinterpretation of backslashes
while IFS= read -r line || [[ -n "$line" ]]; do
    # Skip empty lines and comment lines:
    [[ -z "$line" || "$line" =~ ^# ]] && continue
    
    echo "Entry: $line"
done < "$HOSTS_FILE"

# Example: Search for a file and terminate the loop on the first match
for file in /tmp/reports/*; do
    [[ -f "$file" ]] || continue
    
    if [[ "$file" == *"critical.log"* ]]; then
        echo "Critical file found: $file!"
        break  # Terminate loop immediately
    fi
done

#!/usr/bin/env bash
set -euo pipefail

PS3="Please choose an option (1-4): "
options=("System Status" "Show Disk Usage" "Restart Nginx" "Quit")

select opt in "${options[@]}"; do
    case "$opt" in
        "System Status")
            uptime
            ;;
        "Show Disk Usage")
            df -h /
            ;;
        "Restart Nginx")
            sudo systemctl restart nginx
            echo "Nginx has been restarted."
            ;;
        "Quit")
            echo "Goodbye!"
            break
            ;;
        *)
            echo "Invalid input! Please enter a number between 1 and 4."
            ;;
    esac
done

#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

IP="${1:?Please provide an IP address as parameter!}"

# Regex for 4 number blocks from 0-255
REGEX='^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'

if [[ "$IP" =~ $REGEX ]]; then
    echo "OK: '$IP' is a formally valid IPv4 address."
    exit 0
else
    echo "ERROR: '$IP' is not a valid IPv4 address!" >&2
    exit 1
fi