泛型的作用
有关 go 泛型的提案和具体使用：
https://github.com/polaris1119/go_dynamic_docs/blob/master/go2draft-contracts.md
- 泛型生命周期只在编译期，旨在为程序员生成代码，减少重复代码的编写
- 类型在编译之前就会限制，提前知道错误
重复代码的问题
例：在比较两个数的大小时，没有泛型的时候，仅仅只是传入类型不一样，我们就要再写一份一模一样的函数，如果有了泛型就可以减少这类代码
// int
func GetMaxNumInt(a, b int) int {
if a > b {
return a
}
return b
}
// int8
func GetMaxNumInt8(a, b int8) int8 {
if a > b {
return a
}
return b
}
类型断言和类型约束的问题
参考：https://www.qb5200.com/article/489894.html
假设我们想实现一个简单的tree数据结构。每个节点持有一个值。在 Go 1.18 之前，实现这种结构的典型方法如下。
type Node struct {
value interface{}
}
这在大多数情况下都很好用，但它也有一些缺点。
首先，interface{}可以是任何东西。如果我们想限制value可能持有的类型，例如整数和浮点数，我们只能在运行时检查这个限制。
func (n Node) IsValid() bool {
switch n.value.(type) {
case int, float32, float64:
return true
default:
return false
}
}
这样并不可能在编译时限制类型，像上面这样的类型判断在许多 Go 库中都是很常见的做法。这里有 go-zero 项目中的例子。
第二，对 Node 中的值进行处理是非常繁琐和容易出错的。对值做任何事情都会涉及到某种类型的断言，即使你可以安全地假设值持有一个int值。
number, ok := node.value.(int)
if !ok {
// ...
}
double := number * 2
这些只是使用interface{}的一些不便之处，它没有提供类型安全，并有可能导致难以恢复的运行时错误。
泛型的简单使用
泛型示例
- 需要go版本大于等于1.18
- 我们先改造一下上面的示例，只需要在函数后用
中括号声明T可能出现的类型，中间用符号"|"分隔
// 使用泛型
func GetMaxNum[T int | int8](a, b T) T {
if a > b {
return a
}
return b
}
自定义泛型类型
- 如果类型太多了怎么办呢？这时候我们就可以自定义泛型类型
// 像声明接口一样声明
type MyInt interface {
int | int8 | int16 | int32 | int64
}
// T的类型为声明的MyInt
func GetMaxNum[T MyInt](a, b T) T {
if a > b {
return a
}
return b
}
调用带泛型的函数
- 如何调用这个带有泛型的函数呢？
var a int = 10
var b int = 20
// 方法1，正常调用，编译器会自动推断出传入类型是int
GetMaxNum(a, b)
// 方法2，显式告诉函数传入的类型是int
GetMaxNum[int](a, b)
自定义泛型类型的语法
在上面我们可以看到一个泛型的简单自定义类型，本节将会详细描述泛型自定义类型的语法
内置的泛型类型any和comparable
- any: 表示go里面所有的内置基本类型，等价于
interface{}
- comparable: 表示go里面所有内置的可比较类型：
int、uint、float、bool、struct、指针等一切可以比较的类型
声明一个自定义类型
- 跟声明接口一样，使用
type x interface{}关键字来声明，不过里面的成员不再是方法，而是类型，类型之间用符号"|"隔开
type MyInt interface {
int | int8 | int16 | int32 | int64
}
- 成员类型支持go中所有的基本类型
type MyT interface {
int | float32 | bool | chan int | map[int]int | [10]int | []int | struct{} | *http.Client
}
泛型中的"~"符号是什么
- 符号
"~"都是与类型一起出现的，用来表示支持该类型的衍生类型
// int8的衍生类型
type int8A int8
type int8B = int8
// 不仅支持int8, 还支持int8的衍生类型int8A和int8B
type MyInt interface {
~int8
}
泛型的进阶使用
泛型与结构体
- 创建一个带有泛型的结构体
User，提供两个获取age和name的方法 注意：只有在结构体上声明了泛型，结构体方法中才可以使用泛型
type AgeT interface {
int8 | int16
}
type NameE interface {
string
}
type User[T AgeT, E NameE] struct {
age T
name E
}
// 获取age
func (u *User[T, E]) GetAge() T {
return u.age
}
// 获取name
func (u *User[T, E]) GetName() E {
return u.name
}
- 我们可以通过声明结构体对象时，声明泛型的类型来使用带有泛型的结构体
// 声明要使用的泛型的类型
var u User[int8, string]
// 赋值
u.age = 18
u.name = "weiwei"
// 调用方法
age := u.GetAge()
name := u.GetName()
// 输出结果 18 weiwei
fmt.Println(age, name)
泛型的限制或缺陷
无法直接和switch配合使用
- 将泛型和
switch配合使用时，无法通过编译
func Get[T any]() T {
var t T
switch T {
case int:
t = 18
}
return t
}
- 只能先将泛型赋值给
interface才可以和switch配合使用
func Get[T any]() T {
var t T
var ti interface{} = &t
switch v := ti.(type) {
case *int:
*v = 18
}
return t
}
泛型的详细参考
https://www.cnblogs.com/makalochen/p/17094821.html
标签：return,int,简单,泛型,类型,GO,interface,int8 From： https://www.cnblogs.com/makalochen/p/17094828.html