Go 泛型怎样写保持顺序的切片去重

Go 泛型做“保序切片去重”时，最稳妥的写法是用 map[T]struct{} 记录已经见过的元素，再按原切片顺序把第一次出现的值追加到结果。泛型参数约束为 comparable，既能覆盖整数、字符串和可比较结构体，也能让编译器拒绝不能作为 map 键的切片、map 等类型。

官方资料：https://go.dev/doc/tutorial/generics

这里讨论的是“全局去重”：例如 ["go", "rust", "go", "java", "rust"] 变成 ["go", "rust", "java"]，保留每个值第一次出现的位置。它和只合并连续重复值的 slices.Compact 不是一回事。

先把两种去重语义分开

如果重复值只会相邻出现，标准库 slices.Compact 可以合并连续段；如果同一个值可能隔着其他值再次出现，就需要一个跨越整个切片生命周期的集合。保序去重不能先排序再去重，因为排序会改变输入顺序。

用 comparable 约束一个通用函数

元素要进入 map 的键位置，就必须支持等值比较。comparable 正好表达这个要求；类型参数 T 不需要为每种具体类型各写一个函数。

package main

import "fmt"

// Unique 保留每个元素第一次出现的位置，并返回新的结果切片。
func Unique[T comparable](items []T) []T {
	seen := make(map[T]struct{}, len(items)) // 用空结构体表示“已见过”，不额外存值。
	result := make([]T, 0, len(items))       // 预留上限容量，避免频繁扩容。

	for _, item := range items {
		if _, exists := seen[item]; exists {
			continue // 重复值不再追加，因此结果顺序保持不变。
		}
		seen[item] = struct{}{}
		result = append(result, item)
	}
	return result // 输入不会被改写，调用方只接收新的切片描述符。
}

func main() {
	words := []string{"go", "rust", "go", "java", "rust"}
	unique := Unique(words)
	fmt.Println(unique)
}

这个实现的关键不是“把元素放进 map”本身，而是先判断、再记录、最后追加。这样 result 的追加顺序始终跟输入的第一次出现顺序一致。结果应为 [go rust java]；这是代码语义推导出的示例，不把它当成本文已经执行过的测试记录。

时间复杂度平均为 O(n)，额外空间为 O(n)。map 的容量按输入长度预留只是减少扩容机会，不代表最终结果一定占满该容量，也不代表任何输入规模下都能得到固定的性能收益。

结构体可比较时，泛型函数仍然能复用

结构体只有在所有字段都可比较时，才能满足 comparable。字符串、整数、布尔值和由这些字段组成的结构体通常可以直接使用；含有切片、map 或函数字段的结构体则不能作为这种函数的元素类型。

type User struct {
	ID   int
	Name string
}

func exampleUsers() []User {
	users := []User{
		{ID: 7, Name: "Lin"},
		{ID: 7, Name: "Lin"},
		{ID: 8, Name: "Mia"},
	}
	return Unique(users) // User 的字段都可比较，所以可以按整体值去重。
}

整体值去重和按业务身份去重不是同一个规则。上例把 ID 与 Name 一起纳入比较；如果同一个用户改了名字，业务可能仍希望只保留一个对象，这时应明确使用哪一个字段作为键。

元素不可比较时，用 key 函数保留顺序

切片本身不能用 == 比较，因此不能直接令 T 为 []byte 或 []string 并把它放进 map。更灵活的做法是让调用方提供一个返回可比较键的函数：输入元素仍按原顺序遍历，集合只记录键。

// UniqueBy 按 key 提取的稳定标识去重，同时保留第一次出现的元素。
func UniqueBy[E any, K comparable](items []E, key func(E) K) []E {
	seen := make(map[K]struct{}, len(items)) // 只要求键可比较，元素本身可以是切片。
	result := make([]E, 0, len(items))

	for _, item := range items {
		id := key(item)
		if _, exists := seen[id]; exists {
			continue // 同一键只保留第一次出现的完整元素。
		}
		seen[id] = struct{}{}
		result = append(result, item)
	}
	return result
}

例如字节切片可以用内容转成字符串作为键，或者业务对象可以提取数据库主键。键函数必须稳定、可解释，并且要提前决定空值和大小写是否等价；函数本身不会替你定义业务身份。

nil、空切片和输入副作用怎么处理

上面的实现会为空输入返回一个非 nil 的空结果，因为它主动创建了 make([]T, 0, 0)。如果你的 API 需要保留 nil 语义，可以在函数开头单独判断：

func UniqueKeepNil[T comparable](items []T) []T {
	if items == nil {
		return nil // 调用方用 nil 表示“未提供”，这里保留这个约定。
	}
	return Unique(items)
}

去重函数没有改写输入切片的元素槽位，但返回结果里的元素仍可能是指针、切片或包含引用的对象。此时只是复制了元素值，不是深复制对象；如果下游会修改对象内部数据，仍要单独约定所有权和并发访问方式。

把实现放进项目时，记住这份边界

• 需要保留第一次出现顺序时，不要先排序，也不要把相邻去重当成全局去重。
• 元素整体可比较时使用 Unique[T comparable]；不可比较时提取业务键并使用 UniqueBy。
• 键函数要明确大小写、空值、规范化和冲突规则，不能把字符串转换当成天然正确的身份定义。
• 结果是否需要保持 nil，应该由 API 约定决定；不要靠打印结果区分 nil 与非 nil 空切片。
• 泛型减少重复实现，但不替代对“什么算相同”的业务定义。

两个常见疑问

为什么不用 map 直接返回结果？ map 只适合记录是否出现过，遍历 map 得到的顺序不应当当作输入顺序。结果切片必须在原输入遍历过程中按第一次出现的位置追加。

能否直接用标准库的 slices.Compact？ 只有在重复元素已经相邻、且任务确实是合并连续段时才适合。分散重复值需要本文的 seen 集合；两者的输入语义不同。

归纳起来，保序切片去重可以收敛成一个小而明确的泛型契约：元素或业务键必须可比较，集合负责记忆已见值，结果负责保存第一次出现的顺序。先把“相同”的定义说清楚，再选择整体比较还是 key 函数，代码就不会在类型复用和业务语义之间互相牺牲。