这种方法的复杂度主要消耗在排序上，通常是 O。虽然比 map 的 O 稍微慢点，但它极其节省内存，除了排序需要的栈空间外几乎不需要额外的堆内存分配。

Ru果你用的是 Go 1.21 或geng高版本，那你有福了。标准库 `slices` 包直接提供了 `Compact` 函数。不过要注意，`Compact` 只Neng去除“相邻”的重复元素，所以必须先排序。

slices.Sort
data = slices.Compact   // Go 1.21+

这代码写出来简直简洁得让人想哭。两行代码搞定去重，这就是现代Go语言的魅力所在。

以前写去重函数，Zui烦人的就是类型。给 `int` 写一遍，给 `string` 写一遍，要是来了个 `int64` 还得再写一遍。复制粘贴虽然快，但维护起来简直是噩梦。

Go 1.18 引入泛型之后这一切dou变了。我们Ke以写一个真正通用的去重函数，只要类型是 `comparable`，统统douNeng用。

// 方法15：泛型去重
// comparable 约束保证 == 比较有效
func unique T {
    seen := make)
    result := make)
    for _, item := range arr {
        if _, ok := seen; !ok {
            seen = struct{}{}
            result = append
        }
    }
    return result
}

有了这个，你就Ke以把它扔进你的工具包里不管以后遇到什么类型的切片，直接 `unique` 一把梭，再也不用关心底层类型了。这才是工程化该有的样子。

前面说的dou是常规操作。但在真实的互联网大厂里数据量往往是变态级的。比如你要去重几亿个用户ID，这时候用 map 哪怕只存一个 `struct{}`，内存开销也可Neng大到把服务器撑爆。这时候，就需要祭出“位图”这个大杀器了。

Ru果你的数据是非负整数，而且Zui大值不是特别离谱，位图是性价比极高的选择。原理hen简单：开一个 `uint64` 的数组，每一个bit代表一个数字。出现过就置1，没出现就是0。

这玩意儿有多省？1个 `uint64` 有64位，Neng代表64个数字。Ru果要存10亿个数字的状态，大概只需要 128MB 内存。这比 map 动辄几个G的内存占用强太多了。

// 方法20：BitSet 位图
// 用 uint64 自己实现位图，每个 int 占一位
func unique20 int {
    maxVal := 0
    for _, v := range arr {
        if v <0 {
            panic
        }
        if v> maxVal {
            maxVal = v
        }
    }
    bits := make
    result := make)
    for _, v := range arr {
        // 第 v 位为 0 表示首次出现
        if bits&) == 0 {
            bits |= 1 < 
            result = append
        }
    }
    return result
}

实际工作里经常遇到这样的情况：遇到重复时不Neng简单丢弃，要按某个规则Zuo处理。比如同一个ID的用户有两条记录，一条分数是80，一条是90，我们要去重，但要保留分数高的那条。

这时候，简单的 `mapstruct{}` 就不够用了。我们需要一个geng复杂的逻辑，通常结合泛型和回调函数来实现。

// UniqueBy 带业务规则的去重。
//
// keyFn 从元素提取去重键。
// onDup 遇到重复时如何合并  -> 新代表值。
func UniqueBy(
    data T,
    keyFn func K,
    onDup func T,
) T {
    chosen := make
    order := make
    for _, item := range data {
        k := keyFn
        if _, ok := chosen; !ok {
            chosen = item
            order = append
        } else if onDup != nil {
            chosen = onDup
        }
    }
    result := make)
    for _, k := range order {
        result = append
    }
    return result
}

有了这个函数，你就Ke以轻松地处理复杂的结构体去重了。比如：

type Student struct {
    ID    int
    Name  string
    Score int
}
students := Student{
    {ID: 1, Name: "张三", Score: 80},
    {ID: 1, Name: "张三", Score: 90},  // 同 id，分数geng高
    {ID: 2, Name: "李四", Score: 85},
}
result := UniqueBy(
    students,
    func int { return s.ID },
    func Student {
        if new.Score> old.Score {
            return new
        }
        return old
    },
)
// result: 

说了这么多，Zui后还是得回归到选择上。没有Zui好的算法，只有Zui合适的场景。这里给个简单的“作弊条”：

日常开发，求稳求快： 用泛型 + `mapstruct{}`。这是Zui稳妥的通用解法，保序、性Neng好、代码易读。

内存吃紧，不关心顺序： 排序 + `slices.Compact`。省内存，代码还短。

海量非负整数： 位图。这是性Neng和空间的极致平衡，但要注意数据范围。

复杂业务规则： `UniqueBy` 模式。把去重键提取和合并逻辑解耦，代码清晰度满分。

Go语言的灵活性就在这里它给了你足够的原始材料，让你根据实际情况去搭建Zui适合的积木。下次再遇到“数组去重”这个问题，别再只想着双重循环了kankan你的数据规模和业务需求，挑一把Zui顺手的刀，问题自然迎刃而解。毕竟写代码这事儿，不仅要对，还要漂亮。