Go’s one loop and range.

For loops and iteration protocols and While loops and termination showed the forms of for one at a time. Go has no other loop keyword, so here are all four together. for i := 0; i < 3; i++ counts, with a start, a condition, and an update. for fuel < 50 has a condition only, and works as a while loop. for with nothing after it has no condition, and runs until a break or a return ends it. for i, v := range x reads x one element at a time. break, continue, and labels work with every form, as Break, continue, and early return showed.

The range form has one rule that the other forms do not have. The expression after range is evaluated once, before the first pass. The condition of a three-part loop is evaluated before every pass. So for i := range carsReady() calls carsReady once. If carsReady returns 3, the loop then gives i the values 0, 1, and 2, because range over an integer n counts from 0 up to n − 1 (since Go 1.22).

A function, as in From source to a running program, is a named group of lines; carsReady below prints a line and returns 3.

Go’s for has four forms. In the range form, the expression after range is evaluated once, before the first pass.

For loops and iteration protocols showed that the range variable holds a copy of the element. The same is true when the element is a struct: a value that groups named fields, such as Car{Plate: "KA-31", Km: 41200}. Copying a struct copies every field, so car.Km = 0 inside the loop changes the copy, not the car in the slice. Write cars[i].Km = 0 instead. Records, structs, and objects, a later lesson, covers structs in full.

An array is copied in a larger way. An array is a value with a fixed number of elements, such as [3]int, and assigning it copies every element. range evaluates the array once, and that value is a copy of the whole array. So when the loop body changes a later element, the range variable still shows the old value when the loop reaches it.

A slice is different. A slice refers to elements stored elsewhere, so range copies only the slice and reads each element as it is when its pass begins. To read an array as it changes, range over fuel[:], a slice of all of fuel’s elements, or over &fuel, a pointer: a value that leads to fuel itself.

Each range variable is a copy of one element, and range over an array reads a copy of the whole array. Write through the index, and range over arr[:] or &arr to see changes.

A map stores values under keys. map[string]int{"KA-31": 41200} stores 41200 under the key "KA-31", and km["KA-31"] reads it. Maps, dictionaries, and hashing, a later lesson, shows how a map finds a key. Here one thing matters. for plate, driven := range km gives each key and its value once, in an order that the language does not fix. Go even chooses a different order in different runs, on purpose, so that no program comes to depend on one order. With one variable, for plate := range km gives the keys only.

Changing the map during the loop has two rules. Deleting is allowed: delete(km, plate) removes an entry, and an entry deleted before the loop reaches it is not produced. Adding is allowed too, but an entry added during the loop may be produced or may be skipped, and that can differ between runs. Do not count on either.

When the order matters, as on a screen or in a test, put the keys in a slice, sort the slice, and range over it. sort.Strings sorts a slice of strings in place.

range over a map gives each entry once, in an order that changes between runs. Deleting during the loop is safe; to print in a fixed order, sort the keys first.

Each pass of a loop sets its loop variables. Since Go 1.22, each pass declares new ones: the plate of pass 1 and the plate of pass 2 are two different variables. This matters only when something keeps a variable after its pass ends.

A function literal is a function written as a value, without a name, such as func() { fmt.Println("return", plate) }. When it uses plate, it keeps that variable itself, not a copy of its value. Together they form a closure. Closures and captured variables, a later lesson, covers closures in full. Below, calls is a slice of functions, each pass appends one closure, and call() runs one. Because each pass has its own plate, the three closures print three different plates.

Before Go 1.22, a loop had one set of variables, and every pass wrote into them. All three closures kept the same plate, which held ZE-12 after the loop, so they printed ZE-12 three times. You will meet this in older code: a line plate := plate inside the loop made a new variable for each pass by hand. Go 1.22 and later do not need it. A goroutine, a function running on its own and started with go, had the same problem when it used a loop variable, and the same rule now fixes it.

Since Go 1.22, each pass of a for loop has its own variables, so a closure or goroutine keeps the values of its own pass. Before Go 1.22, all passes shared one set of variables.

range reads more than slices and arrays.

Over a string, range gives runes, not bytes. The first variable is the byte position where each rune starts, so it jumps by 2 over ö in "Köln", as Text, bytes, and Unicode showed. Use it as a position in the string, never as a count of letters.

Over a channel, range receives values until the channel is closed. Channels belong to a later topic on goroutines.

Over a function: since Go 1.23, range can read an iterator function, a function that hands out values one at a time. It takes another function, usually named yield, and calls it once for each value. The standard library returns iterator functions. slices.Backward(s) gives the index and element of s from the last element to the first. maps.Keys(m) gives the keys of a map, in the map’s changing order. slices.Sorted(maps.Keys(km)) collects those keys into a sorted slice: a shorter form of the sorting code in the map section.

Over a string, range gives byte positions and runes; over a channel, values until it is closed; over an iterator function, each value it passes to yield.

Range loops in real programs fail in four ways that the compiler accepts.

Changing a struct copy. for _, b := range bookings { b.Paid = true } changes nothing that lasts. Write bookings[i].Paid = true. When the slice holds pointers, as []*Booking, b is a copy of a pointer, so b.Paid = true does change the booking.

Taking &v of the range variable. Since Go 1.22, &car points to that pass’s copy, so the value read through it is right, but a change through it never reaches the slice. Before Go 1.22, &car was the same address in every pass, so every kept pointer showed the last element. Point at &cars[i] instead, as below.

Printing in map order. Log lines and test output built in range order change from run to run, so a test that compares them with one expected text passes on some runs and fails on others. Sort the keys first, or compare the results as a map.

Ranging over a large array value. for _, v := range grid, where grid is an array such as [100000]int, works on a copy of every element. It reads old values, as in the copies section, and the copy can also cost time. Range over &grid or grid[:].

Write through the index, point at s[i] rather than at the range variable, sort map keys before output, and range over &arr instead of a large array value.

Decide what each car variable holds before you add anything. The next lesson, Function calls, shows what happens when a function is called.