🧮 Lesson 8.2: Variables, Input, and Conditionals

Variables

Variables store data that your script can use and reuse. In Bash, variable assignment has one critical rule: no spaces around the =.

#!/bin/bash

# ✅ Correct — no spaces
NAME="Ray"
AGE=30
GREETING="Hello, $NAME"

# ❌ WRONG — spaces cause errors
# NAME = "Ray"    → Bash thinks NAME is a command
# NAME= "Ray"     → Also broken

# Use variables with $
echo "Name: $NAME"
echo "Age: $AGE"
echo "$GREETING"

# Curly braces for clarity (required when variable is next to other text)
FILE="report"
echo "${FILE}_final.txt"    # report_final.txt
echo "$FILE_final.txt"      # WRONG — Bash looks for variable $FILE_final

Quoting Rules

Quoting is one of the most important (and confusing) parts of Bash. Here's the cheat sheet:

NAME="Ray De La Paz"

echo "Hello, $NAME"     # Hello, Ray De La Paz
echo 'Hello, $NAME'     # Hello, $NAME (literal)
echo Hello, $NAME       # Hello, Ray De La Paz (works, but fragile)

# Why double-quoting matters:
FILE="my document.txt"
cat $FILE       # ❌ Bash sees: cat my document.txt (two arguments!)
cat "$FILE"     # ✅ Bash sees: cat "my document.txt" (one argument)

Environment Variables

Environment variables are inherited by child processes. Regular variables are not.

# Regular variable (only visible in this script/shell)
MY_VAR="local only"

# Environment variable (visible to child processes)
export MY_ENV_VAR="shared with children"

# One-liner: export at assignment
export API_KEY="abc123"

# View all environment variables
env
# or
printenv

# Some important built-in environment variables:
echo "$HOME"        # Your home directory (/home/ray)
echo "$USER"        # Current username (ray)
echo "$PATH"        # Where Bash looks for commands
echo "$PWD"         # Current working directory
echo "$SHELL"       # Your default shell (/bin/bash)
echo "$HOSTNAME"    # Machine name
echo "$RANDOM"      # A random number (0-32767)
echo "$$"           # Current process ID (PID)

Command Substitution

Capture the output of a command and store it in a variable:

# Modern syntax (preferred): $(command)
TODAY=$(date +%Y-%m-%d)
echo "Today is $TODAY"

FILE_COUNT=$(ls | wc -l)
echo "There are $FILE_COUNT files here"

KERNEL=$(uname -r)
echo "Kernel: $KERNEL"

# Old syntax (backticks) — still works but harder to nest
TODAY=`date +%Y-%m-%d`

# Nesting is clean with $():
echo "Files modified today: $(find . -newer $(date +%Y-%m-%d) -type f | wc -l)"
# vs. backticks (messy with escaping):
# echo "Files: `find . -newer \`date +%Y-%m-%d\` -type f | wc -l`"

A=10
B=3
echo "Sum: $((A + B))"        # 13
echo "Product: $((A * B))"    # 30
echo "Division: $((A / B))"   # 3 (integer only!)
echo "Remainder: $((A % B))"  # 1

# Increment
COUNT=0
((COUNT++))
echo "$COUNT"   # 1

User Input with read

#!/bin/bash

# Basic input
echo -n "Enter your name: "
read NAME
echo "Hello, $NAME!"

# Prompt built into read (-p flag)
read -p "Enter your age: " AGE
echo "You are $AGE years old."

# Silent input for passwords (-s flag)
read -sp "Enter password: " PASSWORD
echo ""   # Newline after silent input
echo "Password is ${#PASSWORD} characters long."

# Read with a timeout (-t seconds)
read -t 5 -p "Quick! Favorite color? " COLOR || echo "(Too slow!)"

# Read with a default value
read -p "Directory [/tmp]: " DIR
DIR="${DIR:-/tmp}"    # Use /tmp if empty
echo "Using directory: $DIR"

# Read multiple values
read -p "Enter first and last name: " FIRST LAST
echo "First: $FIRST, Last: $LAST"

NAME="${1:-World}"           # First argument, or "World"
LOG_DIR="${LOG_DIR:-/var/log}" # Env var, or /var/log
echo "Hello, $NAME!"

Script Arguments

Scripts can accept arguments from the command line — no need for interactive prompts.

#!/bin/bash
# greet.sh — Greets the user by name

echo "Script name: $0"
echo "First argument: $1"
echo "Second argument: $2"
echo "All arguments: $@"
echo "Number of arguments: $#"

$ ./greet.sh Ray Developer
Script name: ./greet.sh
First argument: Ray
Second argument: Developer
All arguments: Ray Developer
Number of arguments: 2

#!/bin/bash
# A script that requires exactly one argument

if [ $# -ne 1 ]; then
    echo "Usage: $0 <filename>" >&2
    exit 1
fi

echo "Processing file: $1"

if / elif / else

Conditionals let your script make decisions. The basic structure:

if [ condition ]; then
    # commands if true
elif [ another_condition ]; then
    # commands if this is true
else
    # commands if nothing above was true
fi

# ✅ Correct
if [ "$NAME" = "Ray" ]; then

# ❌ WRONG — will error
if ["$NAME" = "Ray"]; then

#!/bin/bash

read -p "Enter a number: " NUM

if [ "$NUM" -gt 100 ]; then
    echo "That's a big number!"
elif [ "$NUM" -gt 0 ]; then
    echo "That's a positive number."
elif [ "$NUM" -eq 0 ]; then
    echo "That's zero."
else
    echo "That's a negative number."
fi

Test Expressions

String Comparisons

Numeric Comparisons

File Tests

Combining Tests

# AND (both must be true)
if [ "$AGE" -ge 18 ] && [ "$AGE" -le 65 ]; then
    echo "Working age"
fi

# OR (either can be true)
if [ "$COLOR" = "red" ] || [ "$COLOR" = "blue" ]; then
    echo "Primary color!"
fi

# NOT (invert)
if [ ! -f "$FILE" ]; then
    echo "File does not exist"
fi

# Pattern matching (globbing)
if [[ "$FILE" == *.txt ]]; then
    echo "It's a text file"
fi

# Regex matching
if [[ "$EMAIL" =~ ^[a-zA-Z]+@[a-zA-Z]+\.[a-zA-Z]+$ ]]; then
    echo "Looks like an email"
fi

# No word splitting — no need to quote variables (but still good practice)
if [[ $NAME = "Ray" ]]; then echo "Hi Ray"; fi

Practical Example

Here's a script that combines everything — a file backup utility with input validation:

#!/bin/bash
# ============================================
# backup.sh — Back up a directory with a timestamp
# Usage: ./backup.sh [source_directory]
# ============================================

# Get source from argument or ask
SOURCE="${1:-}"
if [ -z "$SOURCE" ]; then
    read -p "Directory to back up: " SOURCE
fi

# Validate the source
if [ ! -d "$SOURCE" ]; then
    echo "ERROR: '$SOURCE' is not a directory." >&2
    exit 1
fi

# Set up the backup
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="backup_$(basename "$SOURCE")_${TIMESTAMP}.tar.gz"
DEST_DIR="${HOME}/backups"

# Create destination if needed
if [ ! -d "$DEST_DIR" ]; then
    mkdir -p "$DEST_DIR"
    echo "Created backup directory: $DEST_DIR"
fi

# Perform the backup
echo "Backing up '$SOURCE' → '$DEST_DIR/$BACKUP_NAME'"
tar -czf "$DEST_DIR/$BACKUP_NAME" -C "$(dirname "$SOURCE")" "$(basename "$SOURCE")"

# Check if it worked
if [ $? -eq 0 ]; then
    SIZE=$(du -h "$DEST_DIR/$BACKUP_NAME" | awk '{print $1}')
    echo "✅ Backup complete! Size: $SIZE"
    exit 0
else
    echo "❌ Backup failed!" >&2
    exit 1
fi

Exercises

Knowledge Check

Summary

🚀 What's Next?

The final lesson covers Loops and Functions — repeating actions and organizing your code into reusable pieces.