在Golang的流程控制中，循环语句有for和range两种。

for语句

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

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

2.for 关系表达式或逻辑表达式 { }

n := 10for n >
 0 {

 n--}

3.for { }

for {

 fmt.Println("hello world")
}

// 等价于
// for true {

//     fmt.Println("hello world")
// }

range语句

Golang range类似迭代器操作，可以对 slice、map、数组、字符串等进行迭代循环。在字符串、数组和切片中它返回 (索引, 值) ，在集合中返回 (键, 值)，但若当只有一个返回值时，第一个参数是索引或键。

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() {
    
    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

分析

out是一个整型指针数组变量，在for循环中，声明了一个i变量，每次循环将i的地址追加到out切片中，但是每次追加的其实都是i变量，因此我们追加的是一个相同的地址，而该地址最终的值是3。

正确做法

解开代码中的注释// i := i，每次循环时都重新创建一个新的i变量。

再看一个比较隐秘的错误：

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。

正确做法

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

更为隐秘的还有：

func main() {

    var out [][]int
    for _, i := range [][1]int{
{
1}
, {
2}
, {
3}
}
 {

        out = append(out, i[:])
    }

    fmt.Println("Values:", out)}
// 输出结果// [[3] [3] [3]]

原理也是一样的，不论遍历多少次，i[:]总是被本次遍历的值所覆盖

场景二，在循环体内使用goroutines

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)
    val := val    go func() {

        fmt.Println(val)
        wg.Done()
    }
()}

②使用闭包

for _, val := range values {

    wg.Add(1)
    go func(val int) {

        fmt.Println(val)
        wg.Done()
    }
(val)}