我们换一种方式理解 Go 泛型。

不要一开始陷入constraint~interface这些概念。

先抓住一句话这方面，

普通变量

func add int {
return a + b
}

至于这里。

a 的类型 = int
b 的类型 = int

类型写死了。

泛型版本

func add T {
return a + b
}

T 是一个类型变量

调用时指定类型

add // 相当于 func add int
add // 相当于 func add float64

一份代码，生成多个版本。

一、先看一个没有泛型的痛点

假设我们写一个最大值函数。

int 版本

func MaxInt int {
if a>b { return a }
return b
}

从使用来看。

fmt.Println)

float 版本

func MaxFloat float64 {
if a>b { return a }
return b
}

string 版本

func MaxString string {
if a>b { return a }
return b
}

至于痛点，三份几乎完全相同的逻辑，却要复制粘贴三遍，维护成本翻倍；如果后面想支持更多类型，又得再写一次。

二、第一个泛型例子

func Max T {
if a>b { return a }
return b
}

再看痛点解决，只写一份即可适配多种基础类型。

int 调用示例

fmt.Println)
// 编译器等价为：
// func Max int { ... }
`Max` 在编译期被替换成对应的具体实现。**为什么要显式指定 ``？**
Go 是静态语言，编译器在编译阶段必须知道所有操作是否合法。若 `T any`，编译器无法判断比较是否支持，就会报错。go
// 错误示例：不能对任意类型做比较
func MaxT{
if a> b {return a} // compile error for non-comparable types
...
}
我们通过约束 `` 告诉编译器：仅支持可比较的基础数值和字符串。


理解 “T 是个未知类型” 


普通变量的观点是，`name := "张三"` 保存数据。

从泛型参数来看，`func Test` 保存的是类型信息而不是值。

调用时例如 `Test` → `T = int`；调用 `Test` → `T = string`。

这类似于 `x = y;` 的概念。只是这里 x 是“占位符”——一个未确定的类型名，而非运行时的数据。

从常见误区来看。“泛型就是变量”，它是 **“类型占位符”**，让同一段代码在不同具体化后生成不同实现。​​​​​​​​​​​​​


五、泛型最简单用途：写通用工具

判断数组是否包含某个元素
至于之前，go
// 整数版
func ContainsInt bool{
for _,v:=range arr{
if v==target{return true}
}
return false}
go
// 字符串版
重复且难以
go
func Contains bool{
for _。v:=range arr{
if v==target{return true}
}
return false}

用法
go
// 整数数组检查
Contains
// 字符串数组检查
Contains
痛点解决：一次定义，多种使用；避免了每种元素都复制粘贴一样逻辑。​​​