Go maps.EqualFunc 比较 nil map 和空 map 为什么返回 true

在 Go 里，nil map 和通过 make 创建但还没有元素的空 map，放进 maps.EqualFunc 比较时会得到 true。原因不是它们的内部状态完全一样，而是这个函数定义的比较目标是“键值集合是否相等”：两者的长度都是 0，没有键需要继续比较。

官方地址：https://pkg.go.dev/maps#EqualFunc

nil map 和空 map，差别到底在哪里

nil map 是 map 变量的零值；空 map 则通常是 make(map[string]int) 得到的已初始化 map。它们都可以安全地读取，读取不存在的键会得到值类型的零值，len 也都是 0；但 nil map 不能直接写入，空 map 可以写入。

package main

import "fmt"

func main() {
	var nilMap map[string]int
	emptyMap := make(map[string]int)

	// 读取和 len 对 nil map 都是安全的，但写入前必须确认 map 已初始化。
	fmt.Println(nilMap["go"], len(nilMap))
	fmt.Println(emptyMap["go"], len(emptyMap))
	emptyMap["go"] = 1
	fmt.Println(emptyMap)
}

因此，nil 身份是一个容器状态；“里面有没有键值”是另一个问题。maps.EqualFunc 选择的是后者。

EqualFunc 为什么会把它们判定为相等

EqualFunc 的核心规则可以压缩成两句话：先比较两个 map 的 len；长度相同后，遍历第一个 map，在第二个 map 中用相同的键查找值，再调用 eq(v1, v2) 判断值是否相等。任一长度不同、键不存在或值比较返回 false，结果就是 false。

当两个参数分别是 nil map 和空 map 时，比较的第一关就是 0 == 0。第一个 map 没有元素，遍历体不会执行，也就没有键缺失或值比较失败的机会，函数自然返回 true。

// EqualFunc 的比较逻辑示意：键仍然按 == 查找，值交给 eq。
func equalFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](
	m1 M1, m2 M2, eq func(V1, V2) bool,
) bool {
	if len(m1) != len(m2) {
		return false // 长度先决定一部分结果。
	}
	for k, v1 := range m1 {
		v2, ok := m2[k]
		if !ok || !eq(v1, v2) {
			return false // 缺键或值不满足 eq 都不相等。
		}
	}
	return true // 空 map 会直接走到这里。
}

用三组输入看清返回值

下面的例子把 nil/空、相同键值、缺少键三种情况放在一起。比较函数返回 bool，并没有把 nil 状态额外纳入规则。

package main

import (
	"fmt"
	"maps"
)

func main() {
	var nilMap map[string]int
	emptyMap := map[string]int{}
	left := map[string]int{"go": 1}
	right := map[string]int{"go": 1}
	missing := map[string]int{}

	// int 可以直接用 == 比较，回调只负责表达值的相等规则。
	eqInt := func(a, b int) bool { return a == b }
	fmt.Println(maps.EqualFunc(nilMap, emptyMap, eqInt)) // true
	fmt.Println(maps.EqualFunc(left, right, eqInt))      // true
	fmt.Println(maps.EqualFunc(left, missing, eqInt))    // false
}

第三组即使回调永远返回 true 也不会被判定相等，因为 len(left) 与 len(missing) 不同；这说明回调不是绕过键集合检查的开关。

自定义 eq 只改变值的判断

EqualFunc 的价值在于两个 map 的值类型可以不同，或者值不适合直接使用 ==。例如一个 map 保存字符串，另一个保存字节切片，可以在回调中定义大小写不敏感的值比较。键仍然必须是可比较类型，并且仍按键的 == 语义匹配。

package main

import (
	"fmt"
	"maps"
	"strings"
)

func main() {
	words := map[int]string{1: "Go", 2: "Map"}
	bytes := map[int][]byte{1: []byte("go"), 2: []byte("MAP")}

	// 值类型不同，先把 []byte 转成 string，再做大小写无关比较。
	caseInsensitive := func(a string, b []byte) bool {
		return strings.EqualFold(a, string(b))
	}
	fmt.Println(maps.EqualFunc(words, bytes, caseInsensitive)) // true
}

这里的 true 只表示两个 map 的键集合相同，且每一对对应值通过了 caseInsensitive。它不表示两个 map 的底层类型、分配状态或内存布局相同。

业务真的要区分 nil 与空，应该怎么写

如果业务定义“未提供”与“已提供但为空”是两个状态，就不要期待 EqualFunc 替你保留这个信息。先判断 nil，再决定是否进行内容比较；如果只关心键值集合，则直接使用 EqualFunc 更符合它的语义。

package main

import "maps"

func samePayload(a, b map[string]string) bool {
	// 先处理业务状态，再处理容器内容，避免把 nil 与空混成同一状态。
	if (a == nil) != (b == nil) {
		return false
	}
	return maps.EqualFunc(a, b, func(x, y string) bool {
		return x == y // 内容比较仍只负责对应键的值。
	})
}

反过来，如果接口层已经把 nil 和空统一解释为“没有字段”，那就不要额外加 nil 判断，否则会把本来等价的两个输入拆成不同结果。判断标准应来自业务契约，而不是来自 map 的个人偏好。

几个容易误读的边界

• 空 map 不等于可写的 nil map：比较返回 true 不会改变 nil map 的写入限制，向 nil map 赋值仍会触发运行时错误。
• eq 不负责比较键：回调只接收两个对应值；键是否存在由 map 查找和键的可比较规则决定。
• 不讨论并发安全：读写 map 的并发安全问题与 EqualFunc 的 nil/空语义是两条不同边界，不能用相等结果替代并发设计。
• 不要把相等当成同一对象：EqualFunc 比较的是键值关系，不会判断两个 map 是否引用同一份底层存储。

结论

maps.EqualFunc(nilMap, emptyMap, eq) 返回 true，是因为函数先比较长度，而 nil map 和空 map 的长度都为 0；随后没有任何键需要查找，回调也不会被调用。需要“内容相等”时直接使用它，需要“状态也相等”时先单独比较 nil，再决定是否比较内容。

相关问题

EqualFunc 会调用 eq 比较 nil map 的值吗？

不会。两个 map 都为空时遍历体不执行，因此没有值对，也不会调用 eq。

为什么不能只让 eq 返回 true 来忽略键差异？

因为键集合和长度检查发生在回调之外。回调只能决定已经按键匹配到的那一对值是否相等。

什么时候应该保留 nil 与空的区别？

当 nil 表示未提供、未初始化或继承默认值，而空 map 表示调用方明确提供了空集合时，应在调用 EqualFunc 前先比较 nil 状态。