如果您查看“encoding/binary”包:

func (littleEndian) Uint64(b []byte) uint64 {
    _ = b[7] // bounds check hint to compiler; see golang.org/issue/14808
    return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
        uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
}

func (littleEndian) PutUint64(b []byte, v uint64) {
    _ = b[7] // early bounds check to guarantee safety of writes below
    b[0] = byte(v)
    b[1] = byte(v >> 8)
    b[2] = byte(v >> 16)
    b[3] = byte(v >> 24)
    b[4] = byte(v >> 32)
    b[5] = byte(v >> 40)
    b[6] = byte(v >> 48)
    b[7] = byte(v >> 56)
}

你会看到:

_ = b[7] // early bounds check to guarantee safety of writes below

现在考虑这个示例代码 A(见注释):

package main

import "fmt"

func main() {
    b := []byte{0, 1, 2, 3, 4, 5, 6}
    var v uint64 = 0x0807060504030201

    b[0] = byte(v)
    b[1] = byte(v >> 8)
    b[2] = byte(v >> 16)
    b[3] = byte(v >> 24)
    b[4] = byte(v >> 32)
    b[5] = byte(v >> 40)
    b[6] = byte(v >> 48)
    b[7] = byte(v >> 56) // panic: runtime error: index out of range

    fmt.Println(b)
}

还有这个示例代码 B(见评论):

package main

import "fmt"

func main() {
    b := []byte{0, 1, 2, 3, 4, 5, 6}
    var v uint64 = 0x0807060504030201

    b[7] = byte(v >> 56) // panic: runtime error: index out of range
    b[6] = byte(v >> 48)
    b[5] = byte(v >> 40)
    b[4] = byte(v >> 32)
    b[3] = byte(v >> 24)
    b[2] = byte(v >> 16)
    b[1] = byte(v >> 8)
    b[0] = byte(v)

    fmt.Println(b)
}

和示例代码 C:

package main

import "fmt"

func main() {
    b := []byte{0, 1, 2, 3, 4, 5, 6}
    var v uint64 = 0x0807060504030201

    _ = b[7] // early bounds check to guarantee safety of writes below

    b[0] = byte(v)
    b[1] = byte(v >> 8)
    b[2] = byte(v >> 16)
    b[3] = byte(v >> 24)
    b[4] = byte(v >> 32)
    b[5] = byte(v >> 40)
    b[6] = byte(v >> 48)
    b[7] = byte(v >> 56)

    fmt.Println(b)
}

所以我有两个问题:
Q1:Golang写的时候是否需要提前进行边界检查来保证写的安全？
Q2:对于早期边界检查以保证写入的安全性，哪个示例代码更简洁且性能优化(速度)，示例代码 A、B、C 还是...？

A2:我认为 B:因为它很简洁并且进行了早期边界检查，不是吗？

最佳答案

Q1: is it necessary to early bounds check to guarantee safety of writes in Golang?

这里的答案是“是和否”。一般来说，“不”，您通常不必在 Go 中插入边界检查，因为编译器会为您插入它们(这就是为什么当您尝试访问超出 slice 长度的内存位置时，您的示例会出现 panic )。但是，如果您像给出的示例那样进行多次写入，则"is"，您需要像提供的示例一样插入早期边界检查，以确保您不会只有一些写入成功，从而使您处于错误状态(或像您在示例 B 中所做的那样进行重构，以便第一次写入最大数组，确保在任何写入成功之前发生 panic )。

但是，与其说这是一个“go problem”，不如说这是一类通用的 bug。如果您不使用任何语言进行边界检查(或者如果它是一种像 Go 一样强制执行边界检查的语言，则不要从最高索引开始)，那么写入是不安全的。这在很大程度上也取决于情况；在您发布的标准库示例中，用户边界检查是必要的。但是，在您发布的第二个示例中，用户边界检查不是必需的，因为代码可以像 B 一样编写，其中编译器在第一行插入边界检查。

Q2: for early bounds check to guarantee safety of writes which Sample Code is more concise and performance optimized (speed), sample code A, B, C or ... ?

A2: I think B : because it is concise and do early bounds check , isn't it?

你是对的。在 B 中，编译器将在第一次写入时插入边界检查，以保护其余写入。因为您使用常量(7、6、... 0)对 slice 进行索引，所以编译器可以从其余部分中省略边界检查写入，因为它可以保证它们是安全的。

关于go - 是否有必要进行早期边界检查以保证 Golang 中写入的安全性？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/38548911/