Explain the use of Go's range keyword for iterating over collections?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
In Go, the range keyword is a powerful tool used to iterate over various types of collections such as arrays, slices, maps, strings, and channels. It provides a concise and readable way to loop through elements in these data structures. Understanding how to effectively use the range keyword can make your code more efficient and easier to understand.
Using Go's **range** Keyword for Iterating Over Collections
Iterating Over Arrays and Slices
The range keyword allows you to iterate over each element of an array or slice. When iterating over an array or slice, range returns two values: the index and the element at that index.

Example: Iterating Over an Array or Slice
package main

import "fmt"

func main() {
    // Define an array
    arr := [5]int{10, 20, 30, 40, 50}

// Iterate over the array using range
    for index, value := range arr {
        fmt.Printf("Index: %d, Value: %d
", index, value)
    }

// Define a slice
    slice := []string{"apple", "banana", "cherry"}

// Iterate over the slice using range
    for i, v := range slice {
        fmt.Printf("Index: %d, Value: %s
", i, v)
    }
}

Outpu
Index: 0, Value: 10
Index: 1, Value: 20
Index: 2, Value: 30
Index: 3, Value: 40
Index: 4, Value: 50
Index: 0, Value: apple
Index: 1, Value: banana
Index: 2, Value: cherry

In this example:

For the array arr, range returns the index (0 to 4) and the corresponding value.
For the slice slice, range works similarly, iterating over each element.

Iterating Over Maps
When using range to iterate over a map, it returns two values: the key and the value associated with that key. This allows you to easily access all key-value pairs in the map.

Example: Iterating Over a Ma
package main

import "fmt"

func main() {
    // Define a map
    person := map[string]int{
        "Alice": 30,
        "Bob":   25,
        "Carol": 40,
    }

// Iterate over the map using range
    for key, value := range person {
        fmt.Printf("Key: %s, Value: %d
", key, value)
    }
}

Output
Key: Alice, Value: 30
Key: Bob, Value: 25
Key: Carol, Value: 40

Here, range iterates over each key-value pair in the map person, printing the key and its corresponding value.

Iterating Over Strings
Using range with strings allows you to iterate over Unicode code points (runes) in the string. The range expression returns the index of the character and its rune value.

Example: Iterating Over a String
package main

import "fmt"

func main() {
    str := "Hello, 世界"

// Iterate over the string using range
    for index, runeValue := range str {
        fmt.Printf("Index: %d, Rune: %c
", index, runeValue)
    }
}

Output:
Index: 0, Rune: H
Index: 1, Rune: e
Index: 2, Rune: l
Index: 3, Rune: l
Index: 4, Rune: o
Index: 5, Rune: ,
Index: 7, Rune: 世
Index: 10, Rune: 界

In this example, range correctly handles Unicode characters in the string "Hello, 世界," providing the index and the rune value of each character.

Iterating Over Channels
range can also be used to receive values from a channel until it is closed. When iterating over a channel with range, it retrieves each value sent on the channel and stops when the channel is closed.

Example: Iterating Over a Channel
package main

import "fmt"

func main() {
    ch := make(chan int)

// Start a Goroutine to send data
    go func() {
        for i := 1; i &#x3C;= 3; i++ {
            ch &#x3C;- i // Send values to the channel
        }
        close(ch) // Close the channel
    }()

// Iterate over the channel using range
    for value := range ch {
        fmt.Println("Received:", value)
    }
}

Output:
Received: 1
Received: 2
Received: 3

Here, range continues to receive values from the channel ch until the channel is closed by the sender.

Practical Examples Using **range**
Example : Filtering Values from a Slice
You can use range to filter specific values from a slice based on a condition.
package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    var evens []int

// Use range to filter even numbers
    for _, num := range numbers {
        if num%2 == 0 {
            evens = append(evens, num)
        }
    }

fmt.Println("Even numbers:", evens)
}

Output:
Even numbers: [2 4 6]

In this example, range is used to loop through each number in the slice numbers and filter out even numbers.
Example : Counting Characters in a String
You can use range to count the occurrences of each character in a string.
package main

import "fmt"

func main() {
    text := "hello world"
    charCount := make(map[rune]int)

// Use range to count characters
    for _, char := range text {
        charCount[char]++
    }

fmt.Println("Character count:", charCount)
}

Output:
Character count: map[104:1 101:1 108:3 111:2 32:1 119:1 114:1 100:1]

In this example, range iterates over each character in the string text and counts their occurrences using a map.
Conclusion
The range keyword in Go is a versatile tool for iterating over collections like arrays, slices, maps, strings, and channels. It provides a concise and readable way to access elements and perform operations on them. By leveraging the range keyword effectively, you can write more efficient and maintainable Go code. Whether you need to iterate over an array, process map keys, handle Unicode strings, or work with channels, range offers a simple solution for iteration in Go.

Explain the use of Go's range keyword for iterating over collections?

Table of Contents

Introduction

Using Go's `range` Keyword for Iterating Over Collections

Iterating Over Arrays and Slices

Iterating Over Maps

Iterating Over Strings

Iterating Over Channels

Practical Examples Using `range`

Example : Filtering Values from a Slice

Example : Counting Characters in a String

Conclusion

Similar Questions