文章转载地址：https://www.flysnow.org/2018/10/20/golang-for-range-slice-map.html
如果我们要遍历某个数组，Map 集合、Slice 切片等，Go 语言(Golang) 为我们提供了比较好的 For Range 方式。
range 是一个关键字， 表示范围，和 for 配合使用可以迭代 数组、Map、Slice等集合，用法比较简洁，那么，这种
迭代方式和 for i=0;i<N;i++ 对比，性能怎么样呢？下面通过 Go 的基准测试对比一下两者的性能
For-Range 的基本使用
for range 的使用非常简单，这里演示两种集合类型的使用
package main
import "fmt"
func main() {
ages := []string{"10","20","30"}
for i,age := range ages {
fmt.Println(i,age)
}
}
这里是针对 Slice 切片的迭代使用，使用 range 关键字返回两个变量 i,age ，第一个是 Slice 切片的索引，第二个
是 Slice 切片的内容，打印结果如下：
0 10
1 20
2 30
下面再看看 Map 的 for range 使用示例：
package main
import "fmt"
func main() {
ages:=map[string]int{"张三":15,"李四":20,"王武":36}
for name,age:=range ages{
fmt.Println(name,age)
}
}
在使用for range迭代map的时候，返回的第一个变量是key,第二个变量是value，也就是我们例子中对应的name和ages
。我们运行程序看看输出结果：
张三 15
李四 20
王五 36
常规 For 循环对比
比如对于 Slice 切片，我们有两种迭代方式：一种是常规的for i:=0;i<N;i++的方式；一种是for range的方式，如下示例：
package main_test import "testing" const N = 1000 // 常规 for 迭代 slice
func ForSlice(s []string) {
len := len(s)
for i := 0; i < len; i++ {
_, _ = i,s[i]
}
} // for range 迭代 slice
func RangeForSlice(s []string) {
for i, v := range s {
_, _ = i, v
}
} // 初始化 slice
func initSlice() []string{
s := make([]string,N) for i := 0;i < N;i++ {
s[i] = "www.flysnow.org"
}
return s
} // 基准测试函数
func BenchmarkForSlice(b *testing.B) {
s := initSlice() b.ResetTimer()
for i := 0;i < b.N;i++ {
ForSlice(s)
}
} func BenchmarkRangeForSlice(b *testing.B) {
s := initSlice() b.ResetTimer()
for i := 0;i < b.N;i++ {
RangeForSlice(s)
}
}
输出结果如下：
goos: windows
goarch: amd64
BenchmarkForSlice-8 5000000 303 ns/op
BenchmarkRangeForSlice-8 3000000 512 ns/op
PASS
ok _/E_/GoProject/development/src 4.692s
从上面的输出结果可以看到，常规的 For 循环的性能更高。主要是因为 for range 是每次对循环元素的拷贝，而
for 循环，它获取集合内元素是通过 s[i]，这种索引指针引用的方式，要比拷贝性能高得多
那么既然是元素拷贝的问题，我们在使用 range 方式迭代 slice 时候的目的也是为了获取元素，现在换一种方式实现 for range：
// for range 迭代 slice
func RangeForSlice(s []string) {
for i, _ := range s {
_, _ = i, s[i]
}
}
输出结果：
goos: windows
goarch: amd64
BenchmarkForSlice-8 5000000 303 ns/op
BenchmarkRangeForSlice-8 5000000 308 ns/op
PASS
ok _/E_/GoProject/development/src 4.218s
结果和常规的 for 循环一样。原因是我们通过 _ 舍弃了元素的复制，然后通过 s[i] 方式获取迭代的元素
Map 遍历
对于 map 来说，我们并不能使用 for i=0;i<N;i++ 的方式，大部分我们使用 for range 的方式：
package main_test import (
"fmt"
"testing"
) const N = 1000 // for range For map
func RangeForMap1(m map[int]string) {
for k, v := range m{
_,_ = k,v
}
} // 初始化 map
func initMap() map[int]string {
m := make(map[int]string,N) for i := 0;i < N;i++ {
m[i] = fmt.Sprint("www.flysnow.org",i)
} return m
} func BenchmarkRangeForMap1(b *testing.B) {
m := initMap() b.ResetTimer()
for i := 0; i < b.N; i++ {
RangeForMap1(m)
}
}
运行结果如下：
goos: windows
goarch: amd64
BenchmarkRangeForMap1-8 100000 14535 ns/op
PASS
ok _/E_/GoProject/development/src 2.333s
相比较 slice，Map 遍历的性能更差。现在，我们使用上面优化遍历 slice 的方式优化遍历 map，减少值拷贝，如下示例：
func RangeForMap2(m map[int]string) {
for k, _ := range m{
_,_ = k,m[k]
}
}
func BenchmarkRangeForMap2(b *testing.B) {
m := initMap()
b.ResetTimer()
for i := 0; i < b.N; i++ {
RangeForMap2(m)
}
}
运行结果如下：
goos: windows
goarch: amd64
BenchmarkRangeForMap1-8 100000 14290 ns/op
BenchmarkRangeForMap2-8 100000 22240 ns/op
PASS
ok _/E_/GoProject/development/src 4.929s
我们看到，优化后的结果性能明显下降了，这和我们上面测试 slice 不一样，这次没有提升反而下降了
For Range 原理
range for slice：
// The loop we generate:
// len_temp := len(range)
// range_temp := range
// for index_temp = 0; index_temp < len_temp; index_temp++ {
// value_temp = range_temp[index_temp]
// index = index_temp
// value = value_temp
// original body
// }
遍历 slice 前先是对要遍历的 slice 做一个拷贝，然后获取 slice 的长度作为循环次数，循环体中每次循环
会先获取元素值，我们还可以看到遍历过程中每次迭代都会对 index 和 value 进行赋值，如果数据量比较大或
者 value 为 string 时，对 value 的赋值操作可能是多余的，所以在上面我们使用 range 遍历 slice 的时候，可以
忽略 value，使用 slice[index] 的方式提升性能
range for 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
// }
看上面的实现方式，结合我们使用 for range slice 的 _ 优化方式，我们可以看到看似减少了一次赋值操作，但
是通过 key 查找 value 的性能消耗高于赋值消耗，这就是为什么优化没有起到作用