🔁Module 6 — Loops

Provisioning account for alice
Provisioning account for bob
Provisioning account for carol

What to read out of it: three words in, three iterations out, in list order. Nothing ran in parallel — iteration 2 started only after iteration 1's body finished (parallel fan-out is Module 12's &). If a body command failed mid-round, the loop would carry on to the next item — loops inherit bash's carry-on default (Module 3), and Part D returns to what production does about that.

attempt 1
attempt 2
attempt 3
attempt 4
attempt 5
tick 1
tick 2
tick 3
3 and a remainder of 1

What to read out of it: the one-line loop form (; do … ; done) is the same grammar compacted — semicolons standing in for newlines (Module 3's glue). The last line is the arithmetic preview earning its keep: 10 / 3 is 3, not 3.33… — bash truncates, silently. Scripts that compute percentages or averages in bash arithmetic are quietly wrong in the decimals; know the limitation now, reach for awk later.

found: logs/app.log
found: logs/db backup.log
found: logs/web.log
processing: logs/*.zip

What to read out of it: line 2 is the quiet triumph — db backup.log, spaces included, arrived as one item with no quoting gymnastics: glob-built lists are split-safe. Line 4 is the landmine: no zip files exist, so the loop ran once anyway, holding the raw pattern as if it were a filename. In a report loop this prints nonsense; in a rm/mv loop it acts on nonsense. Production loops over globs either guard ([ -e "$f" ] || continue) or set shopt -s nullglob at the top of the script — pick one and be consistent.

The direct answer: three constructs. for var in list; do …; done (once per word); while command; do …; done (repeat while the guard succeeds); until command; do …; done (repeat while it fails). Plus bash's C-style counter: for ((i=1; i<=10; i++)); do …; done. The 1-to-10 script: for i in {1..10}; do echo "$i"; done.

Going deeper: say what the list is — the product of expansion, splitting, and globbing — because every follow-up trap question ("what if a filename has a space?") is really asking that; and note while/until take a command whose exit status is the condition, the same mechanism as if (Module 5).

The details that separate candidates: offering {1..10} and the C-style form unprompted, with the rule for choosing (fixed range → brace; computed bound → C-style, since {1..$n} does not expand — brace expansion runs before variables exist, Module 2's pipeline order); and mentioning seq only to say modern bash rarely needs it.

The direct answer: for f in /path/*.log; do … "$f" …; done — glob builds the list, each match is one word regardless of spaces; quote "$f" everywhere in the body.

Going deeper: name the two classic failures — parsing ls output instead of globbing (splits on spaces, mangles odd names; the same disease as looping over cat, Part C) and the unmatched-glob pass-through (guard with [ -e "$f" ] || continue or shopt -s nullglob). For recursive trees, find + while read (Part C) or bash's globstar ** are the tools.

The details that separate candidates: stating why glob lists are split-safe (filename expansion happens after word splitting in the pipeline, and its results are never re-split) — mechanism, not folklore; plus the habit of ./-prefixing or using full paths so a filename beginning with - cannot masquerade as an option to the body's commands.

countdown: 3
countdown: 2
countdown: 1
liftoff
poll 1
poll 2
poll 3

What to read out of it: the countdown's guard measured n, and the body moved n — that pairing is what ends a while loop. Before liftoff, the guard ran a fourth time (n=0, -gt 0 fails) — guards always run once more than the body. The until loop polled exactly three times: it keeps going while its guard fails, and [ "$n" -gt 3 ] failed for n=1,2,3 then passed for n=4. If you ever misread an until as "loop while true," the printed poll count is the tell.

checking web-1
checking web-2
skipping db-1 (not a web host)
checking web-3
attempt 1: not yet
attempt 2: not yet
attempt 3: not yet
found it at attempt 4

What to read out of it: continue let db-1 announce itself and step aside — web-3 still got its turn; the round survived the skip. break ended the second loop with six attempts unspent — attempts 5–10 simply never printed. Note the division of labor: case recognized the shape (db-*), continue did the steering — Module 5 and this module composing, which is how real scripts read.

The direct answer: break exits the entire loop at once; continue ends only the current iteration and moves to the next. Both work in for, while, and until.

Going deeper: give each its canonical shape — break for searches ("stop at first match") and retry loops ("stop on first success"); continue for filters ("skip items that don't apply"). Both take an optional numeric argument for nested loops: break 2 exits two levels — powerful, rarely wise (a comment is mandatory when you use it).

The details that separate candidates: knowing continue in a while loop still runs the guard next (so a continue above the counter-update line can create an infinite loop — the B1 analogy's broken connection, self-inflicted); and that break/continue affect only loops — in a case you exit a branch with ;;, and mixing those up is a syntax error interviewers bait with.

The direct answer: for over lists (words, ranges, globs), while on a repeating verdict, until on a repeating failure, steered by break/continue — each with do…done bodies.

Going deeper: choose by data shape — known list → for; condition-driven → while/until; file lines → while read (never for — the trap has its own section in this module). Show the retry idiom that fuses the family: until curl -fsS "$url" >/dev/null 2>&1; do sleep 2; done — Modules 3, 4, and this one in a single line.

The details that separate candidates: mentioning that loop bodies inherit carry-on-past-failure semantics, and what production does about it (guards in the body, or set -e with its loop subtleties, Module 14); plus the resource nuance that while read < file opens the file once, not per-iteration — a preview of why Part C's pattern scales to gigabyte files.

would archive: [monthly]
would archive: [report.txt]
would archive: [notes.txt]
would archive: [monthly report.txt]
would archive: [notes.txt]

What to read out of it: two lines in, three archive candidates out of the for-loop — the brackets (Module 2's probe style) show exactly where the split fell. The while-loop below it got both lines intact. Now imagine the body was mv "$f" /archive/ — the for-version just tried to archive two files that don't exist, and if a file named monthly happened to exist, it archived the wrong file with no error at all. That silent last case is why this trap has a section, not a footnote.

no -r:   [C:newfolder]
with -r: [C:\new\folder]

What to read out of it: without -r, the backslashes were consumed as escape prefixes — \n in the data became n, and nobody was told. With -r, the line arrived byte-for-byte. Any data that can contain backslashes — Windows paths, regexes, JSON fragments — is corrupted by a bare read. There is no situation in modern scripting where you want the unescaping, which is why ShellCheck (SC2162) flags every read without -r: the correct spelling is simply read -r, always.

The direct answer:

#!/bin/bash while IFS= read -r line; do printf '%s\n' "$line" done < "$1"

Going deeper: justify every token, because that is what the question actually tests — read's per-line verdict drives while; < "$1" streams the file once; -r preserves backslashes; IFS= preserves edge whitespace; printf '%s\n' rather than echo prints hostile lines faithfully (Module 2's echo caveat). Then name the anti-pattern you did not write: for line in $(cat file) splits on all whitespace and glob-expands — words, not lines.

The details that separate candidates: handling the last line when the file lacks a trailing newline (while IFS= read -r line || [ -n "$line" ] — read returns non-zero but still fills the variable); and reading from a command instead of a file with done < <(command) (process substitution, Module 12) rather than piping into while — because a piped while runs in a subshell and its variables vanish (Module 12's headline gotcha, worth naming a module early).

The direct answer: for (lists, ranges, globs), while (repeat on success), until (repeat on failure), plus C-style counting — with break/continue steering all of them.

Going deeper than the published version — the wrong-choice map: for is wrong for file lines (splitting) and for unbounded conditions (it needs a finite list up front); while true with a manual break is wrong where until condition says the same thing declaratively; C-style is wrong in #!/bin/sh scripts (bashism — dash rejects it, Module 1 C2's dialect trap again).

The details that separate candidates: the clipboard principle stated once, cleanly — a for-list is fully built by expansion before iteration begins, so mutating the list mid-loop does not change the round — and its corollary, that {1..$n} cannot work (brace expansion precedes variable expansion). Mechanism answers outrank syntax answers on every one of these.

Diagnosis. The no-match pass-through (A3): the fresh environment had no logs yet, for f in /var/log/app/*.log iterated once with the literal pattern, and the body faithfully compressed a file it first created by redirecting into "$f".gz. The loop worked exactly as written; the written thing assumed matches always exist.

Work the steps: reproduce in an empty dir: for f in *.log; do echo "[$f]"; done → [*.log]. One line, whole bug.

Fix and prevention: shopt -s nullglob at the top (zero matches → zero iterations), or open the body with [ -e "$f" ] || continue. Then delete the impostor file — carefully: it is named with a glob character, so quote it everywhere: rm '/var/log/app/*.log.gz' (unquoted, that rm is a Module 2 globbing incident waiting to happen — on a now-populated directory).

Diagnosis. Two mutilations, two missing amulets (C1/C2). The paired cannot-stat errors are word splitting's fingerprint (Module 2 B1) — the loop is for p in $(cat manifest.txt). The eaten backslashes are read without -r — so somewhere a second reader, or the rewrite of the first, dropped the escape guard.

Work the steps: run the manifest through both list-builders with the bracket probe (Exercise 6.6's exact experiment) and compare item counts against wc -l manifest.txt; then Exercise 6.7's -r test on a backslashed line.

Fix and prevention: the canonical reader — while IFS= read -r path; do cp -- "$path" "$dest/"; done < manifest.txt — plus the || [ -n "$path" ] guard if manifests may lack trailing newlines. Prevention is mechanical: ShellCheck flags both the cat-loop (SC2013) and the bare read (SC2162); wire it into CI and this ticket class retires.

Diagnosis. Two stacked faults. The hang-forever part is a missing bound (E1's rule): an until with no attempt limit turns any persistent failure into an infinite stakeout. The "DB was up" part means the guard itself was failing for a different reason — with DB_HOST unset (Module 2's silent empty expansion), pg_isready -h with no value errors out with a usage failure — non-zero forever, truth never consulted.

Work the steps: run the guard alone and read its actual complaint: pg_isready -h "$DB_HOST"; echo $? — the stderr line names the missing argument. printf '[%s]\n' "$DB_HOST" confirms the empty jar.

Fix and prevention: validate inputs before looping ([ -n "$DB_HOST" ] || { echo "DB_HOST unset" >&2; exit 2; }); bound the loop (for i in {1..60}; do pg_isready … && break; sleep 5; done with a final "gave up" exit); and distinguish the guard's failure kinds if the tool provides them — Module 3's not-found-vs-couldn't-look discipline applies to readiness probes too.

Diagnosis. Every fleet sin from D1's callout in one line: serial round (40 minutes of single-file SSH), no per-item failure isolation (the refused connection's failing verdict ended the round via the script's set -e), no record of outcomes (success and failure both vanished into scrollback), and the hostlist read by the splitting-vulnerable cat-loop (dormant until a hostname needs escaping, but present).

Work the steps: immediate triage needs the missing record — rerun read-only checks in a loop that writes files: while IFS= read -r host; do ssh -o ConnectTimeout=5 "$host" 'check-patch' && echo "$host" >> ok.txt || echo "$host" >> failed.txt; done < hosts.txt.

Fix and prevention: rebuild the round with the production shape: while read over the manifest; per-host || { echo "$host" >> failed.txt; continue; }; outcomes logged to files that feed the retry; a connect timeout so dead hosts cost 5 seconds, not a hang; and batched parallelism when Module 12's wait arrives. The design goal, stated plainly in the runbook: a patch round must be interruptible, resumable, and auditable — three properties, three files, one while-loop.