Go的邊界檢查有哪些類型

本篇內容主要講解“Go的邊界檢查有哪些類型”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Go的邊界檢查有哪些類型”吧!

1. 什么是邊界檢查?

邊界檢查，英文名 Bounds Check Elimination，簡稱為 BCE。它是 Go  語言中防止數組、切片越界而導致內存不安全的檢查手段。如果檢查下標已經越界了，就會產生 Panic。

邊界檢查使得我們的代碼能夠安全地運行，但是另一方面，也使得我們的代碼運行效率略微降低。

比如下面這段代碼，會進行三次的邊界檢查

package main  func f(s []int) {     _ = s[0]  // 檢查第一次     _ = s[1]  // 檢查第二次     _ = s[2]  // 檢查第三次 }  func main() {}

你可能會好奇了，三次?我是怎么知道它要檢查三次的。

實際上，你只要在編譯的時候，加上參數即可，命令如下

$ go build -gcflags="-d=ssa/check_bce/debug=1" main.go # command-line-arguments ./main.go:4:7: Found IsInBounds ./main.go:5:7: Found IsInBounds ./main.go:6:7: Found IsInBounds

2. 邊界檢查的條件?

并不是所有的對數組、切片進行索引操作都需要邊界檢查。

比如下面這個示例，就不需要進行邊界檢查，因為編譯器根據上下文已經得知，s  這個切片的長度是多少，你的終止索引是多少，立馬就能判斷到底有沒有越界，因此是不需要再進行邊界檢查，因為在編譯的時候就已經知道這個地方會不會 panic。

package main  func f() {     s := []int{1,2,3,4}     _ = s[:9]  // 不需要邊界檢查 } func main()  {}

因此可以得出結論，對于在編譯階段無法判斷是否會越界的索引操作才會需要邊界檢查，比如這樣子

package main   func f(s []int) {     _ = s[:9]  // 需要邊界檢查 } func main()  {}

3. 邊界檢查的特殊案例

3.1 案例一

在如下示例代碼中，由于索引 2 在最前面已經檢查過會不會越界，因此聰明的編譯器可以推斷出后面的索引 0 和 1 不用再檢查啦

 package main  func f(s []int) {     _ = s[2] // 檢查一次     _ = s[1]  // 不會檢查     _ = s[0]  // 不會檢查 }  func main() {}

3.2 案例二

在下面這個示例中，可以在邏輯上保證不會越界的代碼，同樣是不會進行越界檢查的。

package main  func f(s []int) {     for index, _ := range s {         _ = s[index]         _ = s[:index+1]         _ = s[index:len(s)]     } }  func main()  {}

3.3 案例三

在如下示例代碼中，雖然數組的長度和容量可以確定，但是索引是通過 rand.Intn()  函數取得的隨機數，在編譯器看來這個索引值是不確定的，它有可能大于數組的長度，也有可能小于數組的長度。

因此第一次是需要進行檢查的，有了第一次檢查后，第二次索引從邏輯上就能推斷，所以不會再進行邊界檢查。

package main  import (     "math/rand" )  func f()  {     s := make([]int, 3, 3)     index := rand.Intn(3)      _ = s[:index]  // 第一次檢查     _ = s[index:]  // 不會檢查 }  func main()  {}

但如果把上面的代碼稍微改一下，讓切片的長度和容量變得不一樣，結果又會變得不一樣了。

package main  import (     "math/rand" )  func f()  {     s := make([]int, 3, 5)     index := rand.Intn(3)      _ = s[:index]  // 第一次檢查     _ = s[index:]  // 第二次檢查 }  func main()  {}

我們只有當數組的長度和容量相等時， :index 成立，才能一定能推出 index: 也成立，這樣的話，只要做一次檢查即可

一旦數組的長度和容量不相等，那么 index 在編譯器看來是有可能大于數組長度的，甚至大于數組的容量。

我們假設 index 取得的隨機數為 4，那么它大于數組長度，此時 s[:index] 雖然可以成功，但是 s[index:]  是要失敗的，因此第二次邊界的檢查是有必要的。

你可能會說， index 不是最大值為 3 嗎?怎么可能是 4呢?

要知道編譯器在編譯的時候，并不知道 index 的最大值是 3 呢。

小結一下

當數組的長度和容量相等時，s[:index] 成立能夠保證 s[index:] 也成立，因為只要檢查一次即可

當數組的長度和容量不等時，s[:index] 成立不能保證 s[index:] 也成立，因為要檢查兩次才可以

3.4 案例四

有了上面的鋪墊，再來看下面這個示例，由于數組是調用者傳入的參數，所以編譯器的編譯的時候無法得知數組的長度和容量是否相等，因此只能保險一點，兩個都檢查。

package main  import (     "math/rand" )  func f(s []int, index int) {     _ = s[:index] // 第一次檢查     _ = s[index:] // 第二次檢查 }  func main()  {}

但是如果把兩個表達式的順序反過來，就只要做一次檢查就行了，原因我就不贅述了。

package main  import (     "math/rand" )  func f(s []int, index int) {     _ = s[index:] // 第一次檢查     _ = s[:index] // 不用檢查 }  func main()  {}

5. 主動消除邊界檢查

雖然編譯器已經非常努力去消除一些應該消除的邊界檢查，但難免會有一些遺漏。

這就需要"警民合作"，對于那些編譯器還未考慮到的場景，但開發者又極力追求程序的運行效率的，可以使用一些小技巧給出一些暗示，告訴編譯器哪些地方可以不用做邊界檢查。

比如下面這個示例，從代碼的邏輯上來說，是完全沒有必要做邊界檢查的，但是編譯器并沒有那么智能，實際上每個for循環，它都要做一次邊界的檢查，非常的浪費性能。

package main   func f(is []int, bs []byte) {     if len(is) >= 256 {         for _, n := range bs {             _ = is[n] // 每個循環都要邊界檢查         }     } } func main()  {}

可以試著在 for 循環前加上這么一句 is = is[:256] 來告訴編譯器新 is 的長度為 256，最大索引值為 255，不會超過 byte  的最大值，因為 is[n] 從邏輯上來說是一定不會越界的。

package main   func f(is []int, bs []byte) {     if len(is) >= 256 {         is = is[:256]         for _, n := range bs {             _ = is[n] // 不需要做邊界檢查         }     } } func main()  {}

到此，相信大家對“Go的邊界檢查有哪些類型”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！