在Go语言中，遍历是日常开发中最常见的操作之一。不同的遍历方式会对性能产生显著影响。本文将深入分析：
Go语言中主要有三种遍历切片的方式：
// 1. 索引遍历
for i := 0; i < len(slice); i++ {
// 使用slice[i]
}
// 2. range遍历值
for _, v := range slice {
// 使用v
}
// 3. range遍历索引和值
for i, v := range slice {
// 使用i和v
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
func BenchmarkIndexLoop(b *testing.B) {
slice := make([]int, 1000)
for i := 0; i < b.N; i++ {
for j := 0; j < len(slice); j++ {
_ = slice[j]
}
}
}
func BenchmarkRangeValue(b *testing.B) {
slice := make([]int, 1000)
for i := 0; i < b.N; i++ {
for _, v := range slice {
_ = v
}
}
}
func BenchmarkRangeIndexValue(b *testing.B) {
slice := make([]int, 1000)
for i := 0; i < b.N; i++ {
for j, v := range slice {
_, _ = j, v
}
}
}
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
测试结果如下，可以发现三者性能接近，基本相差不大。
% go test -bench=. -benchmem .
goos: darwin
goarch: arm64
pkg: main/demo
cpu: Apple M4 Pro
BenchmarkIndexLoop-12 4721586 235.7 ns/op 0 B/op 0 allocs/op
BenchmarkRangeValue-12 5085130 234.3 ns/op 0 B/op 0 allocs/op
BenchmarkRangeIndexValue-12 5101604 233.9 ns/op 0 B/op 0 allocs/op
PASS
ok main/demo 4.560s
1
2
3
4
5
6
7
8
9
10
type Item struct {
ID int
Data [4096]byte // 增加数据量以放大性能差异
}
func BenchmarkStructIndex(b *testing.B) {
var slice [1000]Item
for i := 0; i < b.N; i++ {
var tmp int
for j := 0; j < len(slice); j++ {
tmp = slice[j].ID
}
_ = tmp
}
}
func BenchmarkStructRangeValue(b *testing.B) {
var slice [1000]Item
for i := 0; i < b.N; i++ {
var tmp int
for _, v := range slice {
tmp = v.ID
}
_ = tmp
}
}
func BenchmarkStructRangeIndexValue(b *testing.B) {
var slice [1000]Item
for i := 0; i < b.N; i++ {
var tmp int
for j := range slice {
tmp = slice[j].ID
}
_ = tmp
}
}
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
运行结果如下，可以发现通过索引的方式取值的两种方式相差不大，但是直接取值的方式性能差了 500 多倍，这是因为直接取值时会进行数据的复制，而索引取值不会进行数据的复制。
$ go test -bench=. -benchmem .
goos: darwin
goarch: arm64
pkg: main/demo
cpu: Apple M4 Pro
BenchmarkStructIndex-12 4735326 237.9 ns/op 0 B/op 0 allocs/op
BenchmarkStructRangeValue-12 17096 69135 ns/op 0 B/op 0 allocs/op
BenchmarkStructRangeIndexValue-12 5123646 234.6 ns/op 0 B/op 0 allocs/op
PASS
ok main/demo 4.983s
1
2
3
4
5
6
7
8
9
10
type Item struct {
ID int
Data [4096]byte // 增加数据量以放大性能差异
}
func BenchmarkStructIndex(b *testing.B) {
var slice [1000]*Item
for i := range slice {
slice[i] = &Item{}
}
for i := 0; i < b.N; i++ {
var tmp int
for j := 0; j < len(slice); j++ {
tmp = slice[j].ID
}
_ = tmp
}
}
func BenchmarkStructRangeValue(b *testing.B) {
var slice [1000]*Item
for i := range slice {
slice[i] = &Item{}
}
for i := 0; i < b.N; i++ {
var tmp int
for _, v := range slice {
tmp = v.ID
}
_ = tmp
}
}
func BenchmarkStructRangeIndexValue(b *testing.B) {
var slice [1000]*Item
for i := range slice {
slice[i] = &Item{}
}
for i := 0; i < b.N; i++ {
var tmp int
for j := range slice {
tmp = slice[j].ID
}
_ = tmp
}
}
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
39
40
41
42
43
44
45
46
47
运行结果如下，三者性能相近，但是有个好处是可以直接修改指针对应结构体的值。
go test -bench=. -benchmem .
goos: darwin
goarch: arm64
pkg: main/demo
cpu: Apple M4 Pro
BenchmarkStructIndex-12 1864108 656.9 ns/op 2 B/op 0 allocs/op
BenchmarkStructRangeValue-12 1577792 748.6 ns/op 3 B/op 0 allocs/op
BenchmarkStructRangeIndexValue-12 1843874 661.4 ns/op 2 B/op 0 allocs/op
PASS
ok main/demo 5.995s
1
2
3
4
5
6
7
8
9
10
根据测试结果，我们得出以下结论：
for _, v := range直接值遍历[]*T)性能接近且更灵活记住：没有绝对的最佳方式，只有最适合当前场景的选择！
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。