Hands-on lab — Day 12: Shell Scripting: Variables, Loops, and Conditionals

#!/usr/bin/env bash
# Day 012 lab — completed reference implementation.
#
# backup_notes.sh — summarize a directory of notes before you archive it.
# It takes a directory as its first argument (defaulting to the current
# directory), counts the regular files in it, and prints a breakdown by file
# extension. This is the kind of inventory you would generate before backing
# up or cleaning out a folder.
#
# Usage:
#   bash backup_notes.sh [DIRECTORY]
#   bash backup_notes.sh            # summarizes the current directory
#   bash backup_notes.sh ~/notes    # summarizes ~/notes
set -euo pipefail

# --- Argument with a sensible default -------------------------------------
# Take the first argument, or fall back to "." (the current directory).
target="${1:-.}"

# --- Validate the input ---------------------------------------------------
# A tool that silently accepts nonsense is a trap: fail loudly instead.
if [ ! -d "${target}" ]; then
  echo "Error: '${target}' is not a directory" >&2
  exit 1
fi

# --- A small, reusable function -------------------------------------------
# Print the extension of a filename, or "(no extension)" when it has none.
extension_of() {
  local name="$1"
  if [ "${name}" = "${name%.*}" ]; then
    # No dot in the name at all (e.g. README).
    echo "(no extension)"
  else
    # Strip everything up to and including the last dot.
    echo "${name##*.}"
  fi
}

# --- Loop over the files, counting as we go -------------------------------
total=0
extensions=""
for path in "${target}"/*; do
  # Skip anything that is not a regular file (directories, or an empty dir
  # where the glob did not expand to a real path).
  [ -f "${path}" ] || continue
  total=$((total + 1))
  extensions="${extensions}$(extension_of "$(basename "${path}")")
"
done

# --- Print the report -----------------------------------------------------
echo "=== Notes summary ==="
echo "Directory: ${target}"
echo "Total files: ${total}"
echo "By extension:"
if [ "${total}" -eq 0 ]; then
  echo "  (none)"
else
  # sort groups identical extension lines together; uniq -c collapses each
  # group into "count extension"; the loop reformats it for the report.
  printf '%s' "${extensions}" | sort | uniq -c | while read -r count ext; do
    echo "  ${ext}: ${count}"
  done
fi
echo "=== End of summary ==="

month,amount
July,1200

Try the loop idea

# Weekly sync notes

Read me first

# Roux: butter + flour

Buy milk and eggs

lesson_id: D012
day: 12
kind: shell-scripting
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-012-shell-scripting-variables-loops-and-conditionals
run_commands:
  - bash examples/backup_notes.sh examples/sample-notes
  - bash starter/backup_notes.sh examples/sample-notes
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/backup_notes.sh  # optional: reset your work'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), bash 3.2.57; bash tests/run_tests.sh -> 11 checks, 0 failure(s).'

# Dependencies — Day 012 lab

**None beyond a POSIX shell.** This lab has no installable dependencies:

- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution)
- Standard OS utilities: `basename`, `sort`, `uniq`, `printf`, `mktemp` — all
  part of the base system on macOS and Linux.

## Optional: ShellCheck

[ShellCheck](https://www.shellcheck.net/) is a free, open-source static
analyzer for shell scripts. It is **entirely optional** — the lab is fully
completable without it — but it is an excellent habit to adopt. If you want to
try it:

- macOS: `brew install shellcheck`
- Debian/Ubuntu: `sudo apt install shellcheck`
- Fedora: `sudo dnf install ShellCheck`

Then run `shellcheck examples/backup_notes.sh` to see it in action. There is no
paid version; ShellCheck is free.

The companion formatter **shfmt** (also free and open source) is likewise
optional — it rewrites a script into a consistent style — and is not needed to
finish the lab.

There is deliberately no `requirements.txt` or `package.json` here: this lab
runs on a factory-fresh macOS or Linux machine with nothing installed.

#!/usr/bin/env bash
# Day 012 lab — YOUR working file. Build backup_notes.sh step by step.
#
# This skeleton already runs, but it is deliberately incomplete: five numbered
# exercises below add one real feature each. Complete them in order. After each
# one, run the script to see your progress:
#
#     bash starter/backup_notes.sh examples/sample-notes
#
# The finished result should match examples/backup_notes.sh and pass the tests
# (bash tests/run_tests.sh). Try each exercise yourself before peeking.
set -euo pipefail

# ===========================================================================
# Exercise 1 — Accept a directory argument, with a sensible default.
# Replace the line below so that `target` is the first argument ($1), or "."
# (the current directory) when no argument is given. Use the ${1:-default}
# form:   target="${1:-.}"
# ---------------------------------------------------------------------------
target="."
# ===========================================================================

# ===========================================================================
# Exercise 2 — Validate the input.
# Right now the script trusts whatever it is given. Add a conditional that
# checks the target is a directory, and if not, prints an error to standard
# error and exits with a non-zero code. Uncomment and complete:
#
#   if [ ! -d "${target}" ]; then
#     echo "Error: '${target}' is not a directory" >&2
#     exit 1
#   fi
# ===========================================================================

# ===========================================================================
# Exercise 3 — Write the extension_of function.
# This helper should print the extension of a filename, or "(no extension)"
# when there is no dot. Replace the stub body below with:
#
#   local name="$1"
#   if [ "${name}" = "${name%.*}" ]; then
#     echo "(no extension)"
#   else
#     echo "${name##*.}"
#   fi
# ---------------------------------------------------------------------------
extension_of() {
  echo "file" # <-- replace this stub with the real logic (Exercise 3)
}
# ===========================================================================

# ===========================================================================
# Exercise 4 — Loop over the files and count them.
# Fill in the loop body so that, for each REGULAR file in "${target}", it:
#   (a) skips non-files with:   [ -f "${path}" ] || continue
#   (b) adds one to total:      total=$((total + 1))
#   (c) records the extension:  append extension_of "$(basename "${path}")"
#       to the `extensions` variable, one per line (see examples/ for the
#       exact idiom).
# ---------------------------------------------------------------------------
total=0
extensions=""
for path in "${target}"/*; do
  : # <-- replace this no-op with the loop body (Exercise 4)
done
# ===========================================================================

# --- Print the report -----------------------------------------------------
echo "=== Notes summary ==="
echo "Directory: ${target}"
echo "Total files: ${total}"
echo "By extension:"
if [ "${total}" -eq 0 ]; then
  echo "  (none)"
else
  # =========================================================================
  # Exercise 5 — Print the by-extension breakdown.
  # Turn the collected `extensions` into sorted counts. Replace the echo
  # stub below with the pipeline:
  #
  #   printf '%s' "${extensions}" | sort | uniq -c | while read -r count ext; do
  #     echo "  ${ext}: ${count}"
  #   done
  # -------------------------------------------------------------------------
  echo "  (fill in Exercise 5 to see the breakdown)"
  # =========================================================================
fi
echo "=== End of summary ==="

# Scripting worksheet — predict, then run

The best way to know you understand a loop is to predict what it will do
*before* you run it. Do the prediction below by hand first; only then run the
script and compare. A wrong prediction you understand afterwards teaches more
than a lucky right one.

## The input directory

The lab ships a sample directory at `examples/sample-notes/`. It contains
exactly these files:

```text
sample-notes/
├── shopping.txt
├── ideas.txt
├── meeting.md
├── recipe.md
├── budget.csv
└── README
```

## Step 1 — Predict (fill this in before running anything)

Using your understanding of how `backup_notes.sh` counts files by extension,
predict its report for `examples/sample-notes/`:

- Total files: __________
- `txt`: __________
- `md`: __________
- `csv`: __________
- `(no extension)`: __________

Then predict the order the extensions will be printed in. (Hint: the script
pipes the extensions through `sort` before counting — so what determines the
order?)

Predicted order (top to bottom): ________________________________________

## Step 2 — Run and compare

From the lab directory, run your completed script against the sample:

```bash
bash examples/backup_notes.sh examples/sample-notes
```

(Use `examples/backup_notes.sh` to check against the reference, or
`starter/backup_notes.sh` once you have completed all five exercises — they
should produce identical output.)

Write down the actual result:

- Total files: __________
- `txt`: __________
- `md`: __________
- `csv`: __________
- `(no extension)`: __________

## Step 3 — Reconcile

- Did your totals match? If not, which file did you miscount, and why?
- Did the *order* match your prediction? Explain in one sentence what `sort`
  did to the extension list, and where `(no extension)` landed relative to the
  letters — and why.
- The `README` file has no dot in its name. Trace how the `extension_of`
  function decides it has "(no extension)": what does `"${name%.*}"` produce
  for `README`, and why does that equal `README` itself?

## Step 4 — A second prediction (harder)

Suppose you add two more files to the directory: `photo.JPG` (uppercase
extension) and `.gitignore` (a dotfile whose name begins with a dot). Predict:

- Will `photo.JPG` be counted under `JPG` or `jpg`? (The script does not change
  case — so which?)
- Will `.gitignore` be counted, and if so, under what extension? Think about
  what `"${name%.*}"` does to a name that starts with a dot, and check your
  answer by creating the files and re-running. Note anything that surprised
  you — this is exactly the kind of edge case real scripts must handle.

#!/usr/bin/env bash
# Tests for the Day 012 lab. Run from anywhere:
#   bash tests/run_tests.sh
#
# Builds a temporary directory with a KNOWN set of files, runs the completed
# reference script (examples/backup_notes.sh) against it, and checks that the
# reported counts are exactly right. Also checks the empty-directory case and
# the "not a directory" error path. Cleans up the temp directory on exit.
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
script="${lab_dir}/examples/backup_notes.sh"
failures=0
checks=0

check() {
  local label="$1" ok="$2"
  checks=$((checks + 1))
  if [ "${ok}" = "yes" ]; then
    echo "  ok: ${label}"
  else
    echo "  FAIL: ${label}"
    failures=$((failures + 1))
  fi
}

# A temp workspace we always clean up, even if a check fails.
work="$(mktemp -d)"
cleanup() { rm -rf "${work}"; }
trap cleanup EXIT

# --- Fixture: a known set of files ----------------------------------------
# 3 x .txt, 2 x .md, 1 x .csv, 1 file with no extension  => 7 files total.
fixture="${work}/notes"
mkdir -p "${fixture}"
printf 'a\n' >"${fixture}/one.txt"
printf 'b\n' >"${fixture}/two.txt"
printf 'c\n' >"${fixture}/three.txt"
printf 'd\n' >"${fixture}/alpha.md"
printf 'e\n' >"${fixture}/beta.md"
printf 'f\n' >"${fixture}/data.csv"
printf 'g\n' >"${fixture}/README"
# A subdirectory that must NOT be counted as a file.
mkdir -p "${fixture}/subfolder"

echo "Testing ${script} against a known fixture ..."

if ! out="$(bash "${script}" "${fixture}" 2>&1)"; then
  check "script exits 0 on a valid directory" "no"
  echo "${out}" | sed 's/^/    /'
else
  check "script exits 0 on a valid directory" "yes"
fi

# Header and footer present.
echo "${out}" | grep -q '^=== Notes summary ===$' && check "prints header" "yes" || check "prints header" "no"
echo "${out}" | grep -q '^=== End of summary ===$' && check "prints footer" "yes" || check "prints footer" "no"

# Total files should be exactly 7 (the subfolder is excluded).
echo "${out}" | grep -q '^Total files: 7$' && check "counts 7 total files (excludes subdirectory)" "yes" || check "counts 7 total files (excludes subdirectory)" "no"

# Per-extension counts, exactly.
echo "${out}" | grep -q '^  txt: 3$' && check "counts 3 .txt files" "yes" || check "counts 3 .txt files" "no"
echo "${out}" | grep -q '^  md: 2$' && check "counts 2 .md files" "yes" || check "counts 2 .md files" "no"
echo "${out}" | grep -q '^  csv: 1$' && check "counts 1 .csv file" "yes" || check "counts 1 .csv file" "no"
echo "${out}" | grep -q '^  (no extension): 1$' && check "counts 1 file with no extension" "yes" || check "counts 1 file with no extension" "no"

# --- Empty directory: total 0, still exits 0 ------------------------------
empty="${work}/empty"
mkdir -p "${empty}"
if empty_out="$(bash "${script}" "${empty}" 2>&1)"; then
  check "empty directory exits 0" "yes"
else
  check "empty directory exits 0" "no"
fi
echo "${empty_out}" | grep -q '^Total files: 0$' && check "empty directory reports 0 files" "yes" || check "empty directory reports 0 files" "no"

# --- Error path: not a directory should exit non-zero ---------------------
if bash "${script}" "${work}/does-not-exist" >/dev/null 2>&1; then
  check "missing directory exits non-zero" "no"
else
  check "missing directory exits non-zero" "yes"
fi

echo
echo "${checks} checks, ${failures} failure(s)."
[ "${failures}" -eq 0 ]