Go语言中任意对象哈希的正确方法与实践

package main

import (
    "crypto/md5"
    "encoding/binary"
    "fmt"
    "io"
)

// Hash 函数尝试直接将对象写入MD5摘要器
func Hash(obj interface{}) []byte {
    digest := md5.New()
    // binary.Write 期望写入固定大小的数据类型或固定大小结构的组合
    if err := binary.Write(digest, binary.LittleEndian, obj); err != nil {
        // 对于像 int 这样的非固定大小或复杂类型，会引发 panic
        panic(err)
    }
    return digest.Sum(nil)
}

func main() {
    // 尝试对 int 类型进行哈希，将导致 panic: binary.Write: invalid type int
    // fmt.Printf("%x\n", Hash(123))

    // binary.Write 适用于固定大小的类型，例如 int32
    var val int32 = 123
    fmt.Printf("Hash of int32(123): %x\n", Hash(val))

    // 对于更复杂的结构体，如果其所有字段都是固定大小的，也可能工作
    type MyStruct struct {
        ID    int32
        Value float64
    }
    s := MyStruct{ID: 1, Value: 3.14}
    fmt.Printf("Hash of MyStruct: %x\n", Hash(s))

    // 但如果结构体包含切片、字符串或接口等可变大小类型，binary.Write 仍会失败
    type AnotherStruct struct {
        Name string // string 是可变大小类型
    }
    // fmt.Printf("%x\n", Hash(AnotherStruct{Name: "test"})) // 这会 panic
}

package main

import (
    "bytes"
    "crypto/md5"
    "encoding/gob"
    "fmt"
    "io"
)

// HashWithGob 使用 gob 序列化对象后进行 MD5 哈希
func HashWithGob(obj interface{}) []byte {
    var b bytes.Buffer
    encoder := gob.NewEncoder(&b)
    if err := encoder.Encode(obj); err != nil {
        panic(fmt.Errorf("gob encode failed: %w", err))
    }

    digest := md5.New()
    if _, err := io.Copy(digest, &b); err != nil {
        panic(fmt.Errorf("copy to digest failed: %w", err))
    }
    return digest.Sum(nil)
}

func main() {
    type Person struct {
        Name string
        Age  int
        Tags []string
    }

    p1 := Person{Name: "Alice", Age: 30, Tags: []string{"developer", "go"}}
    p2 := Person{Name: "Alice", Age: 30, Tags: []string{"developer", "go"}} // 与 p1 内容相同
    p3 := Person{Name: "Bob", Age: 25, Tags: []string{"designer"}}

    fmt.Printf("Hash of p1 (gob): %x\n", HashWithGob(p1))
    fmt.Printf("Hash of p2 (gob): %x\n", HashWithGob(p2))
    fmt.Printf("Hash of p3 (gob): %x\n", HashWithGob(p3))

    // 尝试对 int 类型进行哈希
    fmt.Printf("Hash of int(123) (gob): %x\n", HashWithGob(123))
    fmt.Printf("Hash of string(\"hello\") (gob): %x\n", HashWithGob("hello"))
}

package main

import (
    "crypto/md5"
    "encoding/json"
    "fmt"
    "io"
)

// HashWithJSON 使用 JSON 序列化对象后进行 MD5 哈希
func HashWithJSON(obj interface{}) ([]byte, error) {
    // json.Marshal 将对象序列化为 JSON 格式的字节数组
    data, err := json.Marshal(obj)
    if err != nil {
        return nil, fmt.Errorf("json marshal failed: %w", err)
    }

    digest := md5.New()
    if _, err := digest.Write(data); err != nil {
        return nil, fmt.Errorf("write to digest failed: %w", err)
    }
    return digest.Sum(nil), nil
}

func main() {
    type Person struct {
        Name string
        Age  int
        Tags []string
    }

    p1 := Person{Name: "Alice", Age: 30, Tags: []string{"developer", "go"}}
    p2 := Person{Name: "Alice", Age: 30, Tags: []string{"developer", "go"}}
    p3 := Person{Name: "Bob", Age: 25, Tags: []string{"designer"}}

    h1, _ := HashWithJSON(p1)
    h2, _ := HashWithJSON(p2)
    h3, _ := HashWithJSON(p3)

    fmt.Printf("Hash of p1 (json): %x\n", h1)
    fmt.Printf("Hash of p2 (json): %x\n", h2)
    fmt.Printf("Hash of p3 (json): %x\n", h3)

    // 尝试对 int 类型进行哈希
    hInt, _ := HashWithJSON(123)
    fmt.Printf("Hash of int(123) (json): %x\n", hInt)

    // 尝试对 string 类型进行哈希
    hStr, _ := HashWithJSON("hello world")
    fmt.Printf("Hash of string(\"hello world\") (json): %x\n", hStr)

    // 复杂类型，包含 Map
    type Data struct {
        ID   int
        Info map[string]string
    }
    d1 := Data{ID: 1, Info: map[string]string{"keyA": "valueA", "keyB": "valueB"}}
    d2 := Data{ID: 1, Info: map[string]string{"keyB": "valueB", "keyA": "valueA"}} // 键顺序不同

    hD1, _ := HashWithJSON(d1)
    hD2, _ := HashWithJSON(d2)

    fmt.Printf("Hash of d1 (json, map order A,B): %x\n", hD1)
    fmt.Printf("Hash of d2 (json, map order B,A): %x\n", hD2)
    fmt.Println("Are d1 and d2 hashes equal?", bytes.Equal(hD1, hD2))
}