Course outline

01 · Getting Started6/6

02 · Variables, Types & Control Flow6/6

03 · Functions & Composite Types6/6

04 · Methods, Interfaces & Errors6/6

05 · Packages, Modules & Concurrency Intro6/6

06 · Your First Real Program6/6

07 · Testing & Debugging in Go6/6

08 · Capstone — Ship a Real Tool7/7

09 · Generics6/6

10 · Concurrency in Practice6/6

11 · Language Depth II6/6

12 · Standard Library Toolkit6/6

13 · Building Web Services6/6

14 · Working with Databases6/6

15 · Advanced Runtime & Tooling6/6

16 · Building a Terminal Dashboard with Bubble Tea5/5

17 · Closing the Loop2/2

Stage 1 · Code

Language Depth II

Iterating Collections

Learn the everyday Go patterns for walking through slices, maps, and strings, and understand why byte-by-byte thinking can quietly break the moment real text enters the picture.

16 min readThe Complete Go EngineerCode

Walking Through Slices

Iteration is just repeated attention: look at one item, then the next, then the next. In Go, the most common way to do that is for range. For slices, range can give you both the index and the element value.

Goiterating-over-a-slice-with-range.go

13 linesLn 1, Col 1Go

On each pass, `index` tells you where you are and `region` gives you the element at that position. This is the most common slice iteration shape in everyday Go.

If you only need one of those two values, you can ignore the other with _. That keeps the loop honest about what it actually uses.

Gokeeping-only-the-part-you-need.go

9 linesLn 1, Col 1Go

The blank identifier `_` means 'I am intentionally ignoring this value.'

Iterating Maps Carefully

You can also use range with maps, but there is one rule you must internalize early: map iteration order is intentionally not stable. Go deliberately avoids promising a consistent order so programmers do not accidentally depend on it.

That means a map is for lookup, update, and membership checks. It is not a presentation-order container. If you need a stable report order, collect the keys, sort them, then read the map through that sorted list.

Gomap-iteration-versus-stable-sorted-output.go

31 linesLn 1, Col 1Go

The first loop visits every map entry in unspecified order. The second loop creates a predictable alphabetical order by sorting the keys first.

Do not treat today's map order as a contract

If your program appears to print map entries in the same order a few times, that is luck, not a guarantee. Production code should never rely on map iteration order.

Map Lookups and the Zero-value Trap

Map lookup has its own iteration-adjacent habit you need constantly: the comma-ok form. A plain lookup like m[k] returns the zero value of the map's value type when the key is missing. That is convenient, but it can also lie to you.

Gowhy-`v,-ok-:=-m[k]`-matters.go

22 linesLn 1, Col 1Go

Both plain lookups print `0`, but they mean different things. `cable` exists with a stored value of `0`. `keyboard` is missing entirely. Only the comma-ok form can tell those situations apart reliably.

Strings Bytes and Runes

Strings need slower, more careful thinking than slices of plain numbers. A Go string is a sequence of bytes. Human text, however, is made of characters, and many characters need more than one byte in UTF-8. That gap is where beginners get tricked.

If you iterate a string byte by byte, you are walking its raw storage. Sometimes that matches human-readable characters, especially for simple ASCII text. But the moment accented letters, emoji, or many non-English scripts appear, one character may occupy multiple bytes. Byte iteration then splits one visible character into fragments.

Gobyte-iteration-and-rune-iteration-are-not-the-same.go

20 linesLn 1, Col 1Go

The manual byte loop visits every byte. The `range` loop over a string decodes UTF-8 and gives you each rune with the byte index where that rune begins.

Tracing Byte vs Rune Iteration

Gofollowing-`aé🙂`-through-two-different-loops.go

18 linesLn 1, Col 1Go

Byte iteration is about storage units. Rune iteration is about decoded Unicode code points. When text matters, those are very different jobs.

Use range for normal string traversal

If your goal is to process human text character by character, for _, r := range text is usually the right default. Drop to byte-level iteration only when you truly care about the raw UTF-8 bytes.

Quiz

Quiz & Practice

Question 1 / 3

Why should you not rely on map iteration order in Go?

Practice

CountPresentEasy

Write a function `CountPresent(inventory map[string]int, key string) string`. If `key` exists in the map, return `present:<value>`. If it does not exist, return `missing`. Use the comma-ok idiom.

Gosolution.go

Summary

for range is the standard way to iterate slices, maps, and strings in Go.
Map iteration order is intentionally unspecified, so sort keys first when stable output matters.
Use the comma-ok idiom on map lookups when zero values and missing keys must be distinguished.
A Go string stores bytes, but range over a string decodes UTF-8 runes for you.
Byte iteration and rune iteration answer different questions, so choose the one that matches your real goal.

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.