go循环遍历小坑

for语句

1. for 赋值表达式; 关系表达式或逻辑表达式; 赋值表达式 { }

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

3. for { }

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

for循环尤其是range语句，在平时开发过程中频繁使用，但很多开发者(本人算一个)经常会在以下场景中踩坑。

场景一，使用循环迭代器的变量

先来看一个明显的错误：

func main() {
	a1 := []int{1, 2, 3}
	a2 := make([]*int, len(a1))

	for i, v := range a1 {
		a2[i] = &v
	}

	fmt.Println("值:", *a2[0], *a2[1], *a2[2])
	fmt.Println("地址:", a2[0], a2[1], a2[2])
}
// 输出结果
// 值: 3 3 3
// 地址: 0xc000012090 0xc000012090 0xc000012090

分析

大多数人就是在range这里给变量赋值的时候踩坑，因为比较隐秘，其实情况和上面的一样，range在遍历值类型时，其中的v是一个局部变量，只会声明初始化一次，之后每次循环时重新赋值覆盖前面的，所以给a2[i]赋值的时候其实都是同一个地址&v，而v最终的值为a1最后一个元素的值，也就是3。

正确做法

package main

import "fmt"

func main() {
   slic:= []int{1,2,3}
   cp:=make([]*int,len(slic))
   for i,x:=range slic {
      cp[i]=&slic[i]
      cp=append(cp, &x)


   }
   fmt.Println(*cp[1])


}

①a2[i]赋值时传递原始指针，即a2[i] = &a1[i]
②创建临时变量t := v；a2[i] = &t
③闭包(与②原理一样)，func(v int) { a2[i] = &v }(v)

更为隐秘的还有：

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

分析

对于主协程来讲，循环是很快就跑完的，而这个时候各个协程可能才开始跑，此时val的值已经遍历到最后一个了，所以各协程都输出了3。（如果遍历数据庞大，主协程遍历耗时较久的话，goroutine的输出会根据当时候的val的值，所以每次的输出结果不一定相同的。）

解决办法

①使用临时变量

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