Bash Scripting Best Practices: Writing Scripts That Don't Bite

1
2
3

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

1
2

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Bad - breaks with spaces or special chars
rm -rf $path

# Good
rm -rf "$path"

# Even in conditionals
if [[ -d "$dir" ]]; then
    echo "Directory exists"
fi

1
2
3
4
5

# Ambiguous
echo "$foobar"

# Clear
echo "${foo}bar"

1
2
3
4
5
6
7
8

# Default if unset
name="${1:-default_name}"

# Default if unset or empty
name="${1:=default_name}"

# Error if unset
name="${1:?Error: name is required}"

1
2

readonly CONFIG_DIR="/etc/myapp"
readonly LOG_FILE="/var/log/myapp.log"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# Good structure
main() {
    setup
    process_files
    cleanup
}

setup() {
    echo "Setting up..."
}

process_files() {
    echo "Processing..."
}

cleanup() {
    echo "Cleaning up..."
}

# Run main at the end
main "$@"

1
2
3
4
5
6

process_file() {
    local filename="$1"
    local content
    content=$(cat "$filename")
    echo "$content"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

is_valid() {
    local value="$1"
    if [[ "$value" =~ ^[0-9]+$ ]]; then
        return 0  # Success/true
    else
        return 1  # Failure/false
    fi
}

if is_valid "$input"; then
    echo "Valid"
fi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Better - more features, fewer surprises
if [[ -f "$file" && "$name" == "test" ]]; then
    echo "Match"
fi

# String comparison
[[ "$a" == "$b" ]]   # Equal
[[ "$a" != "$b" ]]   # Not equal
[[ "$a" < "$b" ]]    # Less than (alphabetically)
[[ -z "$a" ]]        # Empty
[[ -n "$a" ]]        # Not empty

# Regex matching
if [[ "$email" =~ ^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$ ]]; then
    echo "Valid email"
fi

1
2
3
4
5
6
7

[[ -e "$path" ]]   # Exists
[[ -f "$path" ]]   # Is file
[[ -d "$path" ]]   # Is directory
[[ -r "$path" ]]   # Is readable
[[ -w "$path" ]]   # Is writable
[[ -x "$path" ]]   # Is executable
[[ -s "$path" ]]   # Is non-empty

1
2
3
4
5
6
7

# Use (( )) for math
if (( count > 10 )); then
    echo "Too many"
fi

(( count++ ))
(( total = a + b * c ))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Bad - breaks on spaces in filenames
for file in $(ls *.txt); do
    echo "$file"
done

# Good - handles spaces correctly
for file in *.txt; do
    [[ -e "$file" ]] || continue  # Skip if no matches
    echo "$file"
done

# Better - handles all edge cases
while IFS= read -r -d '' file; do
    echo "$file"
done < <(find . -name "*.txt" -print0)

1
2
3

while IFS= read -r line; do
    echo "Line: $line"
done < "$input_file"

1
2
3

while IFS= read -r line; do
    echo "Found: $line"
done < <(grep "pattern" file.txt)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

cleanup() {
    rm -rf "$temp_dir"
    echo "Cleaned up"
}

trap cleanup EXIT

temp_dir=$(mktemp -d)
# Script work here...
# cleanup runs automatically on exit

1
2

trap 'echo "Interrupted"; exit 1' INT TERM
trap 'echo "Error on line $LINENO"; exit 1' ERR

1
2
3
4
5
6

die() {
    echo "ERROR: $*" >&2
    exit 1
}

[[ -f "$config" ]] || die "Config file not found: $config"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Check argument count
if (( $# < 2 )); then
    echo "Usage: $0 <input> <output>" >&2
    exit 1
fi

# Validate file exists
input="$1"
[[ -f "$input" ]] || die "Input file not found: $input"

# Validate is a number
if ! [[ "$count" =~ ^[0-9]+$ ]]; then
    die "Count must be a number: $count"
fi

1
2

echo "Starting process..."           # Normal output (stdout)
echo "Warning: file missing" >&2     # Errors/warnings (stderr)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

readonly LOG_FILE="/var/log/myapp.log"

log() {
    local level="$1"
    shift
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $*" | tee -a "$LOG_FILE"
}

log INFO "Script started"
log ERROR "Something went wrong"

1
2
3
4
5
6
7

VERBOSE="${VERBOSE:-false}"

debug() {
    if [[ "$VERBOSE" == "true" ]]; then
        echo "DEBUG: $*" >&2
    fi
}

1
2
3
4
5
6
7

command_exists() {
    command -v "$1" &> /dev/null
}

if ! command_exists jq; then
    die "jq is required but not installed"
fi

1
2
3
4
5

if output=$(some_command 2>&1); then
    echo "Success: $output"
else
    echo "Failed: $output" >&2
fi

1
2
3

if ! timeout 30 long_running_command; then
    echo "Command timed out"
fi

1
2
3
4
5
6
7

# Create temp file
temp_file=$(mktemp)
trap 'rm -f "$temp_file"' EXIT

# Create temp directory
temp_dir=$(mktemp -d)
trap 'rm -rf "$temp_dir"' EXIT

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

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

# Constants
readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
readonly SCRIPT_NAME="$(basename "${BASH_SOURCE[0]}")"

# Logging
log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"; }
die() { echo "ERROR: $*" >&2; exit 1; }

# Usage
usage() {
    cat <<EOF
Usage: $SCRIPT_NAME [options] <input>

Options:
    -h, --help      Show this help
    -v, --verbose   Verbose output
    -o, --output    Output file

Example:
    $SCRIPT_NAME -v input.txt
EOF
}

# Parse arguments
VERBOSE=false
OUTPUT=""

while [[ $# -gt 0 ]]; do
    case "$1" in
        -h|--help)
            usage
            exit 0
            ;;
        -v|--verbose)
            VERBOSE=true
            shift
            ;;
        -o|--output)
            OUTPUT="$2"
            shift 2
            ;;
        -*)
            die "Unknown option: $1"
            ;;
        *)
            break
            ;;
    esac
done

# Validate arguments
(( $# >= 1 )) || { usage; exit 1; }
INPUT="$1"
[[ -f "$INPUT" ]] || die "File not found: $INPUT"

# Main logic
main() {
    log "Processing $INPUT..."
    
    # Do work here
    
    log "Done"
}

main "$@"