unique.Handle 能否用于包含切片的值

不能直接使用。unique.Handle[T] 和 unique.Make 都要求 T 满足 comparable；切片本身不可比较，所以只要结构体中含有切片字段，整个结构体就不满足这个约束。正确做法通常不是把值改成指针，而是先提取或编码出一个语义明确的可比较键，再对这个键调用 unique.Make。

官方文档：https://pkg.go.dev/unique

最小示例会在编译阶段被拒绝

Go 1.23 引入的 unique 包用于规范化可比较值。下面的 Record 含有 []string，因此无法成为 unique.Make 的类型实参。

package main

import "unique"

type Record struct {
	Name string
	Tags []string // 切片不可比较，导致整个结构体不满足 comparable
}

func main() {
	r := Record{Name: "alpha", Tags: []string{"go", "api"}}
	_ = unique.Make(r) // 编译失败：Record 不满足 comparable
}

这不是 unique 包额外做的运行时检查，而是泛型签名 Make[T comparable] 的编译期约束。布尔值、数字、字符串、指针、通道、元素可比较的数组，以及字段全部可比较的结构体都可以作为 T；切片、映射和函数则不行。

Handle 提供的是可比较值的规范身份

对同一种 T，两个 Handle[T] 相等，当且仅当创建它们的值按 Go 的 == 规则相等。句柄比较通常可以归结为简单的指针比较，因此适合把重复出现、比较成本较高的可比较值规范化。

Handle.Value 返回生成句柄时那个 T 值的浅拷贝。这里没有“自动深比较任意对象”的机制，也不会替开发者定义切片顺序、空切片与 nil、重复元素或大小写是否属于身份的一部分。

把切片编码成无歧义的可比较键

如果标签顺序属于业务身份，可以把切片编码为字符串，并让键结构体只保留可比较字段。下面使用 JSON 编码，是为了区分包含分隔符的标签，也明确保留 nil 与空切片的差异。

package recordid

import (
	"encoding/json"
	"fmt"
	"unique"
)

type Record struct {
	Name string
	Tags []string
}

type recordKey struct {
	Name     string
	TagsJSON string // 字符串可比较，可安全放进规范键
}

func HandleOf(r Record) (unique.Handle[recordKey], error) {
	b, err := json.Marshal(r.Tags)
	if err != nil {
		// 编码失败时不生成不完整的身份键
		return unique.Handle[recordKey]{}, fmt.Errorf("编码标签: %w", err)
	}
	key := recordKey{Name: r.Name, TagsJSON: string(b)}
	return unique.Make(key), nil
}

这种方案的关键不在 JSON，而在“规范化规则只有一个”。如果标签顺序不重要，应先复制并排序，再编码；如果大小写不重要，应在编码前统一大小写。规则一旦变化，同一业务对象可能得到不同句柄，所以规范化逻辑应集中在一个函数中。

原始载荷和规范身份应分开保存

不要为了满足 comparable 而丢掉原始切片。可以让业务对象继续保存完整载荷，同时额外保存一个只表示身份的句柄：

type Item struct {
	Payload Record                   // 保留原始切片与展示数据
	ID      unique.Handle[recordKey] // 只承担稳定比较与去重身份
}

func SameIdentity(a, b Item) bool {
	// Handle 可直接比较，不需要重复比较长字符串
	return a.ID == b.ID
}

这样既不会把编码字符串扩散到业务层，也能把“内容是什么”和“按什么规则认为相同”分开。需要读取原始标签时仍访问 Payload.Tags，不要尝试从句柄键反向恢复完整对象。

改成指针虽然能编译，但通常不等于按内容去重

指针类型是可比较的，因此 unique.Make(&r) 可以通过类型检查。然而两个字段内容完全相同、地址不同的 *Record 仍然不相等，得到的句柄也不会相等。

a := &Record{Name: "alpha", Tags: []string{"go"}}
b := &Record{Name: "alpha", Tags: []string{"go"}}

ha := unique.Make(a) // 比较的是指针身份
hb := unique.Make(b) // 内容相同但地址不同

_ = ha == hb // 结果为 false，不是按切片内容去重

只有当“同一个对象地址”本来就是业务身份，而且对象地址在所需生命周期内稳定时，指针方案才合理。若目标是内容去重，指针只是绕过类型约束，没有解决身份语义。

几种方案怎么选

哈希值也可以作为可比较键，但普通哈希存在碰撞可能。若“两个不同内容绝不能被视为同一个身份”，就不能只保存短哈希；应保留可判等的完整规范编码，或在哈希命中后追加内容核对。

采用前观察三个指标

• 重复率：重复值很少时，编码和全局规范化的成本可能大于节省。
• 键大小：键越大，首次规范化与哈希成本越明显；重复比较很多时才更容易获益。
• 句柄生命周期：只要对应句柄仍然存活，规范副本就会被保留。长期集合应关注句柄是否被无意持有。

unique.Make 可被多个 goroutine 并发调用，但这不意味着原始切片可以在无同步的情况下并发修改。应先构造不可变的规范键，再把键交给 unique.Make。

常见问题

数组可以直接用于 unique.Handle 吗？

可以，前提是数组元素类型可比较。数组长度属于类型的一部分，适合固定长度数据；动态长度数据仍需要其他表示。

把 []byte 转成 string 会改变内容吗？

字符串可以保存任意字节，因此内容不会因 UTF-8 无效而丢失。需要注意转换成本，以及后续不要把字符串当作可读文本处理。

可以把 map 编码后交给 unique.Make 吗？

可以先做确定性编码，但必须确认键顺序、数字格式和空值规则稳定。不要使用输出顺序不确定的自定义序列化结果作为身份键。

为什么不直接用 reflect.DeepEqual？

reflect.DeepEqual 能比较更多类型，但每次仍需遍历内容，也不提供全局规范副本的生命周期管理。两者解决的问题不同。

参考资料

• unique 包文档：https://pkg.go.dev/unique
• Go 1.23 发布说明：https://go.dev/doc/go1.23
• Go Blog：New unique package：https://go.dev/blog/unique