• Golang for循环遍历小坑

    一、for循环

    循环:让程序多次执行相同的代码块
    for循环是Go语言中唯一一个循环结构
    for循环经典语法
    先执行表达式1
    执行表达式2判断是否成立,如果成立执行循环体
    循环体执行完成后,执行表达式3
    再次执行表达式2,判断是否成立.
    for循环用的最多的地方就是遍历数组或切片等

    ?
    1
    2
    3
    for 表达式1;表达式2;表达式3{
      //循环体
    }　

    经典for循环结构中 , for关键字后面有三个表达式,且每个表达式都可以省略。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
    //等价于
    j := 0
    for ; j < 5; {
        fmt.Println(j)
        j++
    }

    for关键字后面也可以只有一个表达式,表示如果条件成立执行循环体代码。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
    //等价于
    j := 0
    for j < 5 {
        fmt.Println(j)
        j++
    }

    二、range语句

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

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    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语句，在平时开发过程中频繁使用，但很多开发者经常会在以下场景中踩坑。

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

    先来看一个明显的错误：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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变量。

    注意，for循环表达式1定义的变量i相当于循环体里面的全局变量，循环体里面定义的变量i相当于循环体里面的局部变量，由于在代码块中同名局部变量会覆盖同名的全局变量，所以此时在循环体逻辑里面，使用的i变量是循环体里面定义的局部变量i。

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

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    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)

    更为隐秘的还有：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    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

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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的值，所以每次的输出结果不一定相同的。）

    解决办法

    ①使用临时变量

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    for _, val := range values {
        wg.Add(1)
        val := val
        go func() {
            fmt.Println(val)
            wg.Done()
        }()
    }

    ②使用闭包

    ?
    1
    2
    3
    4
    5
    6
    7
    for _, val := range values {
        wg.Add(1)
        go func(val int) {
            fmt.Println(val)
            wg.Done()
        }(val)
    }

    三、实战

     基于第一、第二小节内容，接下来进行一个Golang for循环实战，代码详情请看注释。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    package main
     
    import "fmt"
     
    func main() {
        slic := []int{1, 2, 3}
        // len(cp) = 3, cap(cp) = 3
        cp := make([]*int, len(slic))
        for i, x := range slic {
            cp[i] = &slic[i]
            cp = append(cp, &x)
        }
     
        // 第一次循环
        // cp[0] = &slic[0]  *cp[0] = 1
        // 由于len=cap=3,append方法的作用是将元素追加到切片的末尾，即cp(len)位置，此时append便超过切片容量，切片进行扩容，将容量扩容2倍（切片容器<1024时，扩容*2）。
        // append后相当于 cp[3] = &x  此时x的值为1，len(cp)=4, cap(cp)=6
     
        // 第二次循环
        // cp[1] = &slic[1]  *cp[1] = 2
        // 再次append相当于 cp[4] = &x 此时x的值为2，len(cp)=5, cap(cp)=6
     
        // 第三次循环
        // cp[2] = &slic[2]  *cp[2] = 3
        // 再次append相当于 cp[5] = &x 此时x的值为3，len(cp)=6, cap(cp)=6
     
        // 至此循环完毕，cp中数据为  &slic[0]  &slic[1] &slic[2] &x  &x  &x
     
          println("len==", len(cp), "  cap==", cap(cp))
          for _, x := range cp {
            fmt.Print(*x, " ")
          }
    }
     
    /*  输出结果
        len== 6   cap== 6
        1 2 3 3 3 3
    */

    参考：https://www.cnblogs.com/cheyunhua/p/15770777.html

    参考：https://blog.csdn.net/qq_27870421/article/details/118485883

  • 相关阅读:
    LinkedList 底层学习
    WPF控件4
    生态系统长期观测数据产品体系
    对于Biotin-LC-NHS Estercas:72040-63-2与伯氨基 (-NH2) 反应的作用有哪些？
    vscode 远程开发golang
    uni-app华为审核被拒，驳回原因：您的应用在运行时，未见向用户告知权限申请的目的
    css修改滚动条样式
    权限模型 DAC ACL RBAC ABAC
    大数据(十)：数据可视化(二)
    突破编程_C++_面试（函数（1））
  • 原文地址：https://www.cnblogs.com/zhangmingcheng/p/17389930.html