当前位置：首页 > 脚本中心 > 其它 > 详细页面

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

时间：2022-09-12来源：www.pcxitongcheng.com作者：电脑系统城

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

前言

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

for range基本用法

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

1、遍历数组

1
2
3
4
5 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

1
2
3
4
5 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

1
2
3
4
5 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

1
2
3
4
5 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

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

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

结果：

[I am peachesTao]

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

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

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

1
2
3
4
5
6
7 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中所有元素都是一样的，如下：

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

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

1
2
3
4
5 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中有链接地址）

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 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
}
}

运行基准测试命令：

1	`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

1
2
3
4 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】方法中有如下注释。

1
2
3
4
5
6
7 // 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

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

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

1
2
3
4
5
6
7
8
9 // The loop we generate:
// for {
// index_temp, ok_temp = <-range
// if !ok_temp {
// break
// }
// index = index_temp
// original body
// }