func main() {
    var a = [5]int{1, 2, 3, 4, 5}
    var r [5]int
    fmt.Println("original a =", a)
    for i, v := range a {
        if i == 0 {
            a[1] = 12
            a[2] = 13
        }
        r[i] = v
    }
    fmt.Println("after for range loop, r =", r)
    fmt.Println("after for range loop, a =", a)
}

你認為這段代碼會輸出以下結果嗎?

original a = [1 2 3 4 5]
after for range loop, r = [1 12 13 4 5]
after for range loop, a = [1 12 13 4 5]

但是，實際輸出是；

original a = [1 2 3 4 5]
after for range loop, r = [1 2 3 4 5]
after for range loop, a = [1 12 13 4 5]

為什么會這樣?原因是參與 for range 循環(huán)是 range 表達式的副本。也就是說，在上面的例子中，實際上參與循環(huán)的是 a 的副本，而不是真正的 a。

為了讓大家更容易理解，我們把上面例子中的 for range 循環(huán)改寫成等效的偽代碼形式。

for i, v := range ac { //ac is a value copy of a
    if i == 0 {
        a[1] = 12
        a[2] = 13
    }
    r[i] = v
}

ac 是 Go 臨時分配的連續(xù)字節(jié)序列，與 a 根本不是同一塊內存空間。因此，無論 a 如何修改，它參與循環(huán)的副本 ac 仍然保持原始值，因此從 ac 中取出的 v 也依然是 a 的原始值，而不是修改后的值。

那么，問題來了，既然 for range 使用的是副本數據，那 for range 會比經典的 for 循環(huán)消耗更多的資源并且性能更差嗎?

性能對比

基于副本復制問題，我們先使用基準示例來驗證一下：對于大型數組，for range 是否一定比經典的 for 循環(huán)運行得慢?

package main
import "testing"
func BenchmarkClassicForLoopIntArray(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]int
 for i := 0; i < b.N; i++ {
  for j := 0; j < len(arr); j++ {
   arr[j] = j
  }
 }
}
func BenchmarkForRangeIntArray(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]int
 for i := 0; i < b.N; i++ {
  for j, v := range arr {
   arr[j] = j
   _ = v
  }
 }
}

在這個例子中，我們使用 for 循環(huán)和 for range 分別遍歷一個包含 10 萬個 int 類型元素的數組。讓我們看看基準測試的結果。

$ go test -bench . forRange1_test.go
goos: darwin
goarch: amd64
cpu: Intel(R) Core(TM) i5-8279U CPU @ 2.40GHz
BenchmarkClassicForLoopIntArray-8 47404 25486 ns/op 0 B/op 0 allocs/op
BenchmarkForRangeIntArray-8 37142 31691 ns/op 0 B/op 0 allocs/op
PASS
ok command-line-arguments 2.978s

從輸出結果可以看出，for range 的確會稍劣于 for 循環(huán)，當然這其中包含了編譯器級別優(yōu)化的結果(通常是靜態(tài)單賦值，或者 SSA 鏈接)。

讓我們關閉優(yōu)化開關，再次運行壓力測試。

$ go test -c -gcflags '-N -l' . -o forRange1.test
$ ./forRange1.test -test.bench .
goos: darwin
goarch: amd64
pkg: workspace/example/forRange
cpu: Intel(R) Core(TM) i5-8279U CPU @ 2.40GHz
BenchmarkClassicForLoopIntArray-8 6734 175319 ns/op 0 B/op 0 allocs/op
BenchmarkForRangeIntArray-8 5178 242977 ns/op 0 B/op 0 allocs/op
PASS

當沒有編譯器優(yōu)化時，兩種循環(huán)的性能都明顯下降， for range 下降得更為明顯，性能也更加比經典 for 循環(huán)差。

遍歷結構體數組

上述性能測試中，我們的遍歷對象類型是 int 值的數組，如果我們將 int 元素改為結構體會怎么樣?for 和 for range 循環(huán)各自表現又會如何?

package main
import "testing"
type U5 struct {
 a, b, c, d, e int
}
type U4 struct {
 a, b, c, d int
}
type U3 struct {
 b, c, d int
}
type U2 struct {
 c, d int
}
type U1 struct {
 d int
}

func BenchmarkClassicForLoopLargeStructArrayU5(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U5
 for i := 0; i < b.N; i++ {
  for j := 0; j < len(arr)-1; j++ {
   arr[j].d = j
  }
 }
}
func BenchmarkClassicForLoopLargeStructArrayU4(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U4
 for i := 0; i < b.N; i++ {
  for j := 0; j < len(arr)-1; j++ {
   arr[j].d = j
  }
 }
}
func BenchmarkClassicForLoopLargeStructArrayU3(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U3
 for i := 0; i < b.N; i++ {
  for j := 0; j < len(arr)-1; j++ {
   arr[j].d = j
  }
 }
}
func BenchmarkClassicForLoopLargeStructArrayU2(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U2
 for i := 0; i < b.N; i++ {
  for j := 0; j < len(arr)-1; j++ {
   arr[j].d = j
  }
 }
}

func BenchmarkClassicForLoopLargeStructArrayU1(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U1
 for i := 0; i < b.N; i++ {
  for j := 0; j < len(arr)-1; j++ {
   arr[j].d = j
  }
 }
}

func BenchmarkForRangeLargeStructArrayU5(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U5
 for i := 0; i < b.N; i++ {
  for j, v := range arr {
   arr[j].d = j
   _ = v
  }
 }
}
func BenchmarkForRangeLargeStructArrayU4(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U4
 for i := 0; i < b.N; i++ {
  for j, v := range arr {
   arr[j].d = j
   _ = v
  }
 }
}

func BenchmarkForRangeLargeStructArrayU3(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U3
 for i := 0; i < b.N; i++ {
  for j, v := range arr {
   arr[j].d = j
   _ = v
  }
 }
}
func BenchmarkForRangeLargeStructArrayU2(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U2
 for i := 0; i < b.N; i++ {
  for j, v := range arr {
   arr[j].d = j
   _ = v
  }
 }
}
func BenchmarkForRangeLargeStructArrayU1(b *testing.B) {
 b.ReportAllocs()
 var arr [100000]U1
 for i := 0; i < b.N; i++ {
  for j, v := range arr {
   arr[j].d = j
   _ = v
  }
 }
}

在這個例子中，我們定義了 5 種類型的結構體：U1~U5，它們的區(qū)別在于包含的 int 類型字段的數量。

性能測試結果如下：

$ go test -bench . forRange2_test.go
goos: darwin
goarch: amd64
cpu: Intel(R) Core(TM) i5-8279U CPU @ 2.40GHz
BenchmarkClassicForLoopLargeStructArrayU5-8 44540 26227 ns/op 0 B/op 0 allocs/op
BenchmarkClassicForLoopLargeStructArrayU4-8 45906 26312 ns/op 0 B/op 0 allocs/op
BenchmarkClassicForLoopLargeStructArrayU3-8 43315 27400 ns/op 0 B/op 0 allocs/op
BenchmarkClassicForLoopLargeStructArrayU2-8 44605 26313 ns/op 0 B/op 0 allocs/op
BenchmarkClassicForLoopLargeStructArrayU1-8 45752 26110 ns/op 0 B/op 0 allocs/op
BenchmarkForRangeLargeStructArrayU5-8 3072 388651 ns/op 0 B/op 0 allocs/op
BenchmarkForRangeLargeStructArrayU4-8 4605 261329 ns/op 0 B/op 0 allocs/op
BenchmarkForRangeLargeStructArrayU3-8 5857 182565 ns/op 0 B/op 0 allocs/op
BenchmarkForRangeLargeStructArrayU2-8 10000 108391 ns/op 0 B/op 0 allocs/op
BenchmarkForRangeLargeStructArrayU1-8 36333 32346 ns/op 0 B/op 0 allocs/op
PASS
ok command-line-arguments 16.160s

我們看到一個現象：不管是什么類型的結構體元素數組，經典的 for 循環(huán)遍歷的性能比較一致，但是 for range 的遍歷性能會隨著結構字段數量的增加而降低。