ToB企服应用市场:ToB评测及商务社交产业平台

标题: go基础-泛型 [打印本页]
作者: 万万哇    时间: 2023-12-13 12:48
标题: go基础-泛型
概述

在强类型变成语言中，类型是确定不可变，如函数入参是确定类型、链表元素是确定类型，这极大限制了函数功能。也有些解决方案，为每种类型都实现一版函数，会导致大量重复代码；使用类型转换，使用特殊形参（如Object、any），在函数内部判断并转换类型后再执行逻辑，导致大量类型转换的代码，结构混乱，Java 未支持泛型之前就使用这个套路。最优解决方案是泛型，即类型参数化，编写函数暂时不确定类型，使用占位符代替，调用时候类型也是通过参数传递进去，替换占位符。主流强类型语言都支持泛型，Java、C++、C#等。
千呼万唤始出来，1.18版本正式增加泛型支持，但是体感貌似一般，使用场景并没有那么广泛，特别是泛型约束能力，相比Java、C++弱了很多。更多是对函数式编程的支持，如slice、map、func等，在面向对象编程支持不够。不确定后期是否会继续演变，Go对兼容性保持还算可以，后续演变也不用过分担忧。
基本使用

Go 语言不是主流的面向对象，泛型支持上也有所区别，如Java一切皆为对象，只要确定对象泛型即可统一的泛型模式。Go的每种类型都有区别，可简单分为两类，类型泛型：切片泛型、哈希泛型、结构体泛型、基础类型泛型等；函数泛型：函数泛型、方法泛型等。另外泛型语法不是主流的尖括号，而使用的[]中括号，这不重要，思路都是相似的
类型泛型，风格基本一致，使用type定义别名，名称后面紧跟泛型定义，然后是基础类型。
  1. type MyGen[T any] int
复制代码
函数泛型，语法也比较类似，函数名称后面紧跟泛型定义
  1. func MyFun[T any](x T, n int) {
  2.     ...
  3. }
复制代码
切片泛型

定义切片泛型。使用type定了名称为genSlice的新类型，底层类型是个切片。紧跟在名称后面的[T any]就是泛型定义，T表示泛型占位符，any表示泛型约束，可以看到切片的元素类型也使用了T占位符
  1. type genSlice[T any] []T
复制代码
any是标准库提供的特殊类型，表示任意类型，其本质是个空接口 type any = interface{}，类似Java中的Object类型。更多泛型约束信息独立章节介绍
使用泛型切片，与普通切片几乎一模一样。唯一区别，创建时需要传递参数类型，这就是所谓的类型参数化。
  1. arr := make(genSlice[int], 0)
  2. arr2 := genSlice[float64]{1.1, 1.2, 2.1}
  3. var arr3 = genSlice[string]{"a", "b", "cd"}
复制代码
创建了三个切片，相比普通切片多了个参数，使用大括号传递的类型参数，在底层会替换占位符T，三个切片的元素类型分别是int、float64、string。仅此而已，再无其他区别。访问切片
  1. arr = append(arr, 10)
  2. arr = append(arr, 20)
  4. for _, i := range arr {
  5.     fmt.Printf("%T=%v\n", i, i)
  6. }
复制代码
输出如下
  1. int=10
  2. int=20
复制代码
哈希泛型

也就是map切片，map有两个参数，可以定一个或两个泛型，其他方面与切片泛型几乎一样
  1. type genMap1[V any] map[string]V                                // 一个泛型, key 是字符串, value是泛型, 创建时传入
  2. type genMap2[K string|int, V any] map[K]V                // 两个泛型, key 是泛型且限定为字符串或整数, value是泛型且没有限定
复制代码
创建实例
  1. m1 := genMap1[int]{"k1": 1}
  2. m2 := genMap2[string, string]{"k1": "v1"}
复制代码
管道泛型

泛型定义
  1. type genChan[T any] chan T
复制代码
创建实例
  1. chan1 := make(genChan[int])
  2. var chan2 genChan[string]                // nil, 引用类型需要初始化
复制代码
基础类型泛型

相比容器类型有一些区别。基础类型不能只有类型形参，如下缺乏原始类型。
  1. type CommonType[T int|string|float32] T                // err
复制代码
正确定义，给出原始类型int
  1. type CommonType[T int | string | float32] int
复制代码
由于原始类型是int，导致泛型约束无效，原始类型限定更强
  1. var v1 CommonType[int] = 10                                // ok
  2. var v2 CommonType[string] = "test"                // err
复制代码
函数泛型

定义泛型函数
  1. func add[T int|string](x, y T) T {
  2.         return x+y
  3. }
复制代码
调用泛型函数，一样的套路，调用时多个传递一个参数，表示类型
  1. n := add[int](1, 2)
  2. fmt.Println(n)
复制代码
注意，匿名函数不支持泛型，匿名函数不能定义类型参数，以下案例编译不通过
  1. func[T int | float32](a, b T) T {                // err
  2.         return a+b
  3. }
复制代码
闭包函数则可以使用泛型，闭包函数是对外部类型的应用，而不是类型参数。
  1. func MyFunc[T int | float32]() func(a, b T) T {
  2.         return func(a, b T) T {
  3.                 return a + b
  4.         }
  5. }
复制代码
结构体泛型

定义泛型结构体
  1. type genStruct[T int | string] struct {
  2.     Name string
  3.     Data T
  4. }
复制代码
创建实例
  1. p1 := genStruct[int]{"xx", 10}
  2. p2 := new(genStruct[string])
复制代码
注意，匿名结构体目前还不支持泛型，以下代码编译不通过。
  1. struct[T int|string] {
  2.     caseName string
  3.     got      T
  4.     want     T
  5. }[int]{
  6.     caseName: "test OK",
  7.     got:      100,
  8.     want:     100,
  9. }
复制代码
需要特别注意的是结构体方法，泛型结构体并不代表方法泛型。判断一个方法是否支持泛型，要看是否有定义类型参数，这与Java特性一样。如下setName就是普通方法，因为并没有定义泛型参数。名称前面的(p *person[T]) 是类型绑定，而不是类型参数。setName虽然是普通方法，但是内部可以使用结构体中定义的泛型
  1. type person[T string | int] struct {
  2.         name T
  3. }
  5. func (p *person[T]) setName(name T) T {                // 普通方法
  6.         p.name = name
  7.         return p.name
  8. }
复制代码
截止目前go 还不支持泛型方法(1.9版本)，如果后续支持，定义方式应该如下，增加了类型参数E
  1. func (p *person[T]) setName[E string](name T, surname E) T {
  2.     ...
  3. }
复制代码
泛型也支持相互套用
  1. type WowStruct[T int | float32, S []T] struct {
  2.     Data     S                // S是T类型切片
  3.     MaxValue T
  4.     MinValue T
  5. }
复制代码
看起来有点复杂，只要记住一点：任何泛型类型都必须传入类型实参实例化才可以使用。
  1. var ws WowStruct[int, []int]
复制代码
接口泛型

接口泛型最为特殊，因为方法不支持泛型，接口定义却支持泛型，看似好像两者冲突了。其实用了个鸡贼的方式实现，绕开了问题根本，本质是类型转换。接口泛型定义如下，看起来没有特别之处
  1. type DataProcessor[T any] interface {
  2.         Process(oriData T) (newData T)
  3.         Save(data T) error
  4. }
复制代码
实现泛型接口
  1. type CSVProcessor struct {
  2. }
  4. func (c CSVProcessor) Process(oriData string) (newData string) {
  5.         return oriData
  6. }
  8. func (c CSVProcessor) Save(oriData string) error {
  9.         return nil
  10. }
复制代码
注意：与实现非泛型接口有区别，结构体的方法签名与泛型接口内方法签名不一样，按照规范两者没有实现关系。讨巧就在这里，给泛型传入类型参数，然后类型转换。
  1. func MyFun(E DataProcessor[string]) {                                        // 形参是泛型接口
  2.         println(E.Process("name"))
  3. }
  5. var processor DataProcessor[string] = CSVProcessor{}        // 类型转换
  6. MyFun(processor)
复制代码
包装泛型

以下方式也都是错误定义
  1. // 错误, 它认为你要定义一个存放切片的数组，数组长度由 T 乘以 int 计算得到
  2. type NewType [T * int][]T
  4. //✗ 错误。和上面一样，这里不光*被会认为是乘号，| 还会被认为是按位或操作
  5. type NewType2[T *int|*float64] []T
  7. //✗ 错误
  8. type NewType2 [T (int)] []T
复制代码
解决方法也都一样，使用接口包装。在“接口类型约束”章节详细说明
  1. type NewType interface {
  2.     *int | *float64
  3. }
复制代码
泛型约束

除了类型参数化，泛型有个重要作用：类型约束。简单理解就是限定泛型占位符的范围，比如类型参数只能是数组、字符串、数组、接口、函数等。Java的泛型约束可支持上边界、下边界、或类型等；Go泛型约束弱一些，没有上边界、下边界。主要原因还是Go的特殊面向对象，没有Java完整的类型系统。
基本类型约束

泛型约束为int类型
  1. func MyFunc[T int]() T {
  2.         ...
  3. }
复制代码
这种单个基础数据类型约束没有意义，直接使用基础类型效果一样。更多时候会约束一个范围，如下约束范围是所有的整数类型。
  1. func MyFunc[T int|int8|int16|int32|int64|float32|float64]() T {
  2.         ...
  3. }
复制代码
接口类型约束

接口是泛型约束中使用最广泛的类型，这与Java一致。面向接口编程，面向接口约束。
在基本类型约束中有个案例
  1. func MyFunc[T int|int8|int16|int32|int64|float32|float64]() T {
  2.         ...
  3. }
复制代码
这种写法繁琐且不方便复用，如果其他函数有相同的约束需求，需要再写一遍，为此Go 提供特殊的接口定义，专门用于泛型约束。
  1. // 整型
  2. type Int interface {
  3.     int|int8|int16|int32|int64|float32|float64
  4. }
  6. // 无符号整型
  7. type Uint interface {
  8.     uint | uint8 | uint16 | uint32
  9. }
  11. // 浮点
  12. type Float interface {
  13.     float32 | float64
  14. }
复制代码
接口约束之间也继续组合，约束为所有数值类型
  1. type Number interface {
  2.     Int | Uint | Float
  3. }
复制代码
使用接口约束，与使用其他约束一样
  1. func MyFunc[T Number]() T {
  2.         ...
  3. }
复制代码
上面接口定义各类型使用|符号分割，是并集关系，也支持交集关系
  1. // 并集
  2. type AllInt interface {
  3.     ~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint32
  4. }
  6. // 并集
  7. type Uint interface {
  8.     ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
  9. }
  11. // 交集, 接口A代表的类型集是 AllInt 和 Uint 的交集
  12. type A interface {
  13.     AllInt
  14.     Uint
  15. }
  17. // 交集, 接口B代表的类型集是 AllInt 和 ~int 的交集
  18. type B interface {        
  19.     AllInt
  20.     ~int
  21. }
复制代码
空集合， int 和 float32 没有相交的类型，所以接口 Bad 代表的类型集为空，没有任何类型可以匹配，这与any空接口刚好相反，后者可表示任意类型。
  1. type Bad interface {
  2.     int
  3.     float32
  4. }
复制代码
注意：并集和交集只能用于基本类型，如下定义异常
  1. type A interface{
  2.     funcA()
  3. }
  5. type B interface{
  6.     funcB()
  7. }
  9. type C interface{
  10.     A | B                        // err
  11. }
复制代码
穿透别名，项目中经常使用type定义别名，泛型约束无法穿透别名，如下案例编译不通过
  1. type MyInt int
  3. func MyFunc[T MyInt]() T {
  4.         ...
  5. }
  7. MyFunc[int]()                // err，int != MyInt
复制代码
Go专门为此提供了特殊语法，在类型前面增加~符号，可穿透别名约束到底层类型。
  1. type MyInt interface {
  2.         ~int | ~int8 | ~int16 | ~int32 | ~int64
  3. }
  5. func MyFunc[T MyInt]() T {
  6.         ...
  7. }
  9. MyFunc[int]()                // ok
  10. MyFunc[MyInt]()                // ok
复制代码
使用~符号穿透别名约束有一些限制条件：~后面的类型不能为接口，~后面的类型必须为基本类型。
  1. type MyInt int
  3. type _ interface {
  4.     ~int                // ok
  5.     ~[]byte          // ok
  6.     ~MyInt           // err，~后的类型必须为基本类型
  7.     ~error           // err，~后的类型不能为接口
  8. }
复制代码
接口新语法有更深层次的意义，影响深远，在1.18版本之前接口是一堆函数声明的集合，称为方法集（method set）。如下ReadWriter 定义了一个接口 ，包含了 Read() 和 Write() 两个方法。所有同时定义了这两种方法的类型被视为实现了这一接口。
  1. type ReadWriter interface {
  2.     Read(p []byte) (n int, err error)
  3.     Write(p []byte) (n int, err error)
  4. }
复制代码
但是如果换一个角度来重新思考，会发现还能这样理解：可以把  ReaderWriter 接口看成代表一个“类型的集合”，所有实现了  Read()  Writer() 这两个方法的类型都在接口代表的类型集合当中。从 1.18 开始接口的定义就从 **方法集(method set)** 变为了 **类型集(type set)**。
以此配合接口增加了新技能，接口不仅可以定义方法声明，也定义底层类型。来个复杂点的案例，接口类型 ReadWriter 代表了一个类型集合，所有以 string 或 []rune 为底层类型，并且实现了 Read()和Write() 这两个方法的类型都在 ReadWriter 代表的类型集当中
  1. type ReadWriter interface {
  2.     ~string | ~[]rune
  4.     Read(p []byte) (n int, err error)
  5.     Write(p []byte) (n int, err error)
  6. }
复制代码
从此接口可分为两种类型：Basic interface基本接口，接口内仅包含方法声明，就是Go1.18 之前的接口。General interface一般接口，接口内有定义原始类型，以及方法声明。以下两个接口都是一般接口，因为内部都有定义原生类型
  1. type Uint interface {                
  2.     ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64        // 原始类型
  3. }
  5. type ReadWriter interface {         
  6.     ~string | ~[]rune                                                                // 原始类型
  8.     Read(p []byte) (n int, err error)
  9.     Write(p []byte) (n int, err error)
  10. }
复制代码
容器类型约束

常用的约束
  1. func MyFun[T any](arr []T) {
  2.         for i := range arr {
  3.                 log.Println(i)
  4.         }
  5. }
复制代码
以下两种写法和实现的功能其实是差不多的，实例化之后结构体相同
  1. type WowStruct[T int|string] struct {
  2.     Name string
  3.     Data []T
  4. }
  6. type WowStruct2[T []int|[]string] struct {
  7.     Name string
  8.     Data T
  9. }
复制代码
但是像下面这种情况的时候，使用前一种写法会更好
  1. type WowStruct3[T int | string] struct {
  2.     Data     []T
  3.     MaxValue T
  4.     MinValue T
  5. }
复制代码
函数类型约束

也比较常规，就是使用函数签名约束，更多使用接口约束
  1. func MyFunc[T any](arg T) {
  2.     ...
  3. }
复制代码
参考

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4