Go 泛型切片去重实战：comparable 约束和保序去重怎么写

切片去重是 Go 项目里很常见的小需求：接口参数里用户 ID 重复了、批量查询时订单号重复了、聚合结果里同一个标签出现了多次。如果每个地方都临时写一段循环，代码会越来越散。

Go 1.18 之后有了泛型，我们可以把这类逻辑整理成小而清楚的工具函数。本文从最基础的 []T 保序去重开始，再扩展到结构体按字段去重，重点讲清楚 comparable 约束和 seen map 的用法。

摘要

切片去重通常有两个关键问题：第一，如何判断元素是否重复；第二，是否保留原始顺序。对于 int、string 这类可比较类型，可以用 map[T]struct{} 记录是否出现过；对于结构体列表，可以用 UniqueBy 提取某个字段作为去重键。

适合人群

适合已经会写 Go 基础语法，想把项目里的工具函数写得更通用、更好测试的开发者。你只需要了解切片、map、函数和一点泛型语法即可。

目录

• 为什么去重还要强调“保序”
• 用 comparable 写通用 Unique
• 结构体按字段去重：UniqueBy
• 单元测试和边界场景
• 常见坑和总结

一、为什么去重还要强调“保序”

很多业务场景里，去重不是简单地“剩下唯一值”就行，还要保留第一次出现的顺序。例如用户在页面选择了 [3, 1, 2, 3, 2, 4]，后端去重后更希望得到 [3, 1, 2, 4]，而不是被 map 打乱成别的顺序。

上图就是保序去重的核心：从左到右遍历原始切片；如果当前值第一次出现，就追加到结果里；如果已经出现过，就跳过。这样结果天然保留了第一次出现的顺序。

二、用 comparable 写通用 Unique

先实现一个最常用版本：元素本身可以作为 map key，比如 int、string、uint64。

package sliceutil

func Unique[T comparable](items []T) []T {
    if len(items) == 0 {
        return nil
    }

    seen := make(map[T]struct{}, len(items))
    result := make([]T, 0, len(items))

    for _, item := range items {
        if _, ok := seen[item]; ok {
            continue
        }

        seen[item] = struct{}{}
        result = append(result, item)
    }

    return result
}

这里的 T comparable 是关键。它表示类型 T 可以用 ==、!= 比较，也可以作为 map 的 key。像 int、string 可以；像 []int、map[string]int 不可以。

调用示例

package main

import (
    "fmt"

    "example.com/project/sliceutil"
)

func main() {
    ids := []int{3, 1, 2, 3, 2, 4, 1}
    names := []string{"go", "mysql", "go", "redis"}

    fmt.Println(sliceutil.Unique(ids))
    fmt.Println(sliceutil.Unique(names))
}

输出结果：

[3 1 2 4]
[go mysql redis]

这个函数适合处理基础类型切片，代码短、分配次数可控，也不会改变原始切片。

三、结构体按字段去重：UniqueBy

真实项目里经常不是对基础类型去重，而是对结构体列表按某个字段去重。比如用户列表按邮箱去重，订单列表按订单号去重，商品列表按 SKU 去重。此时整个结构体未必适合作为 map key，更稳的方式是提取一个 key。

这张图对应 UniqueBy 的思路：遍历结构体列表，通过函数提取去重字段，把字段值记入 seen，重复字段只保留第一次出现的那条记录。

package sliceutil

func UniqueBy[T any, K comparable](items []T, keyFunc func(T) K) []T {
    if len(items) == 0 {
        return nil
    }

    seen := make(map[K]struct{}, len(items))
    result := make([]T, 0, len(items))

    for _, item := range items {
        key := keyFunc(item)
        if _, ok := seen[key]; ok {
            continue
        }

        seen[key] = struct{}{}
        result = append(result, item)
    }

    return result
}

T any 表示列表元素可以是任意类型，K comparable 表示提取出来的 key 必须能作为 map key。这样既能处理结构体，又能保证去重判断足够简单。

按邮箱去重示例

package main

import (
    "fmt"

    "example.com/project/sliceutil"
)

type User struct {
    ID    int
    Email string
    Name  string
}

func main() {
    users := []User{
        {ID: 1, Email: "a@example.com", Name: "Alice"},
        {ID: 2, Email: "b@example.com", Name: "Bob"},
        {ID: 3, Email: "a@example.com", Name: "Alice Copy"},
    }

    result := sliceutil.UniqueBy(users, func(u User) string {
        return u.Email
    })

    fmt.Println(result)
}

结果会保留邮箱第一次出现的记录：

[{1 a@example.com Alice} {2 b@example.com Bob}]

如果业务规则是“保留最后一条”，那就不是这个函数的语义了。工具函数最好语义单一，名字和注释都说明“保留首次出现”。

四、单元测试和边界场景

工具函数越通用，越应该有测试。切片去重至少要覆盖空切片、无重复、全部重复、部分重复、顺序保持这几类情况。

package sliceutil

import (
    "reflect"
    "testing"
)

func TestUniqueKeepOrder(t *testing.T) {
    input := []int{3, 1, 2, 3, 2, 4, 1}
    want := []int{3, 1, 2, 4}

    got := Unique(input)

    if !reflect.DeepEqual(got, want) {
        t.Fatalf("got %v, want %v", got, want)
    }
}

func TestUniqueByKeepFirst(t *testing.T) {
    type User struct {
        ID    int
        Email string
    }

    input := []User{
        {ID: 1, Email: "a@example.com"},
        {ID: 2, Email: "b@example.com"},
        {ID: 3, Email: "a@example.com"},
    }

    got := UniqueBy(input, func(u User) string {
        return u.Email
    })

    if len(got) != 2 || got[0].ID != 1 || got[1].ID != 2 {
        t.Fatalf("unexpected result: %#v", got)
    }
}

如果你的项目更在意空切片返回空切片而不是 nil，可以把开头改成 return []T{}。两种都能用，关键是团队内部保持一致。

五、常见坑

1. map 去重会不会打乱顺序？

如果你直接遍历 map 输出结果，顺序是不稳定的。本文的写法只用 map 判断是否出现过，真正的输出仍然按原切片遍历顺序 append，所以顺序是稳定的。

2. 为什么不能对 []int 这种元素直接用 Unique？

因为 []int 本身不能比较，不能作为 map key。如果你要对二维切片去重，需要先把每个元素转换成可比较的 key，比如拼接成字符串，或者定义稳定的编码方式。

3. keyFunc 里要不要处理空字段？

要看业务含义。如果空邮箱代表未知用户，那么多个空邮箱是否算重复，需要业务先定规则。工具函数只负责按 key 去重，不应该偷偷改变业务语义。

上线前检查清单

• 函数名是否说明“保留首次出现”。
• 是否明确了空切片返回 nil 还是空切片。
• UniqueBy 的 key 是否真的代表业务唯一性。
• 是否有覆盖顺序保持、全部重复、无重复的测试。
• 调用方是否需要保留最后一条，如果需要就另写一个函数。

总结

Go 泛型让切片去重这类工具函数更自然。基础类型用 Unique[T comparable]，结构体列表用 UniqueBy[T any, K comparable]，核心都是一个 seen map 和一次从左到右的遍历。把“是否重复”和“保留顺序”这两个点讲清楚，函数就容易复用，也容易测试。