在 Go 中计算 hashCode

Question

Java 对象有一个hashCode，它比加密哈希便宜。如何在 Go 中实现这样的 hashCode？

Answer 1

Go 编程语言是开源的。你可以查看它的标准库，了解快速高效的 Go 哈希实现。

这里是：

runtime/hash64.go对于 64 位架构

runtime/hash32.go用于 32 位架构

它们未导出，但如果您在应用程序中需要它们，您只需将代码复制到您的项目中即可。另请注意，如果您的 CPU 支持它，Go 运行时将使用aeshash您的 CPU 的功能（更多信息请点击此处：Go 如何计算地图中键的哈希值？）。

引用较短的32 位版本：

const (

    // Constants for multiplication: four random odd 32-bit numbers.

    m1 = 3168982561

    m2 = 3339683297

    m3 = 832293441

    m4 = 2336365089

)

func memhash(p unsafe.Pointer, seed, s uintptr) uintptr {

    if GOARCH == "386" && GOOS != "nacl" && useAeshash {

        return aeshash(p, seed, s)

    }

    h := uint32(seed + s*hashkey[0])

tail:

    switch {

    case s == 0:

    case s < 4:

        h ^= uint32(*(*byte)(p))

        h ^= uint32(*(*byte)(add(p, s>>1))) << 8

        h ^= uint32(*(*byte)(add(p, s-1))) << 16

        h = rotl_15(h*m1) * m2

    case s == 4:

        h ^= readUnaligned32(p)

        h = rotl_15(h*m1) * m2

    case s <= 8:

        h ^= readUnaligned32(p)

        h = rotl_15(h*m1) * m2

        h ^= readUnaligned32(add(p, s-4))

        h = rotl_15(h*m1) * m2

    case s <= 16:

        h ^= readUnaligned32(p)

        h = rotl_15(h*m1) * m2

        h ^= readUnaligned32(add(p, 4))

        h = rotl_15(h*m1) * m2

        h ^= readUnaligned32(add(p, s-8))

        h = rotl_15(h*m1) * m2

        h ^= readUnaligned32(add(p, s-4))

        h = rotl_15(h*m1) * m2

    default:

        v1 := h

        v2 := uint32(seed * hashkey[1])

        v3 := uint32(seed * hashkey[2])

        v4 := uint32(seed * hashkey[3])

        for s >= 16 {

            v1 ^= readUnaligned32(p)

            v1 = rotl_15(v1*m1) * m2

            p = add(p, 4)

            v2 ^= readUnaligned32(p)

            v2 = rotl_15(v2*m2) * m3

            p = add(p, 4)

            v3 ^= readUnaligned32(p)

            v3 = rotl_15(v3*m3) * m4

            p = add(p, 4)

            v4 ^= readUnaligned32(p)

            v4 = rotl_15(v4*m4) * m1

            p = add(p, 4)

            s -= 16

        }

        h = v1 ^ v2 ^ v3 ^ v4

        goto tail

    }

    h ^= h >> 17

    h *= m3

    h ^= h >> 13

    h *= m4

    h ^= h >> 16

    return uintptr(h)

}

// Note: in order to get the compiler to issue rotl instructions, we

// need to constant fold the shift amount by hand.

// TODO: convince the compiler to issue rotl instructions after inlining.

func rotl_15(x uint32) uint32 {

    return (x << 15) | (x >> (32 - 15))

}