Golang 1.18新特性泛型
一 什么是泛型
泛型的英文是Generics，就是函数的参数，或者容器元素的类型，支持更广泛的类型，不再是特定的类型。
在Golang、Java、C++等这类静态语言中，是需要严格定义传入变量的类型的，斌不是随心所欲，例如在golang中：
func Sum(a, b int) int {
return a + b
}
在函数Sum中，不仅要严格定义传入参数a和b的变量类型，而且返回值的类型也需要严格定义，所有你只能传入int类型进行调用：
Sum(1, 2) // 3
如果传入其它类型的变量就会报错：
fmt.Println(Sum(1.23, 2.54));
./main.go:33:18: cannot use 1.23 (untyped float constant) as int value in argument to Sum (truncated)
./main.go:33:24: cannot use 2.54 (untyped float constant) as int value in argument to Sum (truncated)
因此，如果当golang开发者想开发类似实现两个float类型变量相加的功能，只能另写一个函数：
func SumFloat(a, b float) float {
return a + b
}
或者写一个通用的Sum函数使用interface反射来判断：
func Sum(a, b interface{}) interface{} {
switch a.(type) {
case int:
a1 := a.(int)
b1 := b.(int)
return a1 + b1
case float64:
a1 := a.(float64)
b1 := b.(float64)
return a1 + b1
default:
return nil
}
}
这样的话，不仅重复很多代码，而且类型频繁转换导致不仅性能低效，安全性上也不高。
所以泛型诞生了。
然而泛型是一把双刃剑，在给开发者带来便利的同时，同样会带来编译和效率的问题，因为泛型需要系统去推倒和计算变量的类型的，这在无形中会增加编译的时间和降低运行效率。
二 Golang中的泛型
首先来看一下，在Golang 1.18版本中是如何利用泛型来实现Sum函数的
func Sum[T int|float64](a,b T) T {
return a + b
}
然后再调用一下：
fmt.Println(Sum[int](1, 2)) //3
fmt.Println(Sum[float64](1.23, 2.54)) //3.77
先不去理解函数中各组件的含义，仅仅看代码就简洁了不少，乙肝函数就实现了多个类型的功能。
因为泛型针对的是类型变量，在golang中，类型是贯穿整个语法生态的，比如：变量、函数、接口、通道等。
三 泛型语法详解
3.1 泛型的语法
MyType[T1 constraint1 | constraint2, T2 constraint3...] ...
泛型的语法非常简单, 就类似于上面这样, 其中:
MyTypeT1T2constraintconstraint|constraintTT1constraint1constraint23.2 Constraint(约束)是什么
T而常用的范围, 我们自然会想到的有:
anyinterface{}IntergerintFloatcomparable这些约束, 不是被官方定义为内置类型, 就是被涵盖在了constraints包内!!!
下面是builtin.go的部分官方源码:
// any is an alias for interface{} and is equivalent to interface{} in all ways.
type any = interface{}
// comparable is an interface that is implemented by all comparable types
// (booleans, numbers, strings, pointers, channels, interfaces,
// arrays of comparable types, structs whose fields are all comparable types).
// The comparable interface may only be used as a type parameter constraint,
// not as the type of a variable.
type comparable comparable
下面是constraints.go的部分官方源码:
// Integer is a constraint that permits any integer type.
// If future releases of Go add new predeclared integer types,
// this constraint will be modified to include them.
type Integer interface {
Signed | Unsigned
}
// Float is a constraint that permits any floating-point type.
// If future releases of Go add new predeclared floating-point types,
// this constraint will be modified to include them.
type Float interface {
~float32 | ~float64
}
//......
3.3 自定义constraint(约束)
下面是constraints包中的官方源码:
type Signed interface {
~int | ~int8 | ~int16 | ~int32 | ~int64
}
Signed约束就是这样被写出来的, 其中需要我们掌握的点有如下几个:
interface{}|intint8int64~int~inttype MyInt int64int64int64~int64~int64int64~例如：
type My_constraint_Num interface {
~int64 | ~float64
}
四 泛型综合使用案例
4.1 泛型切片
package main
import "fmt"
type Vector[T any] []T
type NumSlice[T int | float64] []T
func main() {
v := Vector[string]{"a", "b", "c"}
fmt.Printf("v: %v\n", v)
ns := NumSlice[int]{1, 2, 3, 4, 5}
fmt.Printf("ns: %v\n", ns)
ns2 := NumSlice[float64]{1.1, 2.2, 3.3, 4.4, 5.5}
fmt.Printf("ns2: %v\n", ns2)
}
运行结果：
[Running] go run "e:\golang开发学习\go_pro\main.go"
v: [a b c]
ns: [1 2 3 4 5]
ns2: [1.1 2.2 3.3 4.4 5.5]
[Done] exited with code=0 in 0.983 seconds
4.2 泛型map
package main
import (
"fmt"
"golang.org/x/exp/constraints"
)
// map的key必须要可以比较, 也就是可以被 == 和 != 比较(用于处理哈希冲突)
type MyMap[K comparable, V constraints.Integer | constraints.Float] map[K]V
func main() {
m := make(MyMap[string, int])
m["表哥"] = 100
m["小张"] = 0
for k, v := range m {
fmt.Printf("key: %v, val: %v\n", k, v)
}
}
运行结果：
[Running] go run "e:\golang开发学习\go_pro\main.go"
key: 表哥, val: 100
key: 小张, val: 0
[Done] exited with code=0 in 1.432 seconds
4.3 泛型结构体
这里以一个手写链表(只能存储整数)做示范
package main
import (
"fmt"
"golang.org/x/exp/constraints"
)
type MyIntergerNode[T constraints.Integer] struct {
Next *MyIntergerNode[T] //注意这里一定要加类型声明
Data T
}
func main() {
head := &MyIntergerNode[int64]{Next: nil, Data: 1}
head.Next = &MyIntergerNode[int64]{Next: nil, Data: 2}
for p := head; p != nil; p = p.Next {
fmt.Printf("%d ", p.Data)
}
}
运行结果：
[Running] go run "e:\golang开发学习\go_pro\main.go"
1 2
[Done] exited with code=0 in 1.15 seconds
4.4 泛型通道
package main
import "fmt"
type Ch[T any] chan T
func main() {
ch := make(Ch[int], 1)
ch <- 10
res := <-ch
fmt.Printf("res: %v\n", res)
fmt.Printf("ch: %v\n", ch)
}
运行结果：
[Running] go run "e:\golang开发学习\go_pro\main.go"
res: 10
ch: 0xc0000180e0
[Done] exited with code=0 in 1.237 seconds
4.5 泛型函数
这里自定义一个比较64比特大小的类型的函数
package main
import (
"fmt"
)
// 自定义约束
type My_64_Bits_Long_Num interface {
~int64 | ~float64
}
func MyCompare[T My_64_Bits_Long_Num](a, b T) bool {
return a < b
}
func main() {
var a int64 = 1
var b int64 = 8
// 函数可以省略不写参数类型
ans := MyCompare(a, b)
if ans {
fmt.Printf("%v小于%v", a, b)
} else {
fmt.Printf("%v大于%v", a, b)
}
}
运行结果：
[Running] go run "e:\golang开发学习\go_pro\main.go"
1小于8
[Done] exited with code=0 in 1.18 seconds
a := 3 // 编译器自动推导 a 是int型变量
b := "hello" // 编译器自动推导 b 是string型变量
ans := MyCompare(a, b) // 自动推导出 T 是 int
4.6 泛型变量嵌套
就像声明变量类型支持嵌套一样，泛型变量也支持嵌套。
例如下面定义了两个泛型变量，一个是S，另一个是嵌套了S的map泛型变量P
type MyStruct[S int | string, P map[S]string] struct {
Name string
Content S
Job P
}
接下来是如何去实例化：
//实例化int的实参
var MyStruct1 = MyStruct[int, map[int]string]{
Name: "small",
Content: 1,
Job: map[int]string{1: "ss"},
}
fmt.Printf("%+v", MyStruct1) // {Name:small Content:1 Job:map[1:ss]}
//实例化string的实参
var MyStruct2 = MyStruct[string, map[string]string]{
Name: "small",
Content: "yang",
Job: map[string]string{"aa": "ss"},
}
fmt.Printf("%+v", MyStruct2) //{Name:small Content:yang Job:map[aa:ss]}
注意：T和S要保持实参的一致
再来看一个稍微复杂的例子，两个泛型变量之间的嵌套使用，Struct1这个结构体切片，它第二个泛型参数的类型是Slice1：
//切片泛型
type Slice1[T int | string] []T
//结构体泛型，它的第二个泛型参数的类型是第一个切片泛型。
type Struct1[P int | string, V Slice1[P]] struct {
Name P
Title V
}
这种情况下，该如何去实例化？请始终记住：在泛型里面，如果要实例化一个泛型变量，需要用实际传入的变量类型去替换T
//实例化切片
mySlice1 := Slice1[int]{1, 2, 3}
//用int去替换P, 用Slice1去替换Slice1[p]
myStruct1 := Struct1[int, Slice1[int]]{
Name: 123,
Title: []int{1, 2, 3},
}
//用string去替换P, 用Slice1去替换Slice1[p]
myStruct2 := Struct1[string, Slice1[string]]{
Name: "hello",
Title: []string{"hello", "small", "yang"},
}
fmt.Println(mySlice1, myStruct1, myStruct2) //[1 2 3] {123 [1 2 3]} {hello [hello small yang]}
最后再看另一中嵌套方式：
type Slice1[T int|float64|string] []T
type Slice2[T int|string] Slice1[T]
如何去实例化呢？
mySlice1 := Slice1[int]{1, 2, 3, 4}
mySlice2 := Slice2[string]{"hello", "small"}
fmt.Println(mySlice1, mySlice2) //[1 2 3 4] [hello small]
发现：Slice2其实就是继承和实现了Slice1，也就是说Slice2的类型参数约束的取值范围必须是在Slice1的取值范围里，下面尝试改一下：
type Slice1[T int|float64|string] []T
type Slice2[T bool|int|string] Slice1[T]
mySlice1 := Slice1[int]{1, 2, 3, 4}
mySlice2 := Slice2[bool]{true, false}
运行则会报错：
T does not implement int|float64|string
因此可以尝试更加复杂的嵌套写法：
type Slice1[T bool | float64 | string | int] []T
type Slice2[T bool | float64 | string] Slice1[T]
type Slice3[T bool | int] Slice2[T]
注意一眼就能看出，Slice3的曲子范围并不是在Slice2的范围中，因为多了一个int类型。
4.7 泛型方法
先看一个例子：
type DemoInt int
func (t DemoInt) methodName(param string) string {
}
这种类型，不管是前面的(t DemoInt)，还是方法名后面的参数(param string）里面都会涉及到具体的类型变量，因此都可以改造成泛型
4.7.1 接收器泛型
先定义一个泛型变量，然后在这个变量上加上一个方法：
//申请一个自定义的泛型约束类型
type NumberAll interface {
~int|~int64|~int32|~int16|~int8|~float64|~float32
}
//申请一个泛型切片类型，泛型参数是T，约束的类型是 NumberAll
type SliceNumber[T NumberAll] []T
//给泛型切片加上1个接收器方法
func (s SliceNumber[T]) SumIntsOrFloats() T {
var sum T
for _, v := range s {
sum += v
}
return sum
}
注意：(s SliceNumber[T])这个写法，T后面是不用带上它的约束类型NumberAll的，然后返回值也是T
如何去调用呢？其实和普通接收器方法一样，只不过需要先去实例化泛型切片
//实例化成int
var ss1 SliceNumber[int] = []int{1, 2, 3, 4}
//简化
//ss1 := SliceNumber[int]{1, 2, 34}
ss1.SumIntsOrFloats() // 10
//实例化成float64
var ss2 SliceNumber[float64] = []float64{1.11, 2.22, 3.33}
//简化
//ss2 := SliceNumber[float64]{1.11, 2.22, 3.33}
ss2.SumIntsOrFloats() //6.66
4.7.2 方法参数泛型
当接收器是一个普通的类型，在方法的参数里面使用泛型变量，如下：
type DemoSlice []int
func (d DemoSlice) FindOne[T int](a T) bool {
}
Method cannot have type parameters既然函数支持泛型，接收器也支持泛型，所以我们把两者结合起来稍加修改：
type DemoSlice[T int | float64] []T
func (d DemoSlice[T]) FindOne(a T) bool {
for _, t := range d {
if t == a {
return true
}
}
return false
}
s1 := DemoSlice[int]{1, 2, 3, 4}
fmt.Println(s1.FindOne(1))
s2 := DemoSlice[float64]{1.2, 2.3, 3.4, 4.5}
fmt.Println(s2.FindOne(1.2))
4.8 泛型接口
- 如果一个接口里面只有方法，这个接口叫基本接口
- 如果一个接口里面有约束类型，有或者没有方法的，这个接口叫一般接口
4.8.1 基本接口泛型
如何定义一个泛型接口呢？
type MyInterface[T int | string] interface {
WriteOne(data T) T
ReadOne() T
}
[]但值得注意的是，别写反了：
//会提示错误：interface method must have no type parameters
type MyInterface interface {
WriteOne[T int | string] (data T) T
ReadOne[T int | string] () T
}
那么如何实现一个基本泛型接口呢？
先定义一个普通的结构体类型，然后通过接收器方式绑定两个方法：
type Note struct {
}
func (n Note) WriteOne(one string) string {
return "hello"
}
func (n Note) ReadOne() string {
return "small"
}
然后，我们看如何实例化泛型接口并实现接口：
var one MyInterface[string] = Note{}
fmt.Println(one.WriteOne("hello"))
fmt.Println(one.ReadOne())
值得注意的是泛型参数的值的类型，要和被实现方法的参数保持一致，不然会报错：
//接口实例化用的是int，但是实现的方法里面都是string类型，并不匹配，无法被实现。
var one MyInterface[int] = Note{}
fmt.Println(one.WriteOne("hello"))
fmt.Println(one.ReadOne())
报错如下：
cannot use Note{} (value of type Note) as type MyInterface[int] in variable declaration:
Note does not implement MyInterface[int] (wrong type for ReadOne method)
have ReadOne() string
want ReadOne() int
4.8.2 一般接口泛型
先定义一个一般泛型接口，就是接口里有约束类型：
type MyInterface2[T int | string] interface {
int|string
WriteOne(data T) T
ReadOne() T
}
当我们实例化：
type Note2 int
func (n Note2) WriteOne(one string) string {
return "hello"
}
func (n Note2) ReadOne() string {
return "small"
}
var one MyInterface2[string] = Note{}
会出现报错：接口包含约束元素int和string，只能作为类型参数来使用
简而言之，一般泛型接口只能被当做类型参数来使用，无法被实例化