Bash Scripting Basics Cheat Sheet

#!/usr/bin/env bash   # first line of every script - finds bash on $PATH rather than assuming /bin/bash

chmod +x script.sh   # make it executable
./script.sh           # run it (must be in current directory, or use the full/relative path)

name="Aleksandar"        # no spaces around =, or bash treats it as a command
echo "$name"              # always quote variables when reading them
echo "Hello, ${name}!"    # {} disambiguates the variable name from surrounding text

readonly max_retries=3   # a constant - reassigning it later is an error
unset name                 # remove a variable entirely

echo $file       # unquoted - breaks on spaces/globs in $file, words get split apart
echo "$file"      # quoted - always safe, treat this as the default

echo 'literal $no_expansion here'   # single quotes: nothing is expanded, printed exactly as typed
echo "expands $HOME here"            # double quotes: variables and command substitution still expand

now=$(date +%F)               # preferred modern syntax - run a command, capture its output
count=$(ls -1 | wc -l)         # nest commands freely inside $()
echo "Today is $now, $count files here"

#!/usr/bin/env bash
echo "Script name: $0"     # the script's own path
echo "First arg: $1"        # first argument
echo "Second arg: $2"       # second argument
echo "All args: $@"         # every argument, each as a separate word
echo "Arg count: $#"        # how many arguments were passed

./script.sh backup.tar.gz /mnt/data   # $1=backup.tar.gz, $2=/mnt/data, $#=2

if [ "$#" -eq 0 ]; then
    echo "Usage: $0 <source> <destination>"   # remind the caller how to use it
    exit 1                                     # non-zero = failure, stops here
fi

exit 0   # success - the convention every tool and script should follow
exit 1   # generic failure

some-command
echo "exit code was: $?"   # $? holds the exit status of the LAST command run

command1 && command2   # run command2 only if command1 succeeded (exit code 0)
command1 || command2   # run command2 only if command1 failed (non-zero exit code)

if [ "$name" = "admin" ]; then
    echo "Welcome, admin"
elif [ "$name" = "guest" ]; then
    echo "Limited access"
else
    echo "Unknown user"
fi

[[ "$path" == /var/* ]]   # [[ ]] supports pattern matching and is generally safer than [ ]
[ -f "$file" ]             # -f: is this a regular file?
[ -d "$dir" ]              # -d: is this a directory?
[ -x "$script" ]           # -x: is this executable?
[ -z "$var" ]              # -z: is this string empty?
[ -n "$var" ]              # -n: is this string non-empty?

if [ ! -f "$config" ]; then
    echo "Config file missing"   # ! negates the test
    exit 1
fi

if [ "$count" -eq 0 ]; then echo "zero"; fi     # -eq / -ne / -lt / -le / -gt / -ge
if (( count > 10 )); then echo "over ten"; fi    # (( )) arithmetic context - more natural syntax

for file in *.log; do
    echo "Processing: $file"   # loops over each matching filename
done

for i in {1..5}; do
    echo "Iteration $i"        # brace expansion generates 1 2 3 4 5
done

count=0
while [ "$count" -lt 5 ]; do
    echo "Count: $count"
    count=$((count + 1))       # arithmetic without $(( )) requires the let/expr command instead
done

while read -r line; do
    echo "Line: $line"          # -r: don't let backslashes be interpreted, read the line literally
done < input.txt

greet() {
    local name="$1"            # local: scoped to this function, doesn't leak into the rest of the script
    echo "Hello, $name!"
}

greet "Aleksandar"              # call it like any other command

backup_file() {
    local source="$1"
    local dest="$2"
    if [ ! -f "$source" ]; then
        echo "Error: $source not found" >&2   # >&2 sends errors to stderr, not stdout
        return 1                                # return: exit status for a FUNCTION (exit is for the whole script)
    fi
    cp "$source" "$dest"
}

servers=("web1" "web2" "db1")   # declare an array
echo "${servers[0]}"             # first element (arrays are zero-indexed)
echo "${servers[@]}"             # every element
echo "${#servers[@]}"            # number of elements

for server in "${servers[@]}"; do
    echo "Checking $server"       # quoted "${servers[@]}" keeps multi-word elements intact
done

cat <<EOF
This is line one.
This is line two, with $variable expanded.
EOF

cat <<'EOF'
This is printed literally - $variable is NOT expanded because EOF is quoted.
EOF

str="Hello World"
echo "${#str}"           # length of the string
echo "${str,,}"           # lowercase the whole string
echo "${str^^}"           # uppercase the whole string
echo "${str/World/Bash}"  # replace first match
echo "${str:0:5}"         # substring: start at 0, length 5 -> "Hello"

filename="backup.tar.gz"
echo "${filename%.gz}"    # strip shortest match from the end -> "backup.tar"
echo "${filename%%.*}"    # strip longest match from the end -> "backup"

#!/usr/bin/env bash
set -e   # exit immediately if any command fails, instead of continuing on regardless
set -u   # error on any unset variable, instead of silently treating it as empty
set -o pipefail   # a pipeline fails if ANY command in it fails, not just the last one

set -euo pipefail   # the three combined - a common, defensive first line for real scripts

set -x   # print each command before running it - invaluable while debugging, turn off before production use
set +x   # turn tracing back off

read -p "Enter your name: " name   # -p shows a prompt on the same line
echo "Hello, $name"

read -sp "Enter password: " password   # -s: silent, don't echo what's typed
echo   # newline, since -s suppresses the one the user's Enter key would normally produce

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

# Back up a directory with a timestamped name, and confirm the source exists first
source_dir="/home/user/documents"
backup_dir="/mnt/backups"

if [ ! -d "$source_dir" ]; then
    echo "Error: $source_dir does not exist" >&2
    exit 1
fi

timestamp=$(date +%F_%H-%M-%S)
tar -czf "${backup_dir}/backup-${timestamp}.tar.gz" "$source_dir"
echo "Backup complete: backup-${timestamp}.tar.gz"

#!/usr/bin/env bash
# Loop over a list of servers and check if each one responds to ping
servers=("web1.example.com" "web2.example.com" "db1.example.com")

for server in "${servers[@]}"; do
    if ping -c 1 -W 2 "$server" &> /dev/null; then
        echo "$server: UP"
    else
        echo "$server: DOWN"
    fi
done