Go 中 struct 作为 map 的 key

为什么 struct 能作为 map 的 key？

在 Go 语言中，map 的键类型必须支持 == 和 != 操作，也就是必须是可比较类型。struct 本身不一定可比较，它只有在所有字段都可比较时，才可以用作 map 的 key。

简单来说：如果你的 struct 中所有字段都是可比较类型（比如 int、string、bool、指针、channel、数组等），那么这个 struct 就是可比较的，自然可以作为 map 的 key。

可比较的 struct 示例

package main

import "fmt"

// 所有字段均可比较
type Person struct {
    Name string
    Age  int
}

func main() {
    m := make(map[Person]string)

    p1 := Person{Name: "Alice", Age: 30}
    p2 := Person{Name: "Bob", Age: 25}

    m[p1] = "Engineer"
    m[p2] = "Designer"

    // 通过完全相同的 struct 字面量取值
    fmt.Println(m[Person{Name: "Alice", Age: 30}]) // 输出: Engineer

    // 注意：字段顺序不重要，值相等即可
    fmt.Println(m[Person{Age: 25, Name: "Bob"}])   // 输出: Designer
}

编译器会在编译期检查 struct 是否可比较，如果使用了不可比较的类型作为字段，会直接报错。

哪些 struct 不能作为 map 的 key？

包含以下任意一种字段的 struct 都不可比较，因此不能作为 map key：

• slice（切片）
• map
• function
• 以及包含上述类型的 struct 或数组（数组元素不可比较）

错误示例

type User struct {
    Name string
    Tags []string // slice 不可比较
}

func main() {
    m := make(map[User]string) // 编译错误：invalid map key type User
}

如果确实需要把这些不可比较的数据作为 key 的一部分，通常的做法是：

• 将其序列化为字符串（例如 json.Marshal），然后用 string 作为 key。
• 或者使用一个中间唯一标识符（如 ID）作为 key。

struct 作为 key 时的值拷贝特性

当 struct 用作 map 的 key 时，map 内部会存储 key 的拷贝。这意味着：

• 插入 map 时，key struct 会被复制一份。
• 通过 key 查找时，会使用你提供的 struct 值的拷贝进行比较。

因此，对 map 中已存在的 key 的 struct 字段进行原地修改是不允许的。

type Point struct {
    X, Y int
}

m := map[Point]string{{0, 0}: "origin"}

// 试图修改 key 的字段，编译错误
// m[Point{0, 0}].X = 10 // cannot assign to struct field m[Point{…}].X in map

这是因为 m[key] 返回的是值拷贝（对于非指针类型的 value），或者不可寻址的值。即使 value 是 struct，也不能直接修改其字段。如需修改，你需要：

1. 取出整个 value struct。
2. 修改它的字段。
3. 再用相同的 key 存回去。

if val, ok := m[Point{0, 0}]; ok {
    val.X = 10
    m[Point{0, 0}] = val // 注意 key 并没有变
}

如果 value 是指针类型（map[Point]*Point），则可以通过指针修改字段，但此时 map 中存储的是指针，key 仍然是不可变的 struct。

嵌入 struct 作为 key

如果 struct 嵌入了另一个可比较的 struct，那么只要所有字段（包括嵌入部分）都可比较，整个 struct 也是可比较的，可以作为 map key。

type Address struct {
    City  string
    Zip   int
}

type Person struct {
    Name    string
    Address // 匿名嵌入，字段会被提升
}

func main() {
    m := make(map[Person]string)

    m[Person{Name: "Alice", Address: Address{"NYC", 10001}}] = "ok"

    fmt.Println(m[Person{
        Name:    "Alice",
        Address: Address{City: "NYC", Zip: 10001},
    }]) // 输出: ok
}

只要 Address 内所有字段可比较，Person 就可以作为 key。

使用 struct 指针作为 key

struct 值本身可比较，那么指针也自然可比较。但要注意：两个指针相等意味着指向同一个地址，而不是指向的结构体内容相等。

因此，使用指针作为 key 时，map 比较的是地址：

type Data struct {
    Value int
}

p1 := &Data{10}
p2 := &Data{10}
m := make(map[*Data]string)
m[p1] = "first"
m[p2] = "second" // p2 的地址与 p1 不同，所以是不同的 key

fmt.Println(len(m)) // 2

除非你确实需要按地址区分，否则通常不建议用 struct 指针作为 map 的 key，因为这很容易引入难以调试的问题。

性能与内存考虑

• struct 作为 key 时，哈希计算会扫描 struct 的所有字段。字段越多、越大，哈希计算越慢。
• 如果 struct 非常大，建议使用字段子集的哈希值、字符串形式或指针（需谨慎）作为 key。
• 通常，小到中等大小的 struct 直接作为 key 是完全可接受的，优先考虑代码的清晰度。

常见陷阱及解决方案

总结

• struct 可以作为 map 的 key，只要其所有字段均可比较。
• 不可比较字段（slice、map、function）会导致编译错误。
• struct key 是值拷贝，不能通过 m[key] 直接修改原 struct 字段。
• 嵌入 struct、struct 指针都有各自需要注意的细节。
• 优先选择清晰、可维护的方式设计 key，性能问题大多场景下不是瓶颈。