shell-scripting-fundamentals

Use when writing or modifying Bash/shell scripts. Covers script structure, variables, quoting, conditionals, and loops with modern best practices.

⭐47stars🔀5forks📁View on GitHub🕐Updated Jan 2, 2026⬇️1downloads

When & Why to Use This Skill

This Claude skill provides a comprehensive guide to writing robust and maintainable Bash scripts using modern best practices. It focuses on script reliability through strict error handling (set -euo pipefail), secure variable management, and optimized control structures, making it an essential resource for developers and system administrators looking to automate tasks safely and efficiently.

Use Cases

  • Automated System Maintenance: Developing reliable scripts for backups, log rotation, and system health monitoring that handle errors gracefully.
  • CI/CD Pipeline Integration: Creating robust shell-based build and deployment steps that work consistently across different Linux environments and automated workflows.
  • Environment Provisioning: Writing idempotent scripts to automate the setup and configuration of development workstations and server environments.
  • Efficient Data Processing: Leveraging shell-native utilities like grep, glob, and arrays for high-performance text manipulation and file management without external dependencies.
nameshell-scripting-fundamentals
descriptionUse when writing or modifying Bash/shell scripts. Covers script structure, variables, quoting, conditionals, and loops with modern best practices.

Shell Scripting Fundamentals

Core patterns and best practices for writing robust, maintainable shell scripts.

Script Structure

Always start scripts with a proper shebang and safety options:

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

# Script description here

Safety Options Explained

  • set -e: Exit on any command failure
  • set -u: Error on undefined variables
  • set -o pipefail: Pipeline fails if any command fails

Variables

Declaration and Assignment

# No spaces around =
name="value"

# readonly for constants
readonly CONFIG_DIR="/etc/myapp"

# local in functions
my_function() {
    local result="computed"
    echo "$result"
}

Always Quote Variables

# Good - prevents word splitting and glob expansion
echo "$variable"
cp "$source" "$destination"

# Bad - can break on spaces or special characters
echo $variable
cp $source $destination

Default Values

# Use default if unset
name="${NAME:-default}"

# Use default if unset or empty
name="${NAME:-}"

# Assign default if unset
: "${NAME:=default}"

# Error if unset
: "${REQUIRED_VAR:?Error: REQUIRED_VAR must be set}"

Conditionals

Test Syntax

# Modern syntax - preferred
if [[ -f "$file" ]]; then
    echo "File exists"
fi

# String comparison
if [[ "$string" == "value" ]]; then
    echo "Match"
fi

# Numeric comparison
if (( count > 10 )); then
    echo "Greater than 10"
fi

# Regex matching
if [[ "$input" =~ ^[0-9]+$ ]]; then
    echo "Numeric input"
fi

Common Test Operators

Operator Description
-f File exists and is regular file
-d Directory exists
-e Path exists
-r Readable
-w Writable
-x Executable
-z String is empty
-n String is not empty

Loops

For Loops

# Iterate over list
for item in one two three; do
    echo "$item"
done

# Iterate over files (use glob, not ls)
for file in *.txt; do
    [[ -e "$file" ]] || continue  # Handle no matches
    process "$file"
done

# C-style for loop
for (( i = 0; i < 10; i++ )); do
    echo "$i"
done

While Loops

# Read lines from file
while IFS= read -r line; do
    echo "$line"
done < "$filename"

# Read with process substitution
while IFS= read -r line; do
    echo "$line"
done < <(some_command)

Arrays

# Declare array
declare -a files=()

# Add elements
files+=("file1.txt")
files+=("file2.txt")

# Iterate all elements
for file in "${files[@]}"; do
    echo "$file"
done

# Get array length
echo "${#files[@]}"

# Access by index
echo "${files[0]}"

Command Substitution

# Modern syntax - preferred
result=$(command)

# Nested substitution
result=$(echo $(date))

# Avoid legacy backticks
result=`command`  # Don't use this

Functions

# Function definition
process_file() {
    local file="$1"
    local output_dir="${2:-./output}"

    if [[ ! -f "$file" ]]; then
        echo "Error: File not found: $file" >&2
        return 1
    fi

    # Process the file
    cp "$file" "$output_dir/"
}

# Call with arguments
process_file "input.txt" "/tmp/output"

Best Practices Summary

  1. Always use #!/usr/bin/env bash for portability
  2. Enable strict mode: set -euo pipefail
  3. Quote all variable expansions
  4. Use [[ ]] instead of [ ] for tests
  5. Use $(command) instead of backticks
  6. Declare local variables in functions
  7. Use arrays for lists of items
  8. Check command existence before use: command -v cmd >/dev/null