Special Variables

Bash provides several special variables that are automatically set and contain useful information about the script execution context. These variables give you access to command-line arguments, the script name, process IDs, exit statuses, and more. Understanding special variables is essential for writing scripts that accept arguments and handle errors properly!

Script Name: $0

The $0 variable contains the name of the script or command being executed. This is useful for error messages, help text, and logging.

Click Run to execute your code

#!/bin/bash
# Display script name
echo "This script is called: $0"

# Practical use: help message
if [ $# -eq 0 ]; then
    echo "Usage: $0 <filename>"
    exit 1
fi

Positional Parameters: $1, $2, ... $9

These variables contain the command-line arguments passed to your script. $1 is the first argument, $2 is the second, and so on.

#!/bin/bash
# Accessing arguments
echo "First argument: $1"
echo "Second argument: $2"
echo "Third argument: $3"

# Run with: ./script.sh apple banana cherry

Number of Arguments: $#

The $# variable contains the total number of arguments passed to the script. This is essential for argument validation.

#!/bin/bash
echo "Number of arguments: $#"

# Validate argument count
if [ $# -lt 2 ]; then
    echo "Error: Need at least 2 arguments"
    echo "Usage: $0 <arg1> <arg2>"
    exit 1
fi

echo "First arg: $1"
echo "Second arg: $2"

All Arguments: $@ and $*

Both $@ and $* represent all arguments, but they behave differently when quoted. Understanding this difference is crucial for writing robust scripts!

#!/bin/bash
# Difference between $@ and $*

# With arguments: ./script.sh "hello world" "foo bar"

echo "Using $@ (each argument separately):"
for arg in "$@"; do
    echo "  - '$arg'"
done
# Output:
#   - 'hello world'
#   - 'foo bar'

echo ""
echo "Using $* (all as one string):"
echo "  '$*'"
# Output: 'hello world foo bar'

Process ID: $$

The $$ variable contains the Process ID (PID) of the current shell or script. This is useful for creating unique temporary files, logging, and process management.

#!/bin/bash
echo "This script's process ID: $$"

# Create unique temporary file
TEMP_FILE="/tmp/script_$$.tmp"
echo "Creating temp file: $TEMP_FILE"
touch "$TEMP_FILE"

# Cleanup on exit
trap "rm -f $TEMP_FILE" EXIT

Exit Status: $?

The $? variable contains the exit status of the last executed command. This is essential for error handling and conditional logic.

#!/bin/bash
# Exit status is 0 for success, non-zero for failure

# Run a command
ls /nonexistent 2>/dev/null

# Check exit status
if [ $? -eq 0 ]; then
    echo "Command succeeded"
else
    echo "Command failed with exit code: $?"
fi

# Check exit status immediately (before it changes)
ls /tmp
echo "Exit status: $?"  # Must check immediately!

# After another command, $? changes
echo "test"
echo "Previous exit status lost: $?"  # This shows echo's exit status (0)

Background Process ID: $!

The $! variable contains the Process ID of the last background job. This is useful for managing background processes.

#!/bin/bash
# Start a background job
sleep 10 &
BG_PID=$!

echo "Background process started with PID: $BG_PID"

# Wait for it to finish
wait $BG_PID
echo "Background process finished"

Common Mistakes

# Wrong - loses individual arguments
function process_args() {
    for arg in "$*"; do
        echo "$arg"  # Only one iteration, all args joined!
    done
}

# Correct - preserves individual arguments
function process_args() {
    for arg in "$@"; do
        echo "$arg"  # One iteration per argument
    done
}

# Wrong - $? might change
ls /tmp
echo "Something"
if [ $? -eq 0 ]; then  # Checks echo's exit status, not ls!
    echo "ls succeeded"
fi

# Correct - check immediately
ls /tmp
if [ $? -eq 0 ]; then  # Checks ls exit status
    echo "ls succeeded"
fi

# Even better - use if directly
if ls /tmp > /dev/null 2>&1; then
    echo "ls succeeded"
fi

# Wrong - interpreted as $1 + "0"
echo $10  # Prints value of $1 followed by literal "0"

# Correct - use braces
echo ${10}  # Prints 10th argument

# Wrong - no error handling
echo "First arg: $1"
echo "Second arg: $2"

# Correct - validate first
if [ $# -lt 2 ]; then
    echo "Error: Need 2 arguments"
    exit 1
fi
echo "First arg: $1"
echo "Second arg: $2"

Exercise: Create an Argument Processor

#!/bin/bash
# Argument processor script

# Display script name
echo "Script name: $0"
echo ""

# Display argument count
echo "Number of arguments: $#"
echo ""

# Validate arguments
if [ $# -lt 2 ]; then
    echo "Error: Need at least 2 arguments"
    echo "Usage: $0 <arg1> <arg2> [arg3...]"
    exit 1
fi

# Display all arguments
echo "All arguments ($@):"
for arg in "$@"; do
    echo "  - $arg"
done
echo ""

# Display first two arguments
echo "First argument: $1"
echo "Second argument: $2"
echo ""

# Check command exit status
ls /tmp > /dev/null 2>&1
if [ $? -eq 0 ]; then
    echo "ls /tmp succeeded (exit status: $?)"
else
    echo "ls /tmp failed (exit status: $?)"
fi

Summary

What's Next?

Excellent! You've mastered special variables for handling command-line arguments. Next, we'll explore Arrays - a powerful way to store and manipulate multiple values. Arrays let you work with lists of items, iterate through them, and perform bulk operations efficiently!