go语言中for range使用方法及避坑指南

目录
  • 前言
  • for range基本用法
  • for range 和 for的区别
  • for range容易踩的坑
  • for range和for性能比较
  • for range的底层原理
  • 总结
  • 参考资料

前言

for range语句是业务开发中编写频率很高的代码,其中会有一些常见的坑,看完这篇文章会让你少入坑。

for range基本用法

range是Golang提供的一种迭代遍历手段,可操作的类型有数组、切片、string、map、channel等

1、遍历数组

myArray := [3]int{1, 2, 3}
for i, ele := range myArray {
    fmt.Printf("index:%d,element:%d\n", i, ele)
    fmt.Printf("index:%d,element:%d\n", i, myArray[i])
}

直接取元素或通过下标取

2、遍历slice

mySlice := []string{"I", "am", "peachesTao"}
for i, ele := range mySlice {
    fmt.Printf("index:%d,element:%s\n", i, ele)
    fmt.Printf("index:%d,element:%s\n", i, mySlice[i])
}

直接取元素或通过下标取

3、遍历string

s:="peachesTao"
for i,item := range s {
   fmt.Println(string(item))
   fmt.Printf("index:%d,element:%s\n", i, string(s[i]))
}

直接取元素或通过下标取

注意:循环体中string中的元素实际上是byte类型,需要转换为字面字符

4、遍历map

myMap := map[int]string{1:"语文",2:"数学",3:"英语"}
for key,value := range myMap {
    fmt.Printf("key:%d,value:%s\n", key, value)
    fmt.Printf("key:%d,value:%s\n", key, myMap[key])
}

直接取元素或通过下标取

5、遍历channel

myChannel := make(chan int)
go func() {
  for i:=0;i<10;i++{
     time.Sleep(time.Second)
     myChannel <- i
  }
}()

go func() {
 for c := range myChannel {
    fmt.Printf("value:%d\n", c)
 }
}()

channel遍历是循环从channel中读取数据,如果channel中没有数据,则会阻塞等待,如果channel已被关闭,则会退出循环。

for range 和 for的区别

for range可以直接访问目标对象中的元素,而for必须通过下标访问

for frange可以访问map、channel对象,而for不可以

for range容易踩的坑

下面的例子是将mySlice中每个元素的后面都加上字符"-new"

mySlice := []string{"I", "am", "peachesTao"}
for _, ele := range mySlice {
    ele=ele+"-new"
}
fmt.Println(mySlice)

结果:

[I am peachesTao]

打印mySlice发现元素并没有更新,为什么会这样?

原因是for range语句会将目标对象中的元素copy一份值的副本,修改副本显然不能对原元素产生影响

为了证明上述结论,在遍历前和遍历中打印出元素的内存地址

mySlice := []string{"I", "am", "peachesTao"}
fmt.Printf("遍历前首元素内存地址:%p\n",&mySlice[0])
for _, ele := range mySlice {
    ele=ele+"-new"
    fmt.Printf("遍历中元素内存地址:%p\n",&ele)
}
fmt.Println(mySlice)

结果:

遍历前第一个元素内存地址:0xc000054180
遍历前第二个元素内存地址:0xc000054190
遍历前第三个元素内存地址:0xc0000541a0
遍历中元素内存地址:0xc000010200
遍历中元素内存地址:0xc000010200
遍历中元素内存地址:0xc000010200
[I am peachesTao]

可以得出两个结论:

  • 遍历体中的元素内存地址已经发生了变化,生成了元素副本,至于产生副本的原因在“for range底层原理”段落中会有介绍
  • 遍历体中的只生成了一个全局的元素副本变量,不是每个元素都会生成一个副本,这个特点也值得大家注意,否则会踩坑。

比如遍历mySlice元素生成一个[]*string类型的mySliceNew,要通过一个中间变量取中间变量的地址(或者通过下标的形式访问元素也可以)加入mySliceNew,如果直接取元素副本的地址会导致mySliceNew中所有元素都是一样的,如下:

mySlice := []string{"I", "am", "peachesTao"}
var mySliceNew []*string
for _, item := range mySlice {
    itemTemp := item
    mySliceNew = append(mySliceNew, &itemTemp)
    //mySliceNew = append(mySliceNew, &item) 错误的做法
}

回到刚才那个问题,如何能在遍历中修改元素呢?答案是直接通过下标访问slice中的元素对其赋值,如下:

mySlice := []string{"I", "am", "peachesTao"}
for i, _ := range mySlice {
    mySlice[i] = mySlice[i]+"-new"
}
fmt.Println(mySlice)

结果:

[I-new am-new peachesTao-new]

可以看到元素已经被修改

for range和for性能比较

我们定义一个结构体Item,包含int类型的id字段,对结构体数组分别使用for、for range item、for range index的方式进行遍历,下面是测试代码(直接引用“Go语言高性能编程”这篇文章中的例子,下面的reference中有链接地址)

type Item struct {
  id  int
}

func BenchmarkForStruct(b *testing.B) {
  var items [1024]Item
  for i := 0; i < b.N; i++ {
    length := len(items)
    var tmp int
    for k := 0; k < length; k++ {
      tmp = items[k].id
    }
    _ = tmp
  }
}

func BenchmarkRangeIndexStruct(b *testing.B) {
  var items [1024]Item
  for i := 0; i < b.N; i++ {
    var tmp int
    for k := range items {
      tmp = items[k].id
    }
    _ = tmp
  }
}

func BenchmarkRangeStruct(b *testing.B) {
  var items [1024]Item
  for i := 0; i < b.N; i++ {
    var tmp int
    for _, item := range items {
      tmp = item.id
    }
    _ = tmp
  }
}

运行基准测试命令:

go test -bench . test/for_range_performance_test.go

测试结果:

goos: darwin
goarch: amd64
BenchmarkForStruct-4             3176875               375 ns/op
BenchmarkRangeIndexStruct-4      3254553               369 ns/op
BenchmarkRangeStruct-4           3131196               384 ns/op
PASS
ok      command-line-arguments  4.775s

可以看出:

for range 通过Index和直接访问元素的方式和for的方式遍历性能几乎无差异

下面我们在Item结构体添加一个byte类型长度为4096的数组字段val

type Item struct {
  id  int
  val [4096]byte
}

再运行一遍基准测试,结果如下:

goos: darwin
goarch: amd64
BenchmarkForStruct-4             2901506               393 ns/op
BenchmarkRangeIndexStruct-4      3160203               381 ns/op
BenchmarkRangeStruct-4              1088            948678 ns/op
PASS
ok      command-line-arguments  4.317s

可以看出:

  • for range通过下标遍历元素的性能跟for相差不大
  • for range直接遍历元素的性能比for慢近1000倍

结论:

  • for range通过下标遍历元素的性能跟for相差不大
  • for range直接遍历元素的性能在元素为小对象的情况下跟for相差不大,在元素为大对象的情况下比for慢很多

for range的底层原理

对于for-range语句的实现,可以从编译器源码中找到答案。

编译器源码gofrontend/go/statements.cc/For_range_statement::do_lower()【链接见下方reference方法中有如下注释。

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

可见range实际上是一个C风格的循环结构。range支持string、数组、数组指针、切片、map和channel类型,对于不同类型有些细节上的差异。

1、range for slice

下面的注释解释了遍历slice的过程:

For_range_statement::lower_range_slice

// The loop we generate:
//   for_temp := range
//   len_temp := len(for_temp)
//   for index_temp = 0; index_temp < len_temp; index_temp++ {
//           value_temp = for_temp[index_temp]
//           index = index_temp
//           value = value_temp
//           original body
//   }

遍历slice前会先获得slice的长度len_temp作为循环次数,循环体中,每次循环会先获取元素值,如果for-range中接收index和value的话,则会对index和value进行一次赋值,这就解释了对大元素进行遍历会影响性能,因为大对象赋值会产生gc

由于循环开始前循环次数就已经确定了,所以循环过程中新添加的元素是没办法遍历到的。

另外,数组与数组指针的遍历过程与slice基本一致,不再赘述。

2、range for map 

下面的注释解释了遍历map的过程:

For_range_statement::lower_range_map

// The loop we generate:
//   var hiter map_iteration_struct
//   for mapiterinit(type, range, &hiter); hiter.key != nil; mapiternext(&hiter) {
//           index_temp = *hiter.key
//           value_temp = *hiter.val
//           index = index_temp
//           value = value_temp
//           original body
//   }

遍历map时没有指定循环次数,循环体与遍历slice类似。由于map底层实现与slice不同,map底层使用hash表实现,插入数据位置是随机的,所以遍历过程中新插入的数据不能保证遍历到。

3、range for channel

遍历channel是最特殊的,这是由channel的实现机制决定的:

For_range_statement::lower_range_channel

// The loop we generate:
//   for {
//           index_temp, ok_temp = <-range
//           if !ok_temp {
//                   break
//           }
//           index = index_temp
//           original body
//   }

一直循环读数据,如果有数据则取出,如果没有则阻塞,如果channel被关闭则退出循环

注:

上述注释中index_temp实际上描述是有误的,应该为value_temp,因为index对于channel是没有意义的。

总结

使用index,value接收range返回值会产生一次数据拷贝,视情况考虑不接收,以提高性能

for-range的实现实际上是C风格的for循环

到此这篇关于go语言中for range使用方法及避坑指南的文章就介绍到这了,更多相关go语言for range使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

参考资料

【《Go专家编程》Go range实现原理及性能优化剖析 https://my.oschina.net/renhc/blog/2396058

【面试官:用过go中的for-range吗?这几个问题你能解释一下原因吗?】https://zhuanlan.zhihu.com/p/217987219

【Go语言高性能编程】https://geektutu.com/post/hpg-range.html

【gofrontend】https://github.com/golang/gofrontend/blob/master/go/statements.cc

(0)

相关推荐

  • go for range坑和闭包坑的分析

    看程序: package main import ( "fmt" "time" ) func main() { str := []string{"I","like","Golang"} for _, v := range str{ v += "good" } for k, v := range str{ fmt.Println(k, v) } time.Sleep(1e9) } 结果:

  • go实现for range迭代时修改值的操作

    for range的val不能直接修改 因为地址不同 package main import "fmt" func main() { x := make([]int, 3) x[0], x[1], x[2] = 1, 2, 3 for i, val := range x { fmt.Println(&x[i], "vs.", &val) } } //输出 0x416020 vs. 0x41602c 0x416024 vs. 0x41602c 0x41

  • Go 处理大数组使用 for range 和 for 循环的区别

    目录 副本复制问题 性能对比 遍历结构体数组 结论 前言: 对于遍历大数组而言, for 循环能比 for range 循环更高效与稳定,这一点在数组元素为结构体类型更加明显. 我们知道,Go 的语法比较简洁.它并不提供类似 C 支持的 while.do...while 等循环控制语法,而仅保留了一种语句,即 for 循环. for i := 0; i < n; i++ { ... ... } 但是,经典的三段式循环语句,需要获取迭代对象的长度 n.鉴于此,为了更方便 Go 开发者对复合数据类型

  • go for range遍历二维数组的示例

    go for range 遍历二维数组 var arry [2][3] int for index,_ := range arry { fmt.Print(index) } 运行结果: 0 1   没有遍历所有的6个元素. 二维数组 arry 可以理解为:拥有两个 一维数组元素 的一维数组,所以以上只是遍历了其的两个元素,index分别是0 1,value是两个 拥有三个int类型元素 的一维数组. var arry [2][3] int for index,value := range arr

  • golang中for range的取地址操作陷阱介绍

    Tips:for range创建了每个元素的副本,而不是直接返回每个元素的引用 例子1: package main import "fmt" func main() { slice := []int{0, 1, 2, 3} myMap := make(map[int]*int) for index, value := range slice { myMap[index] = &value } fmt.Println("=====new map=====")

  • Go语言for range(按照键值循环)遍历操作

    Go 语言可以使用 for range 遍历数组.切片.字符串.map 及通道(channel).通过 for range 遍历的返回值有一定的规律: 数组.切片.字符串返回索引和值. map 返回键和值. 通道(channel)只返回通道内的值. 遍历数组.切片--获得索引和元素 在遍历代码中,key 和 value 分别代表切片的下标及下标对应的值.下面的代码展示如何遍历切片,数组也是类似的遍历方法: for key, value := range []int{1, 2, 3, 4} { f

  • 详解Go语言中for range的"坑"

    前言 Go 中的for range组合可以和方便的实现对一个数组或切片进行遍历,但是在某些情况下使用for range时很可能就会被"坑",下面用一段代码来模拟下: func main() { arr1 := []int{1, 2, 3} arr2 := make([]*int, len(arr1)) for i, v := range arr1 { arr2[i] = &v } for _, v := range arr2 { fmt.Println(*v) } } 代码解析

  • go语言中for range使用方法及避坑指南

    目录 前言 for range基本用法 for range 和 for的区别 for range容易踩的坑 for range和for性能比较 for range的底层原理 总结 参考资料 前言 for range语句是业务开发中编写频率很高的代码,其中会有一些常见的坑,看完这篇文章会让你少入坑. for range基本用法 range是Golang提供的一种迭代遍历手段,可操作的类型有数组.切片.string.map.channel等 1.遍历数组 myArray := [3]int{1, 2

  • C语言中pow函数使用方法、注意事项以及常见报错原因

    目录 1.首先使用pow函数必须要加头文件 : 2.pow()用来计算以x 为底的 y 次方值,然后将结果返回. 3.注意可能引起报错的原因 可能导致错误的情况: 总结 1.首先使用pow函数必须要加头文件 : #include<math.h> pow() 函数用来求 x 的 y 次幂(次方),x.y及函数值实际上为double型 ,其在使用中的原型为:double pow(double x, double y); 注意,在某些特定的情况之下,pow函数的double类型可能会引起输出结果的错

  • Go语言中的range用法实例分析

    本文实例讲述了Go语言中的range用法.分享给大家供大家参考.具体如下: for 循环的 range 格式可以对 slice 或者 map 进行迭代循环. 复制代码 代码如下: package main import "fmt" var pow = []int{1, 2, 4, 8, 16, 32, 64, 128} func main() {     for i, v := range pow {         fmt.Printf("2**%d = %d\n"

  • 浅析Go语言中的Range关键字

    前言 相信用过Range的朋友们都知道,Go语言中的range关键字使用起来非常的方便,它允许你遍历某个slice或者map,并通过两个参数(index和value),分别获取到slice或者map中某个元素所在的index以及其值. 比如像这样的用法: for index, value := range mySlice { fmt.Println("index: " + index) fmt.Println("value: " + value) } 上面的例子足够

  • C语言中static的使用方法实例详解

    目录 前言 一.static修饰变量 1.修饰局部变量 2.修饰全局变量 二.static修饰函数 补充:static的好处是什么? 总结 前言 static关键字不仅可以用来修饰变量,还可以用来修饰函数.在使用static关键字修饰变量时,我们称此变量为静态变量.静态变量的存储方式与全局变量一样,都是静态存储方式.静态变量属于静态存储方式,属于静态存储方式的变量却不一定就是静态变量. 一.static修饰变量 1.修饰局部变量 先看段代码: #include <stdio.h> void t

  • C语言中for循环问题(一个小坑需注意)

    今天分享一下C语言中的for循环中我们常常忽略的小问题. 举一个小例子来说明,大家也可以自己先算一下哦 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <string.h> int main() { int a=0; int b=0; for(a=0,b=0;b=0;a++,b++) b++; return 0; } 这是一道面试题,问程序运行几次呢?运行结果如何? 其实这个小题关键是我们有没有被上图所示的b=

  • 易语言中Packcom的使用方法

    一.关于packcom Packcom是易语言用来创建类型库和OCX组件与系统的连接文件的工具,通过这个工具我们就可以在易语言中使用系统中的类型库和OCX组件了. 二.Packcom的界面详解 先让我们来了解一下packcom的界面以及各部分组件的作用. 首先我们通过下面这个菜单来运行packcom. 运行之后我们就可以看到如下界面.图中箭头所示的就是每个按钮的作用. 三.如何注册类型库及OCX组件 如果系统中没有我们需要的OCX组件,我们可以通过单击"注册组件" 按钮选择我们自己的O

  • C语言中scanf函数的原样输入的坑及解决

    目录 scanf函数的原样输入的坑及解决 1.scanf函数格式控制后面输入 2.scanf函数的输入是有顺序的 3.最重要的一点就是scanf切记要原样输入 4.还有一个 scanf输入多个数据出现的问题 问题引出 执行原理 程序分析 解决方案 scanf函数的原样输入的坑及解决 scanf函数是C语言里一个输入函数,但其有很多地方需要注意: 1.scanf函数格式控制后面输入 的应该是变量的地址而不是变量本身(即变量名) 例,输入a,b 两个整型变量的值的时候,很多初学者会写成 scanf(

  • 易语言中DLL命令的开发与使用介绍

    一.关于易语言DLL 从易语言3.6版开始,已经能够支持对DLL动态链接库的开发, 编译出的DLL是标准的DLL,和其他编程语言生成的标准DLL的调用方法相同.易语言编写出的DLL,在非独立编译exe时只需要DLL文件随应用程序一起发行,而独立编译exe时无需将DLL文件随应用程序一起发行. 二.新建易语言DLL程序 新建一个易语言程序,然后选择 Windows动态链接库 图标,易语言就会自动创建 出编写DLL动态链接库的代码区(程序集),如下图所示: 创建完毕就可以在代码区里编写DLL程序.

随机推荐