funcgenerateWithCap(n int) []int { rand.Seed(time.Now().UnixNano()) nums := make([]int, 0, n) for i := 0; i < n; i++ { nums = append(nums, rand.Int()) } return nums }
funcBenchmarkForIntSlice(b *testing.B) { nums := generateWithCap(1024 * 1024) for i := 0; i < b.N; i++ { len := len(nums) var tmp int for k := 0; k < len; k++ { tmp = nums[k] } _ = tmp } }
funcBenchmarkRangeIntSlice(b *testing.B) { nums := generateWithCap(1024 * 1024) for i := 0; i < b.N; i++ { var tmp int for _, num := range nums { tmp = num } _ = tmp } }
运行结果如下：
1 2 3 4 5 6
$ go test -bench=IntSlice$ . goos: darwin goarch: amd64 pkg: example/hpg-range BenchmarkForIntSlice-8 3603 324512 ns/op BenchmarkRangeIntSlice-8 3591 322744 ns/op
funcBenchmarkForStruct(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 } }
funcBenchmarkRangeIndexStruct(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 } }
funcBenchmarkRangeStruct(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 } }
先看下 Benchmark 的结果：
1 2 3 4 5 6 7
$ go test -bench=Struct$ . goos: darwin goarch: amd64 pkg: example/hpg-range BenchmarkForStruct-8 3769580 324 ns/op BenchmarkRangeIndexStruct-8 3597555 330 ns/op BenchmarkRangeStruct-8 2194 467411 ns/op
与 for 不同的是，range 对每个迭代值都创建了一个拷贝。因此如果每次迭代的值内存占用很小的情况下，for 和 range 的性能几乎没有差异，但是如果每个迭代值内存占用很大，例如上面的例子中，每个结构体需要占据 4KB 的内存，这种情况下差距就非常明显了。
我们可以用一个非常简单的例子来证明 range 迭代时，返回的是拷贝。
1 2 3 4 5 6 7 8
persons := []struct{ no int }{{no: 1}, {no: 2}, {no: 3}} for _, s := range persons { s.no += 10 } for i := 0; i < len(persons); i++ { persons[i].no += 100 } fmt.Println(persons)
persons 是一个长度为 3 的切片，每个元素是一个结构体。
使用 range 迭代时，试图将每个结构体的 no 字段增加 10，但修改无效，因为 range 返回的是拷贝。
funcgenerateItems(n int) []*Item { items := make([]*Item, 0, n) for i := 0; i < n; i++ { items = append(items, &Item{id: i}) } return items }
funcBenchmarkForPointer(b *testing.B) { items := generateItems(1024) for i := 0; i < b.N; i++ { length := len(items) var tmp int for k := 0; k < length; k++ { tmp = items[k].id } _ = tmp } }
funcBenchmarkRangePointer(b *testing.B) { items := generateItems(1024) for i := 0; i < b.N; i++ { var tmp int for _, item := range items { tmp = item.id } _ = tmp } }
切片元素从结构体 Item 替换为指针 *Item 后，for 和 range 的性能几乎是一样的。而且使用指针还有另一个好处，可以直接修改指针对应的结构体的值。
3 总结
range 在迭代过程中返回的是迭代值的拷贝，如果每次迭代的元素的内存占用很低，那么 for 和 range 的性能几乎是一样，例如 []int。但是如果迭代的元素内存占用较高，例如一个包含很多属性的 struct 结构体，那么 for 的性能将显著地高于 range，有时候甚至会有上千倍的性能差异。对于这种场景，建议使用 for，如果使用 range，建议只迭代下标，通过下标访问迭代值，这种使用方式和 for 就没有区别了。如果想使用 range 同时迭代下标和值，则需要将切片/数组的元素改为指针，才能不影响性能。
