What is the difference between Go's for loop and range loop?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Go, looping constructs are essential for iterating over collections and executing repetitive tasks. Two primary looping constructs are the for loop and the range loop. While both can be used for iteration, they serve different purposes and have distinct syntax and use cases. This guide will explore the differences between Go's for loop and range loop, with practical examples to illustrate their usage.
The for Loop
Basic Syntax
The for loop in Go is a versatile construct that can be used in several forms. Its basic syntax involves initialization, condition, and post statement.
Basic Syntax:
for initialization; condition; post {
    // loop body
}

Example: Simple **for** Loop
package main

import "fmt"

func main() {
    for i := 0; i &#x3C; 5; i++ {
        fmt.Println(i)
    }
}

Explanation:

i := 0 initializes the loop variable i.
i &#x3C; 5 is the loop condition; the loop runs while i is less than 5.
i++ increments the loop variable after each iteration.
The loop prints numbers from 0 to 4.

Infinite Loop
The for loop can also be used to create an infinite loop by omitting the condition.
Example: Infinite **for** Loop
package main

import "fmt"

func main() {
    for {
        fmt.Println("This will run forever")
    }
}

Explanation:

The loop has no condition, so it runs indefinitely until explicitly broken.

The range Loop
Basic Syntax
The range loop is specifically designed for iterating over slices, arrays, maps, and channels. It simplifies the process of accessing elements and their indices.
Basic Syntax:
for index, value := range collection {
    // loop body
}

Example: **range** Loop with Slice
package main

import "fmt"

func main() {
    fruits := []string{"apple", "banana", "cherry"}

for index, fruit := range fruits {
        fmt.Printf("Index: %d, Fruit: %s
", index, fruit)
    }
}

Explanation:

index is the current index of the element in the slice.
fruit is the value at that index.
The loop iterates over the slice, printing each index and corresponding value.

Using range with Maps
The range loop can also iterate over map keys and values.
Example: **range** Loop with Map
package main

import "fmt"

func main() {
    ages := map[string]int{
        "Alice": 30,
        "Bob":   25,
        "Carol": 35,
    }

for name, age := range ages {
        fmt.Printf("Name: %s, Age: %d
", name, age)
    }
}

Explanation:

name is the key in the map.
age is the corresponding value.
The loop iterates over the map, printing each key-value pair.

Differences Between for Loop and range Loop
 Usage
**for** Loop:

Suitable for general iteration needs, including numeric ranges and custom conditions.
More flexible but requires manual handling of index or condition.

**range** Loop:

Specifically designed for iterating over slices, arrays, maps, and channels.
Simplifies iteration by automatically providing the index and value.

Example: Using **for** vs. **range**
// Using for to iterate over a slice
numbers := []int{1, 2, 3, 4, 5}
for i := 0; i &#x3C; len(numbers); i++ {
    fmt.Println(numbers[i])
}

// Using range to iterate over a slice
for _, num := range numbers {
    fmt.Println(num)
}

Index and Value Access
**for** Loop:

Index and value must be managed manually. Index is used to access values in a collection.

**range** Loop:

Automatically provides both index and value. Can also ignore one if not needed.

Example: Ignoring Index with **range**
for _, value := range collection {
    // Only use value, ignore index
}

Infinite Loops
**for** Loop:

Can be used to create infinite loops by omitting the condition.

**range** Loop:

Cannot be used for infinite loops directly, as it relies on the size of the collection or channel.

Example: Infinite **for** Loop
for {
    // Infinite loop
}

Practical Use Cases
When to Use for Loop

When you need to iterate with a custom increment or decrement.
For numeric ranges or complex loop conditions.
For creating infinite loops.

Example: Custom Increment
for i := 0; i &#x3C;= 10; i += 2 {
    fmt.Println(i)
}

When to Use range Loop

When iterating over slices, arrays, maps, or channels.
When you want to simplify code and avoid manual index management.
When you need both index and value or just the value.

Example: Iterating with **range**
colors := []string{"red", "green", "blue"}
for _, color := range colors {
    fmt.Println(color)
}

Conclusion
Both for loops and range loops in Go serve valuable purposes in iteration but are suited to different scenarios. The for loop provides flexibility and control, making it ideal for custom iteration needs. The range loop offers simplicity and convenience for iterating over collections, automatically managing indices and values. Understanding when and how to use each loop type helps you write more efficient and readable Go code.

What is the difference between Go's for loop and range loop?

Table of Contents

Introduction

The `for` Loop

Basic Syntax

Infinite Loop

The `range` Loop

Basic Syntax

Using `range` with Maps

Differences Between `for` Loop and `range` Loop

Usage

Index and Value Access

Infinite Loops

Practical Use Cases

When to Use `for` Loop

When to Use `range` Loop

Conclusion

Similar Questions