Advanced Bash Scripting Guide cheatsheet

Fruits=('Apple' 'Banana' 'Orange')

Fruits[0]="Apple"
Fruits[1]="Banana"
Fruits[2]="Orange"

echo "${Fruits[0]}"           # Element #0
echo "${Fruits[-1]}"          # Last element
echo "${Fruits[@]}"           # All elements, space-separated
echo "${#Fruits[@]}"          # Number of elements
echo "${#Fruits}"             # String length of the 1st element
echo "${#Fruits[3]}"          # String length of the Nth element
echo "${Fruits[@]:3:2}"       # Range (from position 3, length 2)
echo "${!Fruits[@]}"          # Keys of all elements, space-separated

Fruits=("${Fruits[@]}" "Watermelon")    # Push
Fruits+=('Watermelon')                  # Also Push
Fruits=( "${Fruits[@]/Ap*/}" )          # Remove by regex match
unset Fruits[2]                         # Remove one item
Fruits=("${Fruits[@]}")                 # Duplicate
Fruits=("${Fruits[@]}" "${Veggies[@]}") # Concatenate
lines=(`cat "logfile"`)                 # Read from file

for i in "${arrayName[@]}"; do
  echo "$i"
done

set -o noclobber  # Avoid overlay files (echo "hi" > foo)
set -o errexit    # Used to exit upon error, avoiding cascading errors
set -o pipefail   # Unveils hidden failures
set -o nounset    # Exposes unset variables

shopt -s nullglob    # Non-matching globs are removed  ('*.foo' => '')
shopt -s failglob    # Non-matching globs throw errors
shopt -s nocaseglob  # Case insensitive globs
shopt -s dotglob     # Wildcards match dotfiles ("*.sh" => ".foo.sh")
shopt -s globstar    # Allow ** for recursive matches ('lib/**/*.rb' => 'lib/a/b/c.rb')

Set GLOBIGNORE as a colon-separated list of patterns to be removed from glob matches.

!! and !$ can be replaced with any valid expansion.

!! can be replaced with any valid expansion i.e. !cat, !-2, !42, etc.

$((a + 200))      # Add 200 to $a

$(($RANDOM%200))  # Random number 0..199

declare -i count  # Declare as type integer
count+=1          # Increment

(cd somedir; echo "I'm now in $PWD")
pwd # still in first directory

python hello.py > output.txt            # stdout to (file)
python hello.py >> output.txt           # stdout to (file), append
python hello.py 2> error.log            # stderr to (file)
python hello.py 2>&1                    # stderr to stdout
python hello.py 2>/dev/null             # stderr to (null)
python hello.py >output.txt 2>&1        # stdout and stderr to (file), equivalent to &>
python hello.py &>/dev/null             # stdout and stderr to (null)
echo "$0: warning: too many users" >&2  # print diagnostic message to stderr

python hello.py < foo.txt      # feed foo.txt to stdin for python
diff <(ls -r) <(ls)            # Compare two stdout without files

command -V cd
#=> "cd is a function/alias/whatever"

trap 'echo Error at about $LINENO' ERR

or

traperr() {
  echo "ERROR: ${BASH_SOURCE[1]} at about ${BASH_LINENO[0]}"
}

set -o errtrace
trap traperr ERR

case "$1" in
  start | up)
    vagrant up
    ;;

  *)
    echo "Usage: $0 {start|stop|ssh}"
    ;;
esac

source "${0%/*}/../share/foo.sh"

printf "Hello %s, I'm %s" Sven Olga
#=> "Hello Sven, I'm Olga

printf "1 + 1 = %d" 2
#=> "1 + 1 = 2"

printf "This is how you print a float: %f" 2
#=> "This is how you print a float: 2.000000"

printf '%s\n' '#!/bin/bash' 'echo hello' >file
# format string is applied to each group of arguments
printf '%i+%i=%i\n' 1 2 3  4 5 9

Example

echo "Welcome To HHFCheatSheets" | tr '[:lower:]' '[:upper:]'
WELCOME TO HHFCheatSheets

dir=${0%/*}

while [[ "$1" =~ ^- && ! "$1" == "--" ]]; do case $1 in
  -V | --version )
    echo "$version"
    exit
    ;;
  -s | --string )
    shift; string=$1
    ;;
  -f | --flag )
    flag=1
    ;;
esac; shift; done
if [[ "$1" == '--' ]]; then shift; fi

cat <<END
hello world
END

echo -n "Proceed? [y/n]: "
read -r ans
echo "$ans"

The -r option disables a peculiar legacy behavior with backslashes.

read -n 1 ans    # Just one character

See Special parameters.

pwd # /home/user/foo
cd bar/
pwd # /home/user/foo/bar
cd -
pwd # /home/user/foo

if ping -c 1 google.com; then
  echo "It appears you have a working internet connection"
fi

if grep -q 'foo' ~/.bash_history; then
  echo "You appear to have typed 'foo' in the past"
fi

Here’s a comprehensive example of variable manipulation:

# String manipulation
text="Hello World"
echo "${text,,}"      # Convert to lowercase: hello world
echo "${text^^}"      # Convert to uppercase: HELLO WORLD
echo "${text:0:5}"    # Substring: Hello
echo "${#text}"       # Length: 11

# Array operations with explanation
declare -A fruits
fruits=(
    ["apple"]="red"
    ["banana"]="yellow"
    ["grape"]="purple"
)

# Iterate with both key and value
for fruit in "${!fruits[@]}"; do
    echo "The $fruit is ${fruits[$fruit]}"
done

# Pattern matching and substitution
filename="script.txt.bak"
echo "${filename%.bak}"    # Remove .bak suffix
echo "${filename#*.}"      # Remove everything before first dot

Here’s a comprehensive example of file operations:

#!/usr/bin/env bash

# Function to process a directory recursively
process_directory() {
    local dir="$1"
    local depth="${2:-0}"
    local indent="$(printf '%*s' "$depth" '')"
    
    # Check if directory exists and is readable
    if [[ ! -d "$dir" ]] || [[ ! -r "$dir" ]]; then
        echo "Error: Cannot access directory $dir"
        return 1
    }
    
    # Process all files in the directory
    while IFS= read -r -d '' file; do
        if [[ -f "$file" ]]; then
            # Get file information
            local size="$(stat -f %z "$file")"
            local modified="$(stat -f %Sm "$file")"
            echo "${indent}File: $file"
            echo "${indent}Size: $size bytes"
            echo "${indent}Modified: $modified"
            
            # Process based on file type
            case "$(file -b "$file")" in
                *text*)
                    echo "${indent}Type: Text file"
                    # Add text processing logic
                    ;;
                *image*)
                    echo "${indent}Type: Image file"
                    # Add image processing logic
                    ;;
                *)
                    echo "${indent}Type: Other"
                    ;;
            esac
        elif [[ -d "$file" ]]; then
            echo "${indent}Directory: $file"
            # Recursively process subdirectories
            process_directory "$file" "$((depth + 2))"
        fi
    done < <(find "$dir" -print0)
}

# Example usage
process_directory "/path/to/directory"

Here’s a robust example of error handling in Bash:

#!/usr/bin/env bash

# Error handling function
handle_error() {
    local line_num="$1"
    local error_code="$2"
    local error_msg="$3"
    
    echo "Error occurred in script $0 at line $line_num"
    echo "Exit code: $error_code"
    echo "Error message: $error_msg"
    
    # Send error notification (example)
    if command -v mailx >/dev/null 2>&1; then
        echo "Script error in $0" | mailx -s "Script Error" [email protected]
    fi
    
    # Cleanup any temporary files
    cleanup
    
    exit "$error_code"
}

# Set error trap
trap 'handle_error ${LINENO} $? "$BASH_COMMAND"' ERR

# Example function that might fail
risky_operation() {
    local input="$1"
    
    if [[ -z "$input" ]]; then
        return 1
    fi
    
    # Simulate an operation that might fail
    if ! some_command "$input"; then
        return 2
    fi
    
    return 0
}

# Main script with error handling
main() {
    local result
    
    # Try risky operation
    if ! result=$(risky_operation "test input"); then
        echo "Operation failed: $result"
        return 1
    fi
    
    echo "Operation succeeded: $result"
    return 0
}

# Run main function
main "$@"

Here’s an example of network operations in Bash:

#!/usr/bin/env bash

# Function to check network connectivity
check_connectivity() {
    local host="$1"
    local timeout="${2:-5}"
    
    if ping -c 1 -W "$timeout" "$host" >/dev/null 2>&1; then
        echo "Host $host is reachable"
        return 0
    else
        echo "Host $host is not reachable"
        return 1
    fi
}

# Function to download file with retry
download_with_retry() {
    local url="$1"
    local output="$2"
    local max_retries="${3:-3}"
    local retry_count=0
    
    while (( retry_count < max_retries )); do
        if curl -L -o "$output" "$url"; then
            echo "Download successful: $output"
            return 0
        else
            ((retry_count++))
            echo "Download failed, attempt $retry_count of $max_retries"
            sleep $((retry_count * 2))
        fi
    done
    
    echo "Failed to download after $max_retries attempts"
    return 1
}

# Example usage
check_connectivity "google.com" || exit 1
download_with_retry "https://example.com/file.txt" "output.txt" 5

• 1. Use functions to organize code into logical units
• 1. Keep functions small and focused on a single task
• 1. Use meaningful variable and function names
• 1. Add comments to explain complex logic
• 1. Use consistent indentation and formatting
• 1. Follow the DRY (Don’t Repeat Yourself) principle

• 1. Always quote variables to prevent word splitting
• 1. Use restricted paths when executing commands
• 1. Validate user input before processing
• 1. Avoid using eval unless absolutely necessary
• 1. Use proper file permissions
• 1. Be careful with temporary files

• 1. Use built-in commands when possible
• 1. Avoid unnecessary subshells
• 1. Use arrays instead of string manipulation when working with lists
• 1. Minimize external command calls
• 1. Use proper exit codes and error handling

#!/usr/bin/env bash

# Log rotation function
rotate_logs() {
    local log_file="$1"
    local max_size="${2:-1048576}" # 1MB default
    local backup_count="${3:-5}"    # Keep 5 backups by default
    
    # Check if log file exists and exceeds max size
    if [[ -f "$log_file" ]] && [[ "$(stat -f %z "$log_file")" -gt "$max_size" ]]; then
        # Rotate existing backup logs
        for (( i=backup_count; i>0; i-- )); do
            [[ -f "${log_file}.$((i-1))" ]] && mv "${log_file}.$((i-1))" "${log_file}.$i"
        done
        
        # Move current log to .1
        mv "$log_file" "${log_file}.1"
        
        # Create new empty log file
        touch "$log_file"
        
        return 0
    fi
    
    return 1
}

# Example usage
rotate_logs "/var/log/myapp.log" 1048576 5

This enhanced guide provides more comprehensive examples and explanations of advanced Bash scripting concepts. Each section includes practical examples that can be used as templates for real-world applications.