Control Flow Statements (For, While, Range) in Go

The loop structures in the Go language primarily consist of for, while (via specific syntax), and range. Although their syntax appears simple on the surface, understanding their underlying mechanisms is crucial for writing efficient code. In Go, all loop statements are ultimately compiled into jump instructions with labels (goto). This means their behavior is entirely determined by control flow.
The for loop in Go is the most general structure and is highly flexible. Unlike C/C++/Java, which mandate that initialization, condition evaluation, and increment/decrement operations be explicitly written out, Go does not require all three parts to be present. You can omit them entirely or include only a subset of these components. This design makes Go's for loop functionally almost equivalent to the while or do-while structures found in other languages.

Standard Form: Includes initialization, condition evaluation, and increment/decrement operators (e.g., i := 0; i < 10; i++).
Simplified Form: Retains only the condition check while omitting initialization and stepping (Go considers this the most common loop pattern).
Infinite Loop: Omits all parts, resulting in an infinite loop.

Underlying Equivalence of While and For

There is no true while keyword as a standalone syntax structure in the Go language. All conditional judgment statements must be executed within a for structure under a label (label). This design allows the compiler to optimize more effectively and perform better error detection.

Pseudocode Example: Traditional while (i < 10) { i++ }.
Go Implementation: The corresponding Go syntax is actually for ; i < 10; i++ {}, where the semicolon represents an empty initialization section, followed immediately by the condition check and stepping operation.

This unification not only simplifies the compiler's workload but also eliminates common "infinite loop" pitfalls (such as forgetting to update a variable at the end of a while loop). If the termination condition is not met or there is no explicit increment logic provided, Go will directly report an error indicating that a necessary statement block is missing.

Core Application of Range Iteration over Collections

range is one of the most distinctive loop structures in Go, specifically designed for iterating over collection types such as slices, arrays, and maps. It can provide both index values and element contents simultaneously, greatly simplifying the logic required to write iteration code.

1. Iterating Over Slices and Arrays

When using range on sequences, it defaults to returning two variables: one for the current element's index (or position), and another for the value of the element itself. If you only need access to the elements without caring about their indices, declare a single receiver; conversely, if you need both, use two receivers.

// Define a simple integer slice
numbers := []int{1, 2, 3, 4}

// Iteration Method One: Get index and value simultaneously
for i, num := range numbers {
    fmt.Printf("Index: %d, Value: %d\n", i, num)
}

// Iteration Method Two: Access only the element, ignoring the index (Recommended style)
for _, num := range numbers {
    if num > 2 {
        fmt.Println(num * 10) // Output number multiplied by 10 for values greater than 2
    }
}

2. Iterating Over Map Structures

When handling key-value data, range performs exceptionally well as well. It automatically returns the index (i.e., the map's key) and value as two variables to be used within the loop body. Note that in Go, you cannot directly obtain a single variable's value using the syntax value := range m; explicit receiver lists must be declared to maintain type safety.

// Define a map structure
userMap := map[string]int{
    "Alice": 25,
    "Bob":   30,
}

for name, age := range userMap {
    fmt.Printf("User %s is %d years old\n", name, age)
}

As shown in the examples above, range not only reduces boilerplate code redundancy but also ensures synchronized updates of indices and values during iteration. This mechanism avoids logical errors that might arise from manually maintaining counters (such as out-of-bounds access), making it the preferred solution for handling collection data structures in Go.