【Golang】Golang进阶系列教程--为什么 Go for-range 的 value 值地址每次都一样?

水深无声 2023-10-14 10:07 46阅读 0赞

文章目录

  • 前言
  • 现象
    • 无限循环
    • 相同地址
  • 原因
  • 推荐阅读

前言

循环语句是一种常用的控制结构,在 Go 语言中,除了 for 关键字以外,还有一个 range 关键字,可以使用 for-range 循环迭代数组、切片、字符串、map 和 channel 这些数据类型。

但是在使用 for-range 循环迭代数组和切片的时候,是很容易出错的,甚至很多老司机一不小心都会在这里翻车。

具体是怎么翻的呢?我们接着看。

现象

先来看两段很有意思的代码:

无限循环

如果我们在遍历数组的同时向数组中添加元素,能否得到一个永远都不会停止的循环呢?
比如下面这段代码:

  1. func main() {
  2. arr := []int{
  3. 1, 2, 3}
  4. for _, v := range arr {
  5. arr = append(arr, v)
  6. }
  7. fmt.Println(arr)
  8. }

程序输出:

  1. $ go run main.go
  2. 1 2 3 1 2 3

上述代码的输出意味着循环只遍历了原始切片中的三个元素,我们在遍历切片时追加的元素并没有增加循环的执行次数,所以循环最终还是停了下来。

相同地址

第二个例子是使用 Go 语言经常会犯的一个错误。

当我们在遍历一个数组时,如果获取 range 返回变量的地址并保存到另一个数组或者哈希时,会遇到令人困惑的现象:

  1. func main() {
  2. arr := []int{
  3. 1, 2, 3}
  4. newArr := []*int{
  5. }
  6. for _, v := range arr {
  7. newArr = append(newArr, &v)
  8. }
  9. for _, v := range newArr {
  10. fmt.Println(*v)
  11. }
  12. }

程序输出:

  1. $ go run main.go
  2. 3 3 3

上述代码并没有输出 1 2 3,而是输出 3 3 3。
正确的做法应该是使用 &arr[i] 替代 &v,像这种编程中的细节是很容易出错的。

原因

具体原因也并不复杂,一句话就能解释。

对于数组、切片或字符串,每次迭代,for-range 语句都会将原始值的副本传递给迭代变量,而非原始值本身。

口说无凭,具体是不是这样,还得靠源码说话。

Go 编译器会将 for-range 语句转换成类似 C 语言的三段式循环结构,就像这样:

  1. // Arrange to do a loop appropriate for the type. We will produce
  2. // for INIT ; COND ; POST {
  3. // ITER_INIT
  4. // INDEX = INDEX_TEMP
  5. // VALUE = VALUE_TEMP // If there is a value
  6. // original statements
  7. // }

迭代数组时,是这样:

  1. // The loop we generate:
  2. // len_temp := len(range)
  3. // range_temp := range
  4. // for index_temp = 0; index_temp < len_temp; index_temp++ {
  5. // value_temp = range_temp[index_temp]
  6. // index = index_temp
  7. // value = value_temp
  8. // original body
  9. // }

切片:

  1. // for_temp := range
  2. // len_temp := len(for_temp)
  3. // for index_temp = 0; index_temp < len_temp; index_temp++ {
  4. // value_temp = for_temp[index_temp]
  5. // index = index_temp
  6. // value = value_temp
  7. // original body
  8. // }

从上面的代码片段,可以总结两点:

  • 在循环开始前,会将数组或切片赋值给一个新变量,在赋值过程中就发生了拷贝,迭代的实际上是副本,这也就解释了现象 1。
  • 在循环过程中,会将迭代元素赋值给一个临时变量,这又发生了拷贝。如果取地址的话,每次都是一样的,都是临时变量的地址。
  • 参考文章:

garbagecollected.org/2017/02/22/…
draveness.me/golang/docs…

推荐阅读

  • Go 语言教程–介绍(一)
  • Go 语言教程–语言结构(二)
  • Go 语言教程–语言结构(三)
  • Go 语言教程–数据类型(四)
  • Go 语言教程–语言变量(五)
  • Go 语言教程–GO语言常量(六)
  • Go 语言教程–GO语言运算符(七)
  • Go 语言教程–GO条件和循环语句(八)
  • Go 语言教程–GO语言函数(九)
  • Go 语言教程–GO语言变量作用域(十)
  • Go 语言教程–GO语言数组(十一)
  • Go 语言教程–GO语言指针(十二)
  • Go 语言教程–GO语言结构体(十三)
  • Go 语言教程–GO语言切片(Slice)(十四)
  • Go 语言教程–Go 语言范围(Range)(十五)
  • Go 语言教程–Go 语言Map(集合)(十六)
  • Go 语言教程–Go 语言递归函数(十七)
  • Go 语言教程–Go 语言类型转换(十八)
  • Go 语言教程–Go 语言接口(十九)
  • Go 语言教程–Go 错误处理(二十)
  • Go 语言教程–Go 并发(二十一)

发表评论

表情:
评论列表 (有 0 条评论,46人围观)

还没有评论,来说两句吧...

相关阅读