$devvkit resources --cheatsheet bash-scripting

Bash Scripting

Q: How do I debug a Bash script?

Run bash -x script.sh to trace every command as it executes, or add set -x inside the script and set +x to disable. Use set -e to exit on errors and set -u to error on undefined variables.

[terminal]

Every essential Bash scripting pattern: variables, conditionals, loops, functions, file operations, and error handling, with syntax and real use cases.93 commands · 6 sections

Bash scripts automate everything from deploys to cron jobs. This cheatsheet covers the patterns you write daily: variables and substitutions, conditionals, loops, functions, file operations, and the error-handling habits that keep scripts safe.

Every entry shows real syntax followed by the use case: when and why you reach for it.

Variables & Substitutions22

$name="Jane"

Use case: Assign a variable: NO spaces around the equals sign.Example: dir="/var/www"

$echo "$name"

Use case: Use the value: always double-quote variables.Example: echo "Deploying to $dir"

$echo '$name'

Use case: Single quotes: literal text, NO expansion.Example: echo '$name stays literal'

$export PATH="$PATH:/new/bin"

Use case: Export: make the variable available to child processes.Example: export NODE_ENV="production"

$$(command)

Use case: Command substitution: capture output.Example: files="$(ls -1 src)"

$`command`

Use case: Legacy command substitution: avoid; use $().Example: date=`date`

$${name:-default}

Use case: Default value if unset or empty.Example: port="${PORT:-3000}"

$${name:=default}

Use case: Assign a default if unset: same as :- but writes the variable.Example: ${MODE:=dev}

$${name:?error msg}

Use case: Fail loudly if unset: required parameters.Example: api_key="${API_KEY:?API_KEY required}"

$${#name}

Use case: Length of the value.Example: echo "${#password}"

$${name%pattern} / ${name#pattern}

Use case: Strip a suffix / prefix from a variable.Example: file="${path##*/}" # basename

$${name//old/new}

Use case: Replace ALL occurrences in a variable.Example: kebab="${title// /-}"

$${name/old/new}

Use case: Replace the FIRST occurrence.Example: fixed="${input/foo/bar}"

$$((${a:-0} + ${b:-0}))

Use case: Arithmetic: always default numeric vars to avoid errors.Example: total=$((count + 1))

$((i++))

Use case: Arithmetic as a statement: counters in loops.Example: ((attempts++))

$local var="x"

Use case: Function-local variable: never leak globals.Example: local tmp=$(mktemp)

$declare -a arr=(a b c)

Use case: Declare an array.Example: hosts=(web-1 web-2 web-3)

$${arr[@]}

Use case: ALL array elements: expand each as a separate word.Example: for h in "${hosts[@]}"; do ...; done

$${#arr[@]}

Use case: Array length.Example: echo "hosts: ${#hosts[@]}"

$arr+=("new")

Use case: Append to an array.Example: errors+=("$file failed")

$read -r var

Use case: Read user input into a variable.Example: read -rp "Commit message: " msg

$IFS="," read -ra parts <<< "a,b,c"

Use case: Split a string into an array by delimiter.Example: IFS="," read -ra tags <<< "$csv"

Conditionals17

$if [[ $x -eq 5 ]]; then ...; fi

Use case: Numeric comparison: ALWAYS double brackets.Example: if [[ $code -ne 0 ]]; then exit 1; fi

$if [[ "$a" == "yes" ]]; then ...; fi

Use case: String comparison: quote the variables.Example: if [[ "$answer" == "y" || "$answer" == "yes" ]]; then

$if [[ -f "$file" ]]; then ...; fi

Use case: File exists and is a regular file.Example: if [[ -f ".env" ]]; then source .env; fi

$if [[ -d "$dir" ]]; then ...; fi

Use case: Directory exists.Example: if [[ -d "node_modules" ]]; then ...

$if [[ -z "$var" ]]; then ...; fi

Use case: Variable is EMPTY.Example: if [[ -z "$msg" ]]; then msg="no message"; fi

$if [[ -n "$var" ]]; then ...; fi

Use case: Variable is NOT empty.Example: if [[ -n "$BRANCH" ]]; then git checkout "$BRANCH"; fi

$if [[ -x "$file" ]]; then ...; fi

Use case: File is executable.Example: if [[ -x "deploy.sh" ]]; then ./deploy.sh; fi

$if [[ $x -gt 10 && $x -lt 20 ]]; then ...; fi

Use case: AND: both conditions.Example: if [[ $code -ge 500 && $code -lt 600 ]]; then

$if [[ $x == "a" || $x == "b" ]]; then ...; fi

Use case: OR: either condition.Example: if [[ "$env" == "staging" || "$env" == "prod" ]]; then

$if [[ "$a" =~ ^[0-9]+$ ]]; then ...; fi

Use case: Regex match: validate input.Example: if [[ "$port" =~ ^[0-9]+$ ]]; then

$if cmd; then ...; fi

Use case: Test a COMMAND's exit status directly.Example: if grep -q "error" app.log; then alert; fi

$if cmd; then ...; else ...; fi

Use case: The full if/else form.Example: if command -v node &>/dev/null; then echo "node found"; else echo "install node"; fi

$if ...; then ...; elif ...; then ...; fi

Use case: Multiple branches.Example: if [[ $type == "a" ]]; then A; elif [[ $type == "b" ]]; then B; fi

case "$x" in
  a) ... ;;
  *) ... ;;
esac

Use case: Switch statement: cleaner than long if/elif chains.Example: case "$cmd" in start) start_app ;; stop) stop_app ;; *) usage ;; esac

$[ "$x" = "y" ]

Use case: Single brackets: POSIX-compatible but error-prone; prefer [[ ]].Example: [ "$USER" = "root" ]

$! command

Use case: Negate a command's success.Example: if ! docker info &>/dev/null; then echo "docker not running"; fi

$command && echo ok || echo fail

Use case: One-line conditional: chain on success/failure.Example: npm run build && deploy || echo "build failed"

Loops11

$for f in *.txt; do ...; done

Use case: Iterate over glob matches: files.Example: for f in logs/*.log; do gzip "$f"; done

$for i in {1..10}; do ...; done

Use case: Fixed range loop: brace expansion.Example: for i in {1..5}; do retry; done

$for i in $(seq 1 10); do ...; done

Use case: Range loop with seq: dynamic bounds.Example: for i in $(seq 1 "$n"); do ...

$for item in "${arr[@]}"; do ...; done

Use case: Iterate over an array: quote expansion!Example: for host in "${hosts[@]}"; do ping -c1 "$host"; done

$for ((i=0; i<10; i++)); do ...; done

Use case: C-style loop: index math.Example: for ((i=0; i<${#arr[@]}; i++)); do echo "${arr[$i]}"; done

$while read -r line; do ...; done < file

Use case: Read a file line by line: the safe line loop.Example: while read -r ip; do ban "$ip"; done < blocked.txt

$while read -r line; do ...; done <<< "$var"

Use case: Loop over a string's lines.Example: while read -r u; do adduser "$u"; done <<< "$users_csv"

$until condition; do ...; done

Use case: Loop UNTIL the condition is true: wait patterns.Example: until curl -sf http://localhost:3000; do sleep 1; done

$while true; do ...; done

Use case: Infinite loop: with explicit break.Example: while true; do deploy && break sleep 5 done

$break / continue

Use case: Exit the loop / skip an iteration.Example: for f in *; do [[ "$f" == "skip" ]] && continue [[ "$f" == "stop" ]] && break done

$for f in $(find . -name "*.js"); do ...; done

Use case: Loop over command output: careful with spaces.Example: for f in $(git diff --name-only); do lint "$f"; done

Functions8

myfunc() {
  echo "hi"
}

Use case: Define a function.Example: deploy() { npm run build scp -r dist server:/var/www }

$myfunc arg1 arg2

Use case: Call with arguments: no parentheses.Example: deploy production

$$1 $2 ${@}

Use case: Arguments inside the function: $@ is all of them.Example: log() { echo "[$(date)] $@" >> app.log }

$return 1

Use case: Exit the function with a status: 0 success, nonzero fail.Example: check_env() { [[ -n "$KEY" ]] || return 1 return 0 }

$result=$(myfunc)

Use case: Capture a function's stdout as a value.Example: today=$(get_date)

$function name() { ... }

Use case: Alternative syntax: works but redundant.Example: function cleanup() { rm -rf /tmp/build; }

$trap cleanup EXIT

Use case: Run a function when the script exits: guaranteed cleanup.Example: trap 'rm -f "$tmpfile"' EXIT

$export -f myfunc

Use case: Export a function to subshells: with bash -c and parallel.Example: export -f work cat urls | xargs -P4 -I{} bash -c "work {}"

File Operations17

$> file

Use case: Redirect stdout to a file (overwrite).Example: npm run build > build.log 2>&1

$>> file

Use case: Append stdout to a file.Example: echo "deployed $(date)" >> deploy.log

$2> /dev/null

Use case: Discard errors: silence expected failures.Example: rm -f "$lock" 2>/dev/null

$2>&1

Use case: Merge stderr into stdout: one log.Example: cmd > full.log 2>&1

$cmd | tee file

Use case: Pipe to a file AND keep the terminal output.Example: make build 2>&1 | tee build.log

$cmd1 | cmd2

Use case: Pipe: feed one command's output into the next.Example: ps aux | grep node | awk '{print $2}'

$cat file1 file2 > merged

Use case: Concatenate into one file.Example: cat part1.txt part2.txt > full.txt

$grep -q pattern file && action

Use case: Conditional on a search: the if-command idiom.Example: grep -q "TODO" src/*.ts && echo "todos remain"

$find . -name "*.tmp" -exec rm {} \;

Use case: Find and act on matches: {} is the filename.Example: find /tmp -mtime +7 -exec rm -rf {} \;

$xargs -n1 cmd

Use case: Run a command once per input line: parallel with -P.Example: cat urls.txt | xargs -P4 -n1 curl -I

$diff -u a.txt b.txt

Use case: Unified diff: patch-style output.Example: diff -u config.old config.new

$cp -a src/ dst/

Use case: Copy recursively preserving attributes: deploy pattern.Example: cp -a dist/ /var/www/app/

$mv file file.bak

Use case: Backup a file inline.Example: mv config.yml config.yml.bak

$mkdir -p a/b && cd a/b

Use case: Create and enter in one move.Example: mkdir -p "$HOME/tmp/deploy" && cd "$_"

$basename /path/file.txt

Use case: Filename without the directory.Example: name=$(basename "$path")

$dirname /path/file.txt

Use case: Directory without the filename.Example: dir=$(dirname "$path")

$wc -l < file

Use case: Count lines: clean output without the filename.Example: errors=$(wc -l < errors.log)

Error Handling & Debugging18

$set -e

Use case: Exit on ANY command failure: the #1 safety habit.Example: set -e # stop on error

$set -u

Use case: Error on undefined variables: catch typos.Example: set -u

$set -euo pipefail

Use case: The holy trinity: exit on error, undefined vars, and failed pipes.Example: set -euo pipefail

$set -x

Use case: Trace: print every command before running. The debugger.Example: set -x ... set +x

$bash -x script.sh

Use case: Run a script with tracing: no code edits.Example: bash -x deploy.sh

$cmd || exit 1

Use case: Fail explicitly with a status.Example: npm run build || exit 1

$cmd || { echo "msg" >&2; exit 1; }

Use case: Fail with a message to stderr.Example: cd "$dir" || { echo "no dir" >&2; exit 1; }

$cmd || handle_error

Use case: Run a recovery function on failure.Example: retry() { sleep 5; deploy; } deploy || retry

$cmd &

Use case: Background a command: get the prompt back.Example: long_task &

$wait

Use case: Wait for ALL background jobs to finish.Example: sleep 5 & sleep 3 & wait echo "both done"

$$?

Use case: Exit status of the LAST command.Example: cmd if [[ $? -ne 0 ]]; then log_failure; fi

$trap 'echo "killed"; exit 1' INT TERM

Use case: Handle signals: graceful Ctrl+C.Example: trap 'cleanup; exit 1' INT

$trap - ERR

Use case: Run on ANY error: error reporting.Example: trap 'echo "error at line $LINENO" >&2' ERR

$#!/usr/bin/env bash

Use case: Shebang: make the script self-executing.Example: #!/usr/bin/env bash # then: chmod +x script.sh && ./script.sh

$exit 0 / exit 1

Use case: Exit with explicit status: 0 success, 1 failure, 2 usage.Example: if [[ $# -lt 1 ]]; then usage; exit 2; fi exit 0

$>&2 echo "error"

Use case: Print to stderr: keep errors separate from output.Example: >&2 echo "build failed"

$command -v node

Use case: Check a tool is installed: before using it.Example: command -v docker >/dev/null || { echo "install docker"; exit 1; }

$set -o pipefail

Use case: Pipe fails if ANY stage fails: not just the last.Example: set -o pipefail cmd | grep x # fails if cmd fails

Bash Scripting

Every essential Bash scripting pattern: variables, conditionals, loops, functions, file operations, and error handling, with syntax and real use cases.

Every entry shows real syntax followed by the use case: when and why you reach for it.

Variables & Substitutions

name="Jane": Assign a variable: NO spaces around the equals sign.

Example: dir="/var/www"

echo "$name": Use the value: always double-quote variables.

Example: echo "Deploying to $dir"

echo '$name': Single quotes: literal text, NO expansion.

Example: echo '$name stays literal'

export PATH="$PATH:/new/bin": Export: make the variable available to child processes.

Example: export NODE_ENV="production"

$(command): Command substitution: capture output.

Example: files="$(ls -1 src)"

`command`: Legacy command substitution: avoid; use $().

Example: date=`date`

${name:-default}: Default value if unset or empty.

Example: port="${PORT:-3000}"

${name:=default}: Assign a default if unset: same as :- but writes the variable.

Example: ${MODE:=dev}

${name:?error msg}: Fail loudly if unset: required parameters.

Example: api_key="${API_KEY:?API_KEY required}"

${#name}: Length of the value.

Example: echo "${#password}"

${name%pattern} / ${name#pattern}: Strip a suffix / prefix from a variable.

Example: file="${path##*/}" # basename

${name//old/new}: Replace ALL occurrences in a variable.

Example: kebab="${title// /-}"

${name/old/new}: Replace the FIRST occurrence.

Example: fixed="${input/foo/bar}"

$((${a:-0} + ${b:-0})): Arithmetic: always default numeric vars to avoid errors.

Example: total=$((count + 1))

((i++)): Arithmetic as a statement: counters in loops.

Example: ((attempts++))

local var="x": Function-local variable: never leak globals.

Example: local tmp=$(mktemp)

declare -a arr=(a b c): Declare an array.

Example: hosts=(web-1 web-2 web-3)

${arr[@]}: ALL array elements: expand each as a separate word.

Example: for h in "${hosts[@]}"; do ...; done

${#arr[@]}: Array length.

Example: echo "hosts: ${#hosts[@]}"

arr+=("new"): Append to an array.

Example: errors+=("$file failed")

read -r var: Read user input into a variable.

Example: read -rp "Commit message: " msg

IFS="," read -ra parts <<< "a,b,c": Split a string into an array by delimiter.

Example: IFS="," read -ra tags <<< "$csv"

Conditionals

if [[ $x -eq 5 ]]; then ...; fi: Numeric comparison: ALWAYS double brackets.

Example: if [[ $code -ne 0 ]]; then exit 1; fi

if [[ "$a" == "yes" ]]; then ...; fi: String comparison: quote the variables.

Example: if [[ "$answer" == "y" || "$answer" == "yes" ]]; then

if [[ -f "$file" ]]; then ...; fi: File exists and is a regular file.

Example: if [[ -f ".env" ]]; then source .env; fi

if [[ -d "$dir" ]]; then ...; fi: Directory exists.

Example: if [[ -d "node_modules" ]]; then ...

if [[ -z "$var" ]]; then ...; fi: Variable is EMPTY.

Example: if [[ -z "$msg" ]]; then msg="no message"; fi

if [[ -n "$var" ]]; then ...; fi: Variable is NOT empty.

Example: if [[ -n "$BRANCH" ]]; then git checkout "$BRANCH"; fi

if [[ -x "$file" ]]; then ...; fi: File is executable.

Example: if [[ -x "deploy.sh" ]]; then ./deploy.sh; fi

if [[ $x -gt 10 && $x -lt 20 ]]; then ...; fi: AND: both conditions.

Example: if [[ $code -ge 500 && $code -lt 600 ]]; then

if [[ $x == "a" || $x == "b" ]]; then ...; fi: OR: either condition.

Example: if [[ "$env" == "staging" || "$env" == "prod" ]]; then

if [[ "$a" =~ ^[0-9]+$ ]]; then ...; fi: Regex match: validate input.

Example: if [[ "$port" =~ ^[0-9]+$ ]]; then

if cmd; then ...; fi: Test a COMMAND's exit status directly.

Example: if grep -q "error" app.log; then alert; fi

if cmd; then ...; else ...; fi: The full if/else form.

Example: if command -v node &>/dev/null; then echo "node found"; else echo "install node"; fi

if ...; then ...; elif ...; then ...; fi: Multiple branches.

Example: if [[ $type == "a" ]]; then A; elif [[ $type == "b" ]]; then B; fi

case "$x" in
  a) ... ;;
  *) ... ;;
esac

: Switch statement: cleaner than long if/elif chains.

Example: case "$cmd" in start) start_app ;; stop) stop_app ;; *) usage ;; esac

[ "$x" = "y" ]: Single brackets: POSIX-compatible but error-prone; prefer [[ ]].

Example: [ "$USER" = "root" ]

! command: Negate a command's success.

Example: if ! docker info &>/dev/null; then echo "docker not running"; fi

command && echo ok || echo fail: One-line conditional: chain on success/failure.

Example: npm run build && deploy || echo "build failed"

Loops

for f in *.txt; do ...; done: Iterate over glob matches: files.

Example: for f in logs/*.log; do gzip "$f"; done

for i in {1..10}; do ...; done: Fixed range loop: brace expansion.

Example: for i in {1..5}; do retry; done

for i in $(seq 1 10); do ...; done: Range loop with seq: dynamic bounds.

Example: for i in $(seq 1 "$n"); do ...

for item in "${arr[@]}"; do ...; done: Iterate over an array: quote expansion!

Example: for host in "${hosts[@]}"; do ping -c1 "$host"; done

for ((i=0; i<10; i++)); do ...; done: C-style loop: index math.

Example: for ((i=0; i<${#arr[@]}; i++)); do echo "${arr[$i]}"; done

while read -r line; do ...; done < file: Read a file line by line: the safe line loop.

Example: while read -r ip; do ban "$ip"; done < blocked.txt

while read -r line; do ...; done <<< "$var": Loop over a string's lines.

Example: while read -r u; do adduser "$u"; done <<< "$users_csv"

until condition; do ...; done: Loop UNTIL the condition is true: wait patterns.

Example: until curl -sf http://localhost:3000; do sleep 1; done

while true; do ...; done: Infinite loop: with explicit break.

Example: while true; do deploy && break sleep 5 done

break / continue: Exit the loop / skip an iteration.

Example: for f in *; do [[ "$f" == "skip" ]] && continue [[ "$f" == "stop" ]] && break done

for f in $(find . -name "*.js"); do ...; done: Loop over command output: careful with spaces.

Example: for f in $(git diff --name-only); do lint "$f"; done

Functions

myfunc() {
  echo "hi"
}

: Define a function.

Example: deploy() { npm run build scp -r dist server:/var/www }

myfunc arg1 arg2: Call with arguments: no parentheses.

Example: deploy production

$1 $2 ${@}: Arguments inside the function: $@ is all of them.

Example: log() { echo "[$(date)] $@" >> app.log }

return 1: Exit the function with a status: 0 success, nonzero fail.

Example: check_env() { [[ -n "$KEY" ]] || return 1 return 0 }

result=$(myfunc): Capture a function's stdout as a value.

Example: today=$(get_date)

function name() { ... }: Alternative syntax: works but redundant.

Example: function cleanup() { rm -rf /tmp/build; }

trap cleanup EXIT: Run a function when the script exits: guaranteed cleanup.

Example: trap 'rm -f "$tmpfile"' EXIT

export -f myfunc: Export a function to subshells: with bash -c and parallel.

Example: export -f work cat urls | xargs -P4 -I{} bash -c "work {}"

File Operations

> file: Redirect stdout to a file (overwrite).

Example: npm run build > build.log 2>&1

>> file: Append stdout to a file.

Example: echo "deployed $(date)" >> deploy.log

2> /dev/null: Discard errors: silence expected failures.

Example: rm -f "$lock" 2>/dev/null

2>&1: Merge stderr into stdout: one log.

Example: cmd > full.log 2>&1

cmd | tee file: Pipe to a file AND keep the terminal output.

Example: make build 2>&1 | tee build.log

cmd1 | cmd2: Pipe: feed one command's output into the next.

Example: ps aux | grep node | awk '{print $2}'

cat file1 file2 > merged: Concatenate into one file.

Example: cat part1.txt part2.txt > full.txt

grep -q pattern file && action: Conditional on a search: the if-command idiom.

Example: grep -q "TODO" src/*.ts && echo "todos remain"

find . -name "*.tmp" -exec rm {} \;: Find and act on matches: {} is the filename.

Example: find /tmp -mtime +7 -exec rm -rf {} \;

xargs -n1 cmd: Run a command once per input line: parallel with -P.

Example: cat urls.txt | xargs -P4 -n1 curl -I

diff -u a.txt b.txt: Unified diff: patch-style output.

Example: diff -u config.old config.new

cp -a src/ dst/: Copy recursively preserving attributes: deploy pattern.

Example: cp -a dist/ /var/www/app/

mv file file.bak: Backup a file inline.

Example: mv config.yml config.yml.bak

mkdir -p a/b && cd a/b: Create and enter in one move.

Example: mkdir -p "$HOME/tmp/deploy" && cd "$_"

basename /path/file.txt: Filename without the directory.

Example: name=$(basename "$path")

dirname /path/file.txt: Directory without the filename.

Example: dir=$(dirname "$path")

wc -l < file: Count lines: clean output without the filename.

Example: errors=$(wc -l < errors.log)

Error Handling & Debugging

set -e: Exit on ANY command failure: the #1 safety habit.

Example: set -e # stop on error

set -u: Error on undefined variables: catch typos.

Example: set -u

set -euo pipefail: The holy trinity: exit on error, undefined vars, and failed pipes.

Example: set -euo pipefail

set -x: Trace: print every command before running. The debugger.

Example: set -x ... set +x

bash -x script.sh: Run a script with tracing: no code edits.

Example: bash -x deploy.sh

cmd || exit 1: Fail explicitly with a status.

Example: npm run build || exit 1

cmd || { echo "msg" >&2; exit 1; }: Fail with a message to stderr.

Example: cd "$dir" || { echo "no dir" >&2; exit 1; }

cmd || handle_error: Run a recovery function on failure.

Example: retry() { sleep 5; deploy; } deploy || retry

cmd &: Background a command: get the prompt back.

Example: long_task &

wait: Wait for ALL background jobs to finish.

Example: sleep 5 & sleep 3 & wait echo "both done"

$?: Exit status of the LAST command.

Example: cmd if [[ $? -ne 0 ]]; then log_failure; fi

trap 'echo "killed"; exit 1' INT TERM: Handle signals: graceful Ctrl+C.

Example: trap 'cleanup; exit 1' INT

trap - ERR: Run on ANY error: error reporting.

Example: trap 'echo "error at line $LINENO" >&2' ERR

#!/usr/bin/env bash: Shebang: make the script self-executing.

Example: #!/usr/bin/env bash # then: chmod +x script.sh && ./script.sh

exit 0 / exit 1: Exit with explicit status: 0 success, 1 failure, 2 usage.

Example: if [[ $# -lt 1 ]]; then usage; exit 2; fi exit 0

>&2 echo "error": Print to stderr: keep errors separate from output.

Example: >&2 echo "build failed"

command -v node: Check a tool is installed: before using it.

Example: command -v docker >/dev/null || { echo "install docker"; exit 1; }

set -o pipefail: Pipe fails if ANY stage fails: not just the last.

Example: set -o pipefail cmd | grep x # fails if cmd fails

Frequently asked questions

What is the difference between single and double quotes in Bash?

Single quotes preserve every character literally: no expansion happens. Double quotes allow variable expansion and command substitution, so "$name" prints the value while '$name' would print the literal text.

How do I write an if statement in Bash?

Use if [[ condition ]]; then ... elif ...; then ... else ...; fi. Double brackets [[ ]] are safer than single [ ] and support regex with =~, pattern matching, and string comparison operators.

How do I loop over files?

Use for f in *.txt; do echo "$f"; done to iterate over glob matches. For line-based input use while IFS= read -r line; do ...; done < file, which preserves spaces and handles missing trailing newlines.

How do I debug a Bash script?

Run bash -x script.sh to trace every command as it executes, or add set -x inside the script and set +x to disable. Use set -e to exit on errors and set -u to error on undefined variables.