Essential Bash Variables for Every Script

1
#!/usr/bin/env bash
2

3
# $BASH_SOURCE gives you the full path to this script
4
SCRIPT_PATH="$BASH_SOURCE"
5
echo "Full path: $SCRIPT_PATH"
6
# Output: /home/user/scripts/my_script.sh
7

8
# Use basename to strip the directory and keep just the filename
9
SCRIPT_NAME="$(basename "$BASH_SOURCE")"
10
echo "Script name: $SCRIPT_NAME"
11
# Output: my_script.sh
12

13
# Here's a practical use case: building a help menu
14
cat <<EOF
15
Usage: $SCRIPT_NAME [OPTIONS]
16

17
Options:
18
  -h, --help     Show this help message
19
  -v, --version  Show version information
20
EOF

1
#!/usr/bin/env bash
2

3
# Method 1: Explicit check using $?
4
ls /nonexistent_directory
5
if [[ $? -ne 0 ]]; then
6
  echo "Error: Directory does not exist"
7
  exit 1
8
fi
9

10
# Method 2: Cleaner approach test the command directly
11
# If ls succeeds, run the 'then' block. If it fails, run 'else'
12
if ls /home; then
13
  echo "Directory exists"
14
else
15
  echo "Directory does not exist"
16
fi
17

18
# Method 3: One-liner with logical operators
19
# && means "run this if the previous command succeeded"
20
# || means "run this if the previous command failed"
21
ls /home && echo "Success!" || echo "Failed!"
22

23
# Method 4: Handle specific error codes
24
# Some commands return different numbers for different errors
25
grep "pattern" file.txt
26
case $? in
27
  0) echo "Pattern found";;
28
  1) echo "Pattern not found";;
29
  2) echo "File error or syntax problem";;
30
  *) echo "Unknown error";;
31
esac

1
#!/usr/bin/env bash
2

3
# Individual arguments are numbered: $1, $2, $3, etc.
4
echo "First argument: $1"
5
echo "Second argument: $2"
6
echo "Third argument: $3"
7
# Run like: ./script.sh hello world test
8
# Output: hello, world, test
9

10
# Count how many arguments were passed
11
echo "Total arguments: ${#@}"
12

13
# Loop through all arguments
14
# $@ treats each argument separately, which is usually what you want
15
echo -e "\nProcessing all arguments:"
16
for arg in "$@"; do
17
  echo "  - $arg"
18
done
19

20
# The difference between $@ and $*
21
# This matters when your arguments contain spaces
22
function demo_at {
23
  # Each argument stays separate
24
  printf '@: [%s]\n' "$@"
25
}
26

27
function demo_star {
28
  # All arguments merge into one string
29
  printf '*: [%s]\n' "$*"
30
}
31

32
echo -e "\nDifference between \$@ and \$*:"
33
demo_at "arg one" "arg two"    # Prints: @: [arg one] and @: [arg two]
34
demo_star "arg one" "arg two"  # Prints: *: [arg one arg two] (all together)
35

36
# Real-world example: A function that processes files
37
function process_files() {
38
  # First, make sure we got at least one file
39
  if [[ ${#@} -eq 0 ]]; then
40
    echo "Error: No files specified"
41
    echo "Usage: process_files file1 file2 ..."
42
    return 1
43
  fi
44

45
  # Process each file
46
  for file in "$@"; do
47
    if [[ -f "$file" ]]; then
48
      echo "Processing: $file"
49
      # Your actual file processing logic goes here
50
      # wc -l "$file"  # Example: count lines
51
    else
52
      echo "Warning: File not found: $file"
53
    fi
54
  done
55
}
56

57
# You'd call it like this:
58
# process_files report.txt data.csv notes.md

1
#!/usr/bin/env bash
2

3
# Root check: A common pattern for admin scripts
4
# Root user always has UID 0
5
if [[ $EUID -eq 0 ]]; then
6
  echo "Running with root privileges"
7
  # Safe to do system-level stuff here
8
else
9
  echo "Running as regular user (UID: $UID)"
10
  echo "Some operations may require sudo"
11
  # Maybe prompt for sudo, or just warn and continue
12
fi
13

14
# Build paths specific to the current user
15
# This is useful for multi-user systems
16
USER_CACHE_DIR="/run/user/$UID/cache"
17
echo "User cache directory: $USER_CACHE_DIR"
18
# Example: /run/user/1000/cache
19

20
# Practical example: Create a temp directory that's unique per user
21
# This prevents conflicts when multiple users run your script
22
function create_user_temp() {
23
  local temp_dir="/tmp/myapp-$UID"
24

25
  if [[ ! -d "$temp_dir" ]]; then
26
    mkdir -p "$temp_dir"
27
    echo "Created temp directory: $temp_dir"
28
  fi
29

30
  echo "$temp_dir"
31
}
32

33
# Now each user gets their own isolated temp space
34
TEMP_DIR=$(create_user_temp)
35
echo "Using temp directory: $TEMP_DIR"
36
# User 1000: /tmp/myapp-1000
37
# User 1001: /tmp/myapp-1001

1
#!/usr/bin/env bash
2

3
# Set XDG variables if they're not already set
4
# The syntax ${VAR:=default} means "use VAR if it exists, otherwise use default"
5
export "${XDG_CONFIG_HOME:=$HOME/.config}"        # Config files
6
export "${XDG_CACHE_HOME:=$HOME/.cache}"          # Temporary cache data
7
export "${XDG_DATA_HOME:=$HOME/.local/share}"    # Application data
8
export "${XDG_STATE_HOME:=$HOME/.local/state}"   # State files (logs, history, etc.)
9

10
# Now build your app's specific directories
11
APP_NAME="myapp"
12
APP_CONFIG_DIR="$XDG_CONFIG_HOME/$APP_NAME"  # ~/.config/myapp
13
APP_CACHE_DIR="$XDG_CACHE_HOME/$APP_NAME"    # ~/.cache/myapp
14
APP_DATA_DIR="$XDG_DATA_HOME/$APP_NAME"      # ~/.local/share/myapp
15

16
# Create these directories if they don't exist yet
17
function initialize_app_directories() {
18
  mkdir -p "$APP_CONFIG_DIR"
19
  mkdir -p "$APP_CACHE_DIR"
20
  mkdir -p "$APP_DATA_DIR"
21

22
  echo "Initialized application directories:"
23
  echo "  Config: $APP_CONFIG_DIR"
24
  echo "  Cache:  $APP_CACHE_DIR"
25
  echo "  Data:   $APP_DATA_DIR"
26
}
27

28
initialize_app_directories
29

30
# Example: Save settings to the config directory
31
function save_config() {
32
  local config_file="$APP_CONFIG_DIR/settings.conf"
33

34
  cat > "$config_file" <<EOF
35
# Application settings
36
debug_mode=false
37
log_level=info
38
max_connections=100
39
EOF
40

41
  echo "Saved config to: $config_file"
42
}
43

44
# Example: Load settings from the config directory
45
function load_config() {
46
  local config_file="$APP_CONFIG_DIR/settings.conf"
47

48
  if [[ -f "$config_file" ]]; then
49
    # Source the config file to load variables
50
    source "$config_file"
51
    echo "Loaded config from: $config_file"
52
    echo "Debug mode: $debug_mode"
53
    echo "Log level: $log_level"
54
  else
55
    echo "Config file not found: $config_file"
56
    return 1
57
  fi
58
}
59

60
save_config
61
load_config

1
#!/usr/bin/env bash
2

3
# Strict mode: exit on errors, undefined variables, and pipe failures
4
set -euo pipefail
5

6
# Set up XDG directories with sensible defaults
7
export "${XDG_CONFIG_HOME:=$HOME/.config}"
8
export "${XDG_CACHE_HOME:=$HOME/.cache}"
9
export "${XDG_DATA_HOME:=$HOME/.local/share}"
10

11
# Grab script info using the variables we learned about
12
SCRIPT_NAME="$(basename "$BASH_SOURCE")"
13
SCRIPT_DIR="$(cd "$(dirname "$BASH_SOURCE")" && pwd)"
14
APP_NAME="myapp"
15

16
# Build our application's directory structure
17
APP_CONFIG_DIR="$XDG_CONFIG_HOME/$APP_NAME"
18
APP_CACHE_DIR="$XDG_CACHE_HOME/$APP_NAME"
19
APP_LOG_FILE="$APP_CACHE_DIR/app.log"
20

21
# ANSI color codes for pretty output
22
RED='\033[0;31m'
23
GREEN='\033[0;32m'
24
YELLOW='\033[1;33m'
25
NC='\033[0m'  # Reset to no color
26

27
# Simple logging function with timestamps
28
# Usage: log "INFO" "Something happened"
29
function log() {
30
  local level="$1"
31
  shift
32
  local message="$*"
33
  local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
34

35
  # Print to screen AND save to log file
36
  echo "[$timestamp] [$level] $message" | tee -a "$APP_LOG_FILE"
37
}
38

39
# Centralized error handling
40
# This logs the error and exits with a non-zero status
41
function error_exit() {
42
  log "ERROR" "$*" >&2
43
  exit 1
44
}
45

46
# Check if we have everything we need to run
47
function check_prerequisites() {
48
  # Example: Some scripts need root privileges
49
  if [[ $EUID -ne 0 ]]; then
50
    error_exit "This script must be run as root (current UID: $UID)"
51
  fi
52

53
  # Verify required commands are installed
54
  local required_commands=("curl" "jq" "aws")
55
  for cmd in "${required_commands[@]}"; do
56
    if ! command -v "$cmd" &> /dev/null; then
57
      error_exit "Required command not found: $cmd. Please install it first."
58
    fi
59
  done
60

61
  log "INFO" "All prerequisites satisfied"
62
}
63

64
# Set up directories and initialize the app
65
function initialize() {
66
  # Create necessary directories
67
  mkdir -p "$APP_CONFIG_DIR" "$APP_CACHE_DIR"
68
  touch "$APP_LOG_FILE"
69

70
  # Log some useful info for debugging
71
  log "INFO" "Initialized $APP_NAME"
72
  log "INFO" "Script: $SCRIPT_NAME (located at $SCRIPT_DIR)"
73
  log "INFO" "User: $USER (UID: $UID)"
74
}
75

76
# Parse command-line arguments
77
function process_arguments() {
78
  # If no arguments, show help and exit
79
  if [[ ${#@} -eq 0 ]]; then
80
    cat <<EOF
81
Usage: $SCRIPT_NAME [OPTIONS] [FILES...]
82

83
Options:
84
  -h, --help     Show this help message
85
  -v, --verbose  Enable verbose logging
86
  -d, --debug    Enable debug mode
87

88
Examples:
89
  $SCRIPT_NAME file1.txt file2.txt
90
  $SCRIPT_NAME --verbose *.log
91
EOF
92
    exit 0
93
  fi
94

95
  # Set up some flags
96
  local verbose=false
97
  local debug=false
98
  local files=()
99

100
  # Loop through all arguments
101
  while [[ $# -gt 0 ]]; do
102
    case "$1" in
103
      -h|--help)
104
        process_arguments  # Recursively call to show help
105
        ;;
106
      -v|--verbose)
107
        verbose=true
108
        log "INFO" "Verbose mode enabled"
109
        shift
110
        ;;
111
      -d|--debug)
112
        debug=true
113
        set -x  # This makes Bash print every command before running it
114
        shift
115
        ;;
116
      -*)
117
        error_exit "Unknown option: $1"
118
        ;;
119
      *)
120
        # Anything that doesn't start with - is treated as a file
121
        files+=("$1")
122
        shift
123
        ;;
124
    esac
125
  done
126

127
  log "INFO" "Processing ${#files[@]} file(s)"
128

129
  # Process each file
130
  for file in "${files[@]}"; do
131
    if [[ -f "$file" ]]; then
132
      log "INFO" "Processing file: $file"
133
      # Your actual file processing logic would go here
134
      # Example: wc -l "$file"
135
    else
136
      log "WARN" "File not found: $file"
137
    fi
138
  done
139
}
140

141
# Main entry point
142
function main() {
143
  initialize
144
  check_prerequisites || exit $?
145
  process_arguments "$@" || exit $?
146

147
  log "INFO" "Script completed successfully"
148
}
149

150
# This is where everything starts
151
# We pass all command-line arguments to main using "$@"
152
main "$@"