Inside {{range .Items}} in a Go template, what happens to dot, and how do you reach the top-level value?

## Dot is a cursor, and some actions move it At the start of execution dot is the value handed to `Execute`. Two actions move it for the duration of their body, and this is the single most common source of confusion in Go templates. ### range ``` {{range .Items}}{{.SKU}} x{{.Qty}} {{end}} ``` `range` accepts an array, slice, map, channel (and, in recent Go, an integer or an iterator function). For each element it executes the body once with **dot set to that element**. Inside the body, `.Items` no longer exists — dot is an element, not the outer struct. Referring to an outer field there produces an execution error such as `can't evaluate field Currency in type main.Item`. With a map, the body runs once per key in sorted key order when the keys are of a basic ordered type — a deliberate difference from Go's randomised `for range` over a map, and useful when you are rendering something that must be reproducible. `range` also takes an `{{else}}` branch, which runs exactly once when the ranged value has **zero** iterations — an empty or nil slice, an empty map: ``` {{range .Items}}...{{else}}No items.{{end}} ``` ### with ``` {{with .Customer}}Hi {{.Name}}{{end}} ``` `with` evaluates its pipeline once. If the value is *empty* (the same emptiness rule `if` uses: false, 0, a nil pointer or interface, a zero-length array, slice, map or string) the body is skipped entirely and the optional `{{else}}` branch runs. Otherwise dot is set to that value for the body. So `with` is simultaneously a nil guard and a scope shortener, which is why it reads so well for optional nested structs. ## Getting back out: $ `$` is a variable the template engine pre-declares at the start of each execution and sets to the data argument. It is never rebound by `range` or `with`, so it is the reliable root: ``` {{range .Items}}{{.SKU}} priced in {{$.Currency}} {{end}} ``` One caveat worth knowing: `$` is the root *of the current execution*. When a nested template is invoked with its own argument, `$` inside it is that argument, not the outermost payload. If you need the outer root deeper down, pass it explicitly. ## Getting back out: your own variables A template variable is declared with `:=` and lives to the end of the enclosing block: ``` {{$cur := .Currency}} {{range .Items}}{{.SKU}} {{$cur}} {{end}} ``` This is often clearer than `$.Currency` because it names the thing at the point where the reader can see what it refers to, and it survives being moved into a nested template later. Range can declare variables of its own: - `{{range $item := .Items}}` — one variable, the element. - `{{range $i, $item := .Items}}` — index (or map key) and element. Dot is still rebound in both forms; the variables are an addition, not a replacement. Many teams write `{{range $i, $item := .Items}}` and then use `$item.SKU` throughout, precisely so that nothing in the body depends on what dot happens to be. ## Why this bites The failure is asymmetric and that is what makes it interview-worthy. If the outer field is a struct field, the mistake is loud: `Execute` returns an error and the render stops. If dot inside the loop is a `map[string]any` — very common in payloads assembled by hand — the missing key is not an error by default; it renders as `<no value>` and the wrong output ships. Same typo, two completely different consequences. Nesting compounds it: inside `{{range .Orders}}{{range .Lines}}`, dot is a line, `$` is still the whole payload, and the order in between is reachable only if you named it — `{{range $order := .Orders}}` — before descending. That habit, naming the level you will need later, is the practical takeaway. ## Quick summary - `range` sets dot per element; `{{else}}` covers zero iterations. - `with` sets dot to a non-empty value and skips the body otherwise. - `$` is the execution's root argument and is never rebound by those actions. - Named variables (`{{$x := ...}}`, `{{range $i, $v := ...}}`) are the readable escape from dot entirely.