Explain in simple terms: Thoroughly understand the working principle of Go language range

Go language is a concise and powerful programming language with unique design and features in many aspects. One of the most impressive features is the range keyword, which is used to iterate over data structures such as arrays, slices, maps, and channels. The flexibility and convenience of range make it easy to traverse complex data structures, but many people are confused by how it works. This article will explain the working principle of range in a simple and easy-to-understand way, and use specific code examples to help readers better understand.

First, let us look at a simple example:

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}

    for index, value := range nums {
        fmt.Printf("Index: %d, Value:%d
", index, value)
    }
}

In the above code, we define an integer slice nums, containing 5 numbers. Then use the range keyword to traverse this slice, where index represents the index of the current element, and value represents the value of the current element. By running the above code, we can see the output:

Index: 0, Value: 1
Index: 1, Value: 2
Index: 2, Value: 3
Index: 3, Value: 4
Index: 4, Value: 5

Now let us explain in detail how range works. When we use range to traverse a slice, the Go language will actually return two values: the first value is the index of the current element, and the second value is the value of the current element. In each loop iteration, range will automatically update these two values ​​until the entire slice is traversed.

But it should be noted that range does not return a copy of the slice, but a copy of each element in the slice. This means that modifications to elements during the traversal will not affect the value of the original slice. Let's look at an example of modifying elements:

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5}

    for index, value := range nums {
        nums[index] = value * 2
    }

    fmt.Println(nums)
}

In the above code, we iterate over the slice nums and multiply the value of each element by 2, and then print the modified slice nums. By running the above code, we can see the output:

[2 4 6 8 10]

This shows that when the slice element is modified through range, it actually only modifies a copy of the current element and does not affect The value of the original slice.

In addition, the traversal of the map is similar. When traversing the map using range, a copy of the key-value pair will also be returned. Let's look at an example of traversing a mapping:

package main

import "fmt"

func main() {
    person := map[string]int{
        "Tom": 25,
        "Jerry": 30,
        "Alice": 28,
    }

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

In the above code, we define a person mapping, which stores the person's name and corresponding age. Iterate through the map through range and print each person's name and age. By running the above code, we can see the output:

Tom is 25 years old
Jerry is 30 years old
Alice is 28 years old

In summary, data structures such as arrays, slices, maps, and channels can be easily traversed through the range keyword. During the traversal process, range will automatically return a copy of the index and value of the current element. At the same time, for data structures such as arrays, slices, and maps, when traversing and modifying element values ​​through range, only the copy will be modified and the value of the original data structure will not be affected. We hope that through the explanations and code examples in this article, readers can have a deeper understanding of how range works, and thus better utilize this convenient feature to complete programming tasks.

The above is the detailed content of Explain in simple terms: Thoroughly understand the working principle of Go language range. For more information, please follow other related articles on the PHP Chinese website!