Record the pitfalls of Go's loop traversal

                                                                                                                              

The following tutorial column will share with you the pitfalls of Go’s loop traversal, I hope it will be helpful to friends who need it!

In Golang's flow control, there are two types of loop statements: for and range.

for statement

1.for assignment expression; relational expression or logical expression; assignment expression{}

for i := 0; i < 10; i++ {}

2.for relational expression or logical expression { }

n := 10for n > 0 {
 n--}

3.for { }

for {
 fmt.Println("hello world")
}
// 等价于
// for true {
//     fmt.Println("hello world")
// }

range statementGolang range is similar to the iterator operation and can iterate over slices, maps, arrays, strings, etc. It returns (index, value) in strings, arrays, and slices, and (key, value) in collections, but when there is only one return value, the first argument is the index or key.

str := "abc"
for i, char := range str {
    fmt.Printf("%d => %s\n", i, string(char))
}
for i := range str { //只有一个返回值
    fmt.Printf("%d\n", i)
}
nums := []int{1, 2, 3}
for i, num := range nums {
    fmt.Printf("%d => %d\n", i, num)
}
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
    fmt.Printf("%s => %s\n", k, v)
}
for k := range kvs { //只有一个返回值
    fmt.Printf("%s\n", k)
}
// 输出结果
// 0 => a
// 1 => b
// 2 => c
// 0
// 1
// 2
// 0 => 1
// 1 => 2
// 2 => 3
// a => apple
// b => banana
// a
// b

The for loop, especially the range statement, is frequently used in the normal development process, but many developers (I am one of them) often make mistakes in the following scenarios.

Scenario 1, using the variables of the loop iterator

Let’s look at an obvious mistake first:

func main() {
    var out []*int
    for i := 0; i < 3; i++ {
        // i := i
        out = append(out, &i)
    }
    fmt.Println("值:", *out[0], *out[1], *out[2])
    fmt.Println("地址:", out[0], out[1], out[2])
}
// 输出结果
// 值: 3 3 3
// 地址: 0xc000012090 0xc000012090 0xc000012090

Analysis

out

is an integer pointer array variable. In the for loop, a

i

variable is declared, and the address of i is stored in each loop. Append to the out slice, but each append is actually the i variable, so what we append is the same address, and the final value of the address is 3. Correct approach

Unlock the comments in the code

// i := i

, create a new # each time through the loop ##i

Variables.

Let’s look at a more subtle mistake: <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">func main() { a1 := []int{1, 2, 3} a2 := make([]*int, len(a1)) for i, v := range a1 { a2[i] = &amp;v } fmt.Println(&quot;值:&quot;, *a2[0], *a2[1], *a2[2]) fmt.Println(&quot;地址:&quot;, a2[0], a2[1], a2[2]) } // 输出结果 // 值: 3 3 3 // 地址: 0xc000012090 0xc000012090 0xc000012090</pre><div class="contentsignin">Copy after login</div></div>

Analysis

---

Most people are here

range

This is a pitfall when assigning values ​​to variables because it is relatively secretive. In fact, the situation is the same as above. When

range

is traversing the value type,

v is a local variable and will only be initialized. Once, and then reassign the previous one every time it loops, so when assigning a value to a2[i], it is actually the same address &v, and v The final value is the value of the last element of a1, which is 3. Correct approach

①

a2[i]

Pass the original pointer when assigning, that is,

a2[i] = &a1[i]

②Create temporary variablet := v;a2[i] = &t
③Closure (same principle as ②), func (v int) { a2[i] = &v }(v)
The more secretive thing is: <div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">func main() { var out [][]int for _, i := range [][1]int{{1}, {2}, {3}} { out = append(out, i[:]) } fmt.Println(&quot;Values:&quot;, out)}// 输出结果// [[3] [3] [3]]</pre><div class="contentsignin">Copy after login</div></div>The principle is the same, no matter how many times it is traversed ,

i[:]

---

is always overwritten by the value of this traversal

Scenario 2, using goroutines in the loop body

func main() {
    values := []int{1, 2, 3}
    wg := sync.WaitGroup{}
    for _, val := range values {
        wg.Add(1)
        go func() {
            fmt.Println(val)
            wg.Done()
        }()
    }
    wg.Wait()}// 输出结果// 3// 3// 3

Analysis

For the main coroutine, the loop is completed quickly, and each coroutine may only start running at this time. At this time, the value of

val

has already The traversal has reached the last one, so each coroutine outputs

3

. (If the traversal data is huge and the main coroutine traversal takes a long time, the output of the goroutine will be based on the value of

val at that time, so the output result is not necessarily the same each time.) Solution

①Use temporary variables

for _, val := range values {
    wg.Add(1)
    val := val    go func() {
        fmt.Println(val)
        wg.Done()
    }()}

②Use closure

for _, val := range values {
    wg.Add(1)
    go func(val int) {
        fmt.Println(val)
        wg.Done()
    }(val)}

The above is the detailed content of Record the pitfalls of Go's loop traversal. For more information, please follow other related articles on the PHP Chinese website!