Go 泛型时代的新宠：标准库新增的泛型包全解析

# Go 泛型时代的新宠：标准库新增的泛型包全解析

自从 Go 1.18 正式引入泛型以来，Go 官方团队没有停下脚步，而是持续在后续版本中为标准库添加了一系列基于泛型的新包和方法。这些新特性让我们的代码更加简洁、类型安全，也减少了大量样板代码。

今天就来系统梳理一下这些新成员，包括它们的引入版本、基本用法，以及与老写法的对比。

## 一、`slices` 包（Go 1.21）

在 Go 1.21 之前，操作切片往往需要手写循环或依赖第三方库。现在，`slices` 包提供了一整套泛型函数。

### 主要函数

### 新老写法对比

**老写法（手动实现）：**

“`go
// 判断切片是否包含某元素
func containsInt(s []int, v int) bool {
for _, x := range s {
if x == v {
return true
}
}
return false
}

// 删除指定位置的元素
func deleteInt(s []int, i int) []int {
return append(s[:i], s[i+1:]…)
}
“`

**新写法（Go 1.21+）：**

“`go
import “slices”

// 一行搞定，且支持任意可比较类型
ok := slices.Contains([]int{1, 2, 3}, 2) // true
ok := slices.Contains([]string{“a”, “b”}, “a”) // true

// 安全删除，自动处理边界
s := []int{1, 2, 3, 4}
s = slices.Delete(s, 1, 2) // [1, 3, 4]
“`

**排序对比：**

“`go
// 老写法
import “sort”

ints := []int{3, 1, 2}
sort.Ints(ints) // 只能用于 int

// 新写法 – 泛型支持
import “slices”

slices.Sort([]int{3, 1, 2}) // int
slices.Sort([]float64{3.1, 1.2}) // float64
slices.Sort([]string{“c”, “a”}) // string

// 使用自定义比较器
type Person struct { Name string; Age int }
people := []Person{{“Alice”, 30}, {“Bob”, 25}}
slices.SortFunc(people, func(a, b Person) int {
return cmp.Compare(a.Age, b.Age)
})
“`

## 二、`maps` 包（Go 1.21）

与 `slices` 包同时引入，`maps` 包提供了 map 的常用操作函数。

### 主要函数

### 新老写法对比

**克隆 map：**

“`go
// 老写法 – 手动循环
func cloneMap[K comparable, V any](m map[K]V) map[K]V {
result := make(map[K]V, len(m))
for k, v := range m {
result[k] = v
}
return result
}

// 新写法 – 一行搞定
import “maps”

original := map[string]int{“a”: 1, “b”: 2}
cloned := maps.Clone(original)
“`

**删除满足条件的元素：**

“`go
m := map[int]string{1: “a”, 2: “bb”, 3: “ccc”}

// 老写法 – 循环中删除（需注意并发安全问题）
for k, v := range m {
if len(v) > 1 {
delete(m, k)
}
}

// 新写法 – 一行搞定
maps.DeleteFunc(m, func(k int, v string) bool {
return len(v) > 1
})
“`

## 三、`cmp` 包（Go 1.21）

`cmp` 包虽然小巧，但解决了泛型时代比较操作的痛点。

### 主要函数

“`go
// Ordered 约束：支持 < > <= >= 的类型
type Ordered interface {
~int | ~int8 | ~int16 | ~int32 | ~int64 |
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
~float32 | ~float64 |
~string
}

// Compare 返回 -1, 0, 1
func Compare[T Ordered](x, y T) int

// Less 返回 x < y func Less[T Ordered](x, y T) bool ``` ### 新老写法对比 ```go // 老写法 - 每种类型都要写一遍 func compareInt(a, b int) int { if a < b { return -1 } else if a > b {
return 1
}
return 0
}

// 新写法 – 泛型通用
import “cmp”

result := cmp.Compare(3, 5) // -1
result := cmp.Compare(3.14, 2.71) // 1
result := cmp.Compare(“abc”, “abd”) // -1
“`

**配合 slices.SortFunc 使用：**

“`go
type Student struct {
Name string
Score float64
}

students := []Student{
{“Alice”, 95.5},
{“Bob”, 87.0},
{“Charlie”, 92.3},
}

// 按分数降序
slices.SortFunc(students, func(a, b Student) int {
return cmp.Compare(b.Score, a.Score) // 注意 b 在前
})
“`

## 四、`iter` 包（Go 1.23）

Go 1.23 引入了革命性的迭代器特性，`iter` 包定义了迭代器的核心类型。

### 核心类型

“`go
// Pull 迭代器（简化版）
type Seq[V any] func(yield func(V) bool)

// Pull 迭代器（带 key）
type Seq2[K, V any] func(yield func(K, V) bool)
“`

### 迭代器的威力

Go 1.23 可以在 `for range` 中直接使用函数迭代器：

“`go
// 自定义迭代器
func Backward(s []int) iter.Seq[int] {
return func(yield func(int) bool) {
for i := len(s) – 1; i >= 0; i– {
if !yield(s[i]) {
return
}
}
}
}

// 使用迭代器
for v := range Backward([]int{1, 2, 3}) {
fmt.Println(v) // 3, 2, 1
}
“`

### slices/maps 包的迭代器增强（Go 1.23）

“`go
// 获取所有 key 作为迭代器
m := map[string]int{“a”: 1, “b”: 2}

for k := range maps.Keys(m) {
fmt.Println(k)
}

// 收集迭代器结果
keys := slices.Collect(maps.Keys(m)) // []string{“a”, “b”}
values := slices.Collect(maps.Values(m)) // []int{1, 2}

// 链式操作
allValues := slices.Collect(maps.Values(largeMap))
filtered := slices.Collect(slices.Values(allValues))
“`

## 五、`sync.OnceValue` / `sync.OnceFunc` / `sync.OnceValues`（Go 1.21）

`sync.Once` 是老朋友了，但每次使用都要写一堆样板代码。Go 1.21 新增的泛型版本让单例模式变得优雅。

### 新老写法对比

**老写法 – sync.Once：**

“`go
type Server struct {
dbOnce sync.Once
db *sql.DB
dbErr error
}

func (s *Server) DB() (*sql.DB, error) {
s.dbOnce.Do(func() {
s.db, s.dbErr = sql.Open(“sqlite3”, “file.db”)
})
return s.db, s.dbErr
}
“`

**新写法 – sync.OnceValue：**

“`go
type Server struct {
db func() *sql.DB
}

func NewServer() *Server {
return &Server{
db: sync.OnceValue(func() *sql.DB {
conn, _ := sql.Open(“sqlite3”, “file.db”)
return conn
}),
}
}

// 直接调用，自动保证只执行一次
s.db() // 返回 *sql.DB
“`

**三个函数的区别：**

“`go
// OnceFunc – 只执行一次
var initOnce = sync.OnceFunc(func() {
log.Println(“初始化完成”)
})

// OnceValue – 缓存单个返回值
var getConfig = sync.OnceValue(func() *Config {
return loadConfigFromFile()
})

// OnceValues – 返回值+错误
var readFile = sync.OnceValues(func() ([]byte, error) {
return os.ReadFile(“data.txt”)
})

// 使用
config := getConfig() // *Config
data, err := readFile() // ([]byte, error)
“`

## 六、其他值得关注的泛型特性

### `slices.Concat`（Go 1.22）

“`go
// 老写法
combined := append(append([]int{}, a…), b…)

// 新写法
combined := slices.Concat(a, b) // 支持任意多个切片
combined := slices.Concat(a, b, c, d)
“`

### `slices.Repeat`（Go 1.24）

“`go
// 创建包含重复元素的切片
s := slices.Repeat([]int{1, 2}, 3) // [1, 2, 1, 2, 1, 2]
“`

### `maps.Collect`（Go 1.24）

“`go
// 从迭代器创建 map
m := maps.Collect(iter.Seq2[K, V])
“`

## 总结表格

| 包/方法 | 版本 | 用途 |
|———|——|——|
| `slices` 包 | 1.21 | 切片泛型操作 |
| `maps` 包 | 1.21 | Map 泛型操作 |
| `cmp` 包 | 1.21 | 有序类型比较 |
| `sync.OnceFunc` | 1.21 | 单次执行（无返回） |
| `sync.OnceValue` | 1.21 | 单次执行（单返回值） |
| `sync.OnceValues` | 1.21 | 单次执行（双返回值） |
| `iter` 包 | 1.23 | 迭代器类型定义 |
| `for range` 函数 | 1.23 | 遍历函数迭代器 |
| `slices.Concat` | 1.22 | 拼接多个切片 |
| `maps.Keys` 迭代器 | 1.23 | 返回 key 迭代器 |
| `maps.Values` 迭代器 | 1.23 | 返回 value 迭代器 |

## 写在最后

泛型引入后，Go 标准库正在稳步”现代化”。这些新包和方法不仅减少了样板代码，还提高了类型安全性和代码可读性。

不过要注意：
1. **版本兼容性**：使用这些新特性前，确保项目支持的 Go 版本
2. **性能考量**：某些泛型函数可能有轻微性能开销，性能敏感场景需要 benchmark
3. **学习曲线**：迭代器（iter）是 Go 1.23 的新概念，需要时间适应

如果你还在用 Go 1.20 或更早版本，是时候考虑升级了。这些新特性真的能让你的代码更优雅！

—

**参考资料：**
– [Go 1.21 Release Notes](https://go.dev/doc/go1.21)
– [Go 1.22 Release Notes](https://go.dev/doc/go1.22)
– [Go 1.23 Release Notes](https://go.dev/doc/go1.23)
– [Go 1.24 Release Notes](https://go.dev/doc/go1.24)

2026 年 3 月
一	二	三	四	五	六	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31