IT码农库

您当前所在位置:首页 > 脚本专栏 > Golang

Golang

Golang中for循环遍历避坑指南

[db:来源] 2023-05-11Golang1262
这篇文章主要为大家具体介绍了Golang中for循环遍历会出现的一些小坑以及对应的解决办法,文中的示例代码讲解具体,感爱好的可以了解一下

一、for循环

循环:让程序多次执行相同的代码块

for循环是Go语言中唯一一个循环结构

for循环经典语法

  • 先执行表达式1
  • 执行表达式2判定是否成立,假如成立执行循环体
  • 循环体执行完成后,执行表达式3
  • 再次执行表达式2,判定是否成立.

for循环用的最多的地方就是遍历数组或切片等

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

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

for i := 0; i < 5; i++ {
    fmt.Println(i)
}
//等价于
j := 0
for ; j < 5; {
    fmt.Println(j)
    j++
}

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

for i := 0; i < 5; i++ {
    fmt.Println(i)
}
//等价于
j := 0
for j < 5 {
    fmt.Println(j)
    j++
}

二、range语句

Golang range类似迭代器操作,可以对 slice、map、数组、字符串等入行迭代循环。在字符串、数组和切片中它返归 (索引, 值) ,在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变量。

注重,for循环表达式1定义的变量i相称于循环体里面的全局变量,循环体里面定义的变量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)
}

三、实战

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

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
*/

到此这篇关于Golang中for循环遍历避坑指南的文章就介绍到这了,更多相关Golang for循环内容请搜索以前的文章或继承浏览下面的相关文章希望大家以后多多支持!

大图广告(830*140)