假设您有80个字节的数据并且只有最后4个字节在不断变化，那么如何使用Go高效地哈希80个字节。本质上，前76个字节是相同的，而后4个字节则在不断变化。理想情况下，您希望保留前76个字节的哈希摘要的副本，而只需更改后4个字节即可。

最佳答案

您可以在Go Playground上尝试以下示例。基准结果在最后。

注意:以下实现不能安全地并发使用；我故意使它们像这样变得更简单，更快。

仅使用公共(public)API时最快(始终对所有输入进行哈希处理)

Go的哈希算法的一般概念和接口(interface)是 hash.Hash 接口(interface)。这不允许您保存哈希器的状态以及返回或倒带到保存的状态。因此，使用Go标准库的公共(public)哈希API，您始终必须从头开始计算哈希。

公共(public)API提供的是使用Hash.Reset()方法重用已经构造的哈希器来计算新输入的哈希值。这样很好，因此不需要(内存)分配即可计算多个哈希值。另外，您还可以利用可传递给Hash.Sum()的可选片段，该片段用于将当前哈希附加到该片段。这很好，因此不需要分配就可以接收哈希结果。

这是一个利用这些优势的示例:

type Cached1 struct {
    hasher hash.Hash
    result [sha256.Size]byte
}

func NewCached1() *Cached1 {
    return &Cached1{hasher: sha256.New()}
}

func (c *Cached1) Sum(data []byte) []byte {
    c.hasher.Reset()
    c.hasher.Write(data)
    return c.hasher.Sum(c.result[:0])
}

var fixed = bytes.Repeat([]byte{1}, 76)
var variantA = []byte{1, 1, 1, 1}
var variantB = []byte{2, 2, 2, 2}

var data = append(append([]byte{}, fixed...), variantA...)
var data2 = append(append([]byte{}, fixed...), variantB...)

var c1 = NewCached1()

fmt.Printf("%x\n", sha256.Sum256(data))
fmt.Printf("%x\n", sha256.Sum256(data2))

fb8e69bdfa2ad15be7cc8a346b74e773d059f96cfc92da89e631895422fe966a
10ef52823dad5d1212e8ac83b54c001bfb9a03dc0c7c3c83246fb988aa788c0c

fmt.Printf("%x\n", c1.Sum(data))
fmt.Printf("%x\n", c1.Sum(data2))

fb8e69bdfa2ad15be7cc8a346b74e773d059f96cfc92da89e631895422fe966a
10ef52823dad5d1212e8ac83b54c001bfb9a03dc0c7c3c83246fb988aa788c0c

// digest represents the partial evaluation of a checksum.
type digest struct {
    h     [8]uint32
    x     [chunk]byte
    nx    int
    len   uint64
    is224 bool // mark if this digest is SHA-224
}

type Cached2 struct {
    origv   reflect.Value
    hasherv reflect.Value
    hasher  hash.Hash

    result [sha256.Size]byte
}

func NewCached2(fixed []byte) *Cached2 {
    h := sha256.New()
    h.Write(fixed)

    c := &Cached2{origv: reflect.ValueOf(h).Elem()}
    hasherv := reflect.New(c.origv.Type())
    c.hasher = hasherv.Interface().(hash.Hash)
    c.hasherv = hasherv.Elem()

    return c
}

func (c *Cached2) Sum(data []byte) []byte {
    // Set state of the fixed hash:
    c.hasherv.Set(c.origv)

    c.hasher.Write(data)
    return c.hasher.Sum(c.result[:0])
}

var c2 = NewCached2(fixed)
fmt.Printf("%x\n", c2.Sum(variantA))
fmt.Printf("%x\n", c2.Sum(variantB))

fb8e69bdfa2ad15be7cc8a346b74e773d059f96cfc92da89e631895422fe966a
10ef52823dad5d1212e8ac83b54c001bfb9a03dc0c7c3c83246fb988aa788c0c

var d digest
// init d
saved := d

d = saved

type Cached3 struct {
    orig   mysha256.Digest
    result [sha256.Size]byte
}

func NewCached3(fixed []byte) *Cached3 {
    var d mysha256.Digest
    d.Reset()
    d.Write(fixed)

    return &Cached3{orig: d}
}

func (c *Cached3) Sum(data []byte) []byte {
    // Make a copy of the fixed hash:
    d := c.orig
    d.Write(data)
    return d.Sum(c.result[:0])
}

var c3 = NewCached3(fixed)

fmt.Printf("%x\n", c3.Sum(variantA))
fmt.Printf("%x\n", c3.Sum(variantB))

func BenchmarkCached1(b *testing.B) {
    for i := 0; i < b.N; i++ {
        c1.Sum(data)
        c1.Sum(data2)
    }
}

func BenchmarkCached2(b *testing.B) {
    for i := 0; i < b.N; i++ {
        c2.Sum(variantA)
        c2.Sum(variantB)
    }
}

func BenchmarkCached3(b *testing.B) {
    for i := 0; i < b.N; i++ {
        c3.Sum(variantA)
        c3.Sum(variantB)
    }
}

BenchmarkCached1-4   1000000     1569 ns/op     0 B/op    0 allocs/op
BenchmarkCached2-4   2000000      926 ns/op     0 B/op    0 allocs/op
BenchmarkCached3-4   2000000      872 ns/op     0 B/op    0 allocs/op

关于go - 如何在仅最后几个字节发生变化的golang数据中有效地散列(SHA 256)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45385707/