欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Go?處理大數(shù)組使用?for?range?和?for?循環(huán)的區(qū)別

 更新時間:2022年05月07日 12:05:05   作者:機器鈴砍菜刀  
這篇文章主要介紹了Go處理大數(shù)組使用for?range和for循環(huán)的區(qū)別,對于遍歷大數(shù)組而言,for循環(huán)能比for?range循環(huán)更高效與穩(wěn)定,這一點在數(shù)組元素為結(jié)構(gòu)體類型更加明顯,下文具體分析感興趣得小伙伴可以參考一下

前言:

對于遍歷大數(shù)組而言, for 循環(huán)能比 for range 循環(huán)更高效與穩(wěn)定,這一點在數(shù)組元素為結(jié)構(gòu)體類型更加明顯。

我們知道,Go 的語法比較簡潔。它并不提供類似 C 支持的 while、do...while 等循環(huán)控制語法,而僅保留了一種語句,即 for 循環(huán)。

for i := 0; i < n; i++ {
    ... ...
}

但是,經(jīng)典的三段式循環(huán)語句,需要獲取迭代對象的長度 n。鑒于此,為了更方便 Go 開發(fā)者對復合數(shù)據(jù)類型進行迭代,例如 array、slice、channel、map,Go 提供了 for 循環(huán)的變體,即 for range 循環(huán)。

副本復制問題

range 在帶來便利的同時,也給 Go 初學者帶來了一些麻煩。因為使用者需要明白一點:for range 中,參與循環(huán)表達式的只是對象的副本。

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

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

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 根本不是同一塊內(nèi)存空間。因此,無論 a 如何修改,它參與循環(huán)的副本 ac 仍然保持原始值,因此從 ac 中取出的 v 也依然是 a 的原始值,而不是修改后的值。

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

性能對比

基于副本復制問題,我們先使用基準示例來驗證一下:對于大型數(shù)組,for range 是否一定比經(jīng)典的 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 類型元素的數(shù)組。讓我們看看基準測試的結(jié)果。

$ 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

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

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

 $ 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 下降得更為明顯,性能也更加比經(jīng)典 for 循環(huán)差。

遍歷結(jié)構(gòu)體數(shù)組

上述性能測試中,我們的遍歷對象類型是 int 值的數(shù)組,如果我們將 int 元素改為結(jié)構(gòu)體會怎么樣?for 和 for range 循環(huán)各自表現(xià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 種類型的結(jié)構(gòu)體:U1~U5,它們的區(qū)別在于包含的 int 類型字段的數(shù)量。

性能測試結(jié)果如下:

 $ 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

我們看到一個現(xiàn)象:不管是什么類型的結(jié)構(gòu)體元素數(shù)組,經(jīng)典的 for 循環(huán)遍歷的性能比較一致,但是 for range 的遍歷性能會隨著結(jié)構(gòu)字段數(shù)量的增加而降低。

結(jié)論

對于遍歷大數(shù)組而言, for 循環(huán)能比 for range 循環(huán)更高效與穩(wěn)定,這一點在數(shù)組元素為結(jié)構(gòu)體類型更加明顯。

另外,由于在 Go 中切片的底層都是通過數(shù)組來存儲數(shù)據(jù),盡管有 for range 的副本復制問題,但是切片副本指向的底層數(shù)組與原切片是一致的。這意味著,當我們將數(shù)組通過切片代替后,不管是通過 for range 或者 for 循環(huán)均能得到一致的穩(wěn)定的遍歷性能。

到此這篇關(guān)于Go 處理大數(shù)組使用 for range 和 for 循環(huán)的區(qū)別的文章就介紹到這了,更多相關(guān)Go 處理大數(shù)組內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!

相關(guān)文章

  • Go?Ginrest實現(xiàn)一個RESTful接口

    Go?Ginrest實現(xiàn)一個RESTful接口

    這篇文章主要為大家介紹了Go?Ginrest實現(xiàn)一個RESTful接口示例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
    2022-08-08
  • 基于Go語言實現(xiàn)插入排序算法及優(yōu)化

    基于Go語言實現(xiàn)插入排序算法及優(yōu)化

    插入排序是一種簡單的排序算法。這篇文章將利用Go語言實現(xiàn)冒泡排序算法,文中的示例代碼講解詳細,對學習Go語言有一定的幫助,需要的可以參考一下
    2022-12-12
  • Go實現(xiàn)共享庫的方法

    Go實現(xiàn)共享庫的方法

    本文主要介紹了Go實現(xiàn)共享庫的方法,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2023-02-02
  • Golang http請求封裝的代碼示例

    Golang http請求封裝的代碼示例

    http請求封裝在項目中非常普遍,下面筆者封裝了http post請求傳json、form 和get請求,以備將來使用,文中代碼示例介紹的非常詳細,需要的朋友可以參考下
    2023-06-06
  • 深入理解golang的基本類型排序與slice排序

    深入理解golang的基本類型排序與slice排序

    大家都知道排序有內(nèi)部排序和外部排序,內(nèi)部排序是數(shù)據(jù)記錄在內(nèi)存中進行排序,而外部排序是因排序的數(shù)據(jù)很大,一次不能容納全部的排序記錄,在排序過程中需要訪問外存。下面就來詳細介紹golang的基本類型排序與slice排序,有需要的朋友們可以參考借鑒。
    2016-09-09
  • Go語言實現(xiàn)可選參數(shù)的方法小結(jié)

    Go語言實現(xiàn)可選參數(shù)的方法小結(jié)

    這篇文章主要為大家詳細介紹了Go語言實現(xiàn)可選參數(shù)的一些常見方法,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下
    2024-02-02
  • 探索分析Go?HTTP?GET請求發(fā)送body

    探索分析Go?HTTP?GET請求發(fā)送body

    這篇文章主要為大家介紹了探索分析Go?HTTP?GET請求發(fā)送body,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪
    2023-11-11
  • go實現(xiàn)base64編碼的四種方式

    go實現(xiàn)base64編碼的四種方式

    本文主要介紹了go實現(xiàn)base64編碼的四種方式,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2023-03-03
  • Golang中的http.Server源碼深入分析

    Golang中的http.Server源碼深入分析

    這篇文章主要介紹了Golang中的http.Server源碼,實現(xiàn)一個http.Server非常容易,只需要短短幾行代碼,同時有了協(xié)程的加持,Go實現(xiàn)的http.Server能夠取得非常優(yōu)秀的性能,下面我們來分析看看http.Server的源碼
    2023-05-05
  • GOPROXY:解決go get golang.org/x包失敗問題

    GOPROXY:解決go get golang.org/x包失敗問題

    這篇文章主要介紹了GOPROXY:解決go get golang.org/x包失敗問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
    2024-01-01

最新評論