编写泛型代码时,如果只是打印或保存数据,使用 any 约束就足够了。但如果想在 [T any] 的泛型函数内部直接使用 == 判断两个值是否相等,会发生什么呢?我们先来看下面这段代码:
func isEqual[T any](a, b T) bool {
return a == b // 编译报错
}编译这段代码时,程序会直接报错。为什么连最基本的 == 都不让使用呢?因为 any 代表任意类型,其中也包括切片和函数,而在 Go 语言中切片与函数是不能使用 == 直接比较相等的。
为了让编译器确定传入的类型一定支持 ==、> 或 + 等操作,我们需要在泛型函数或泛型类型中使用更具体的 “泛型约束(Type Constraints)” 来限制 T 的范围。常用的泛型约束如下表所示。
| 约束写法 | 支持操作 | 主要用途 |
|---|---|---|
| any | 无比较与算术运算 | 打印或保存任意数据 |
| comparable | ==、!= | 判断是否相等或作 Map 键 |
| ~int | ~float64 | +、-、*、/ 等运算 | 指定数值类型的算术计算 |
| cmp.Ordered | <、<=、>、>=、==、!= | 比较大小与排序 |
| 普通接口 | 接口规定的方法 | 调用传入类型的指定方法 |
内置 comparable 约束
在 Go 语言中,如果我们只需要使用 == 或 != 判断两个值是否相等,或者把类型形参当作 Map 的键,可以直接使用内置的 comparable 约束。
语法:
func 函数名[T comparable](参数列表) 返回值类型 {
// 函数体
}说明:
其中,comparable 在英文中是 “可比较的” 的意思。它是 Go 语言内置的标识符,不需要导入任何包就能直接使用。
它涵盖了所有支持 == 和 != 判断的数据类型,比如整数、浮点数、字符串、布尔值、指针、数组,以及内部字段全部可判等的结构体。至于切片、Map 和函数,由于本身不支持 == 判等,因此不能传给 comparable 约束。
示例 1:使用 comparable 查找下标
package main
import "fmt"
// 查找目标元素在切片中首次出现的下标
func findIndex[T comparable](s []T, target T) int {
for i, v := range s {
if v == target {
return i
}
}
return -1
}
func main() {
nums := []int{10, 20, 30, 40}
names := []string{"C", "Go", "Python"}
fmt.Println(findIndex(nums, 30))
fmt.Println(findIndex(names, "Go"))
fmt.Println(findIndex(names, "Rust"))
}运行结果如下。
2
1
-1分析:
findIndex() 函数需要通过 v == target 逐一比对切片元素与目标值是否相等。把类型约束写成 [T comparable] 后,函数体内部就可以正常使用 == 和 != 运算符。如果调用时传入了不支持判等的类型,编译阶段就会直接报错。
注意: 小伙伴们不要被 comparable 的字面意思误导了。它只支持用 == 和 != 判等,不支持用 > 或 < 比大小(如布尔值可判等却不能比大小)。需要比较大小时,应该使用后面介绍的 cmp.Ordered 约束。
自定义联合约束与 ~ 符号
当泛型函数需要执行加减乘除运算时,允许传入的数字类型通常有好几种(如 int、int64、float64)。如果每次都在函数名后面的方括号里写一长串 int | int64 | float64,代码就会显得很繁琐。
此时我们可以借助 interface 关键字,把多个允许的类型使用竖线(|)组合起来,封装成一个可复用的联合类型约束。
语法:
type 约束名 interface {
~类型1 | ~类型2 | ...
}说明:
在定义联合类型约束时,主要会用到以下 2 个符号:
- 竖线(|):表示 “联合类型”,也就是 “或者” 的意思,只要我们传入的类型属于竖线连接的任意一种类型即可。
- 波浪号(~):表示 “底层类型匹配”,写在基础类型前面(如
~int)。它不仅允许原生的int类型,还允许所有基于int定义出来的自定义类型。
下面我们先来看只使用竖线(|)的基础联合约束,再看加上波浪号(~)之后的效果。
示例 2:定义联合类型约束
package main
import "fmt"
// 定义数字类型约束
type Number interface {
int | int64 | float64
}
// 计算切片中所有数字的总和
func sumSlice[T Number](s []T) T {
var total T
for _, v := range s {
total += v
}
return total
}
func main() {
intSlice := []int{10, 20, 30}
floatSlice := []float64{1.5, 2.5, 3.5}
fmt.Println(sumSlice(intSlice))
fmt.Println(sumSlice(floatSlice))
}运行结果如下。
60
7.5分析:
type Number interface 将 int、int64 和 float64 组合在了一起,多个泛型函数都可以直接写 [T Number] 来复用这个约束。
在 sumSlice() 函数内部,var total T 声明了一个类型为 T 的变量,Go 会自动将其初始化为对应类型的零值。当 T 为 int 时初始值是 0,当 T 为 float64 时初始值是 0.0,随后通过循环就能把每个元素累加到 total 中。
不过,上面定义的 Number 约束还有一个小局限。前面我们学过,通过 type MyInt int 定义出来的自定义类型 MyInt 是一个全新的独立类型。如果我们把 MyInt 变量传给只写了 int 的约束,编译器会拒绝通过,这时就需要加上波浪号(~)了。
示例 3:使用 ~ 匹配底层类型
package main
import "fmt"
// 基于 int 定义自定义类型
type MyInt int
// 加上 ~ 表示底层是 int 或 int64 的类型都允许
type IntLike interface {
~int | ~int64
}
func doubleVal[T IntLike](n T) T {
return n * 2
}
func main() {
a := 15
b := MyInt(25)
fmt.Println(doubleVal(a))
fmt.Println(doubleVal(b))
}运行结果如下。
30
50分析:
~int 表示只要底层类型是 int,不管是原生的 int 还是自定义的 MyInt 都符合约束要求。两者的匹配范围区别如下图所示。

对于这个例子来说,如果我们去掉波浪号只写 int | int64,调用 doubleVal(b) 时就会直接报错。编译器会提示 “MyInt does not satisfy IntLike”,意思是 MyInt 不满足该约束。
此外小伙伴们还要特别注意,像 Number、IntLike 这种内部包含类型列表的接口,只能写在泛型方括号里充当类型约束。下面这种直接拿它声明普通变量的写法就是错误的。
var x IntLike = 10 // 编译报错如果我们直接写 var x IntLike = 10,编译时会报错 “interface contains type constraints”,提示该接口包含类型约束,不能用来声明普通变量。
提示: 波浪号(~)位于键盘左上角 Esc 键的正下方,在英文输入法下按住 Shift 键再按反引号键即可打出。另外要注意,~ 后面只能紧跟基础底层类型(如 ~int、~string),如果后面跟自定义类型写成 ~MyInt,编译时就会直接报错。
标准库 cmp.Ordered 约束
在实际开发中,我们经常需要通过 <、<=、>、>= 运算符来编写比较大小或排序的泛型函数。如果每次都要手动把十几种整数、浮点数和字符串类型写进接口里,写起来会很繁琐。
从 Go 1.21 开始,官方标准库提供了 "cmp" 包,里面内置了现成的 cmp.Ordered 约束。其中,cmp 是英文 “compare(比较)” 的缩写。
语法:
import "cmp"
func 函数名[T cmp.Ordered](参数列表) 返回值类型 {
// 函数体
}说明:
cmp.Ordered 表示 “可按顺序比较大小的类型”。它的内部已经通过 ~ 符号,把所有整数类型、浮点数类型和字符串类型全部组合好了。凡是需要比较大小的泛型函数,我们直接导入 "cmp" 包并使用 cmp.Ordered 就可以了。
示例 4:比较两个值的大小
package main
import (
"cmp"
"fmt"
)
// 返回两个值中较大的那一个
func getMax[T cmp.Ordered](a, b T) T {
if a > b {
return a
}
return b
}
func main() {
fmt.Println(getMax(10, 20))
fmt.Println(getMax(3.14, 6.28))
fmt.Println(getMax("apple", "banana"))
}运行结果如下。
20
6.28
banana分析:
在这个例子中,getMax() 函数使用了标准库的 cmp.Ordered 约束,因此在函数体内部可以直接使用 a > b 比较大小。无论是传入整数还是小数,这一个函数都能正常返回较大值。
至于第 3 次调用传入的 "apple" 和 "banana",字符串会按照字母先后顺序(字典序)逐位比较。因为首字母 'b' 排在 'a' 后面,所以结果为 "banana"。
使用普通接口作为约束
看到自定义联合约束也使用 interface 关键字时,为什么语法长得这么像上一章学过的接口呢?那普通的接口能不能也直接放进方括号里充当泛型约束?
答案是完全可以。当我们把只包含方法的普通接口(如 Describer)写进 [T Describer] 时,就表示传入的类型 T 必须实现该接口规定的全部方法,并且在泛型函数内部可以直接调用这些方法。
示例 5:使用普通接口作为约束
package main
import "fmt"
type Describer interface {
Info() string
}
type Book struct {
Title string
}
func (b Book) Info() string {
return "图书:《" + b.Title + "》"
}
type Phone struct {
Brand string
}
func (p Phone) Info() string {
return "手机:" + p.Brand
}
// 限定元素类型 T 必须实现 Describer 接口
func printAll[T Describer](items []T) {
for _, item := range items {
fmt.Println(item.Info())
}
}
func main() {
books := []Book{{Title: "Go 语言入门"}, {Title: "数据结构"}}
phones := []Phone{{Brand: "华为"}}
printAll(books)
printAll(phones)
}运行结果如下。
图书:《Go 语言入门》
图书:《数据结构》
手机:华为分析:
printAll[T Describer](items []T) 限定了切片元素 T 必须实现 Describer 接口,因此在循环内部可以直接调用 item.Info() 方法。
相比直接把普通接口当成函数参数,使用泛型接口约束主要有两个明显优势。一是可以直接接收 []Book 或 []Phone 这类具体结构体切片。如果参数写成普通接口切片 []Describer,编译器不允许直接传入 []Book,我们还得手动逐个转换元素。
二是当函数需要把传入的对象原样返回时,泛型返回值(如直接返回 T)能保留原本的具体类型。传入 Book 就会直接返回 Book,不用像普通接口那样拿到 Describer 后再做一次类型断言。
在实际开发中,小伙伴们可以按一个简单的标准来选:如果只是接收单个接口参数,或者需要在一个切片里混合存放多种不同的结构体,直接使用普通接口最简单。如果要处理同一种具体结构体组成的切片,或者希望返回值保留原始具体类型,使用泛型接口约束会更合适。
普通接口与纯约束接口的区别
从 Go 1.18 开始,interface 接口根据内部定义的内容可以分为以下 2 类:
- 普通接口(仅包含方法):比如
Describer、Reader,它们既可以用来声明普通的接口变量,也可以写进[T Describer]中充当泛型约束。 - 纯约束接口(包含类型列表):比如带
|或~的Number、IntLike以及标准库的cmp.Ordered,它们只能写在泛型方括号里限制类型范围,不能用来声明普通变量。
