Go 泛型

男娘i 2023-10-10 21:54 5阅读 0赞

#### 阅读目录 ####

*  Go 泛型
 *   *  泛型遍历数据
     *  泛型解决的问题
     *  基于泛型的队列
     *  动态判断变量的类型

## Go 泛型 ##

泛型减少重复代码并提高类型安全性。

在下面情景的时候非常适合使用泛型:  
当你需要针对不同类型书写同样的逻辑，使用泛型来简化代码是最好的。

类型形参 (Type parameter)  
类型实参(Type argument)  
类型形参列表( Type parameter list)  
类型约束(Type constraint)  
实例化(Instantiations)  
泛型类型(Generic type)  
泛型接收器(Generic receiver)  
泛型函数(Generic function)  
等等等等

### 泛型遍历数据 ###

package main
    
    import "fmt"
    
    func main() {
        
    	strs := []string{
        "wgchen", "willem"}
    	int_var := []int{
        1, 2}
    	printArray(strs)
    	printArray(int_var)
    	fs := []float64{
        1.1, 3.3}
    	printArray(fs)
    }
    
    // 不限定类型，调用的时候自己去定义类型
    // []T 形式类型，实际类型 [T string | int]
    func printArray[T float64 | string | int](arr []T) {
        
    	for _, a := range arr {
        
    		fmt.Println(a)
    	}
    }

PS D:\TEXT\go_test> go run .\main.go
    wgchen
    willem
    1
    2
    1.1
    3.3
    PS D:\TEXT\go_test>

内置的泛型类型 any 和 comparable

any 表示 go 里面所有的内置基本类型，等价于 interface\{\}。

comparable 表示 go 里面所有内置的可比较类型：  
int、uint、float、bool、struct、指针等一切可以比较的类型。

func printArray[T any](arr []T) {
        
    	for _, a := range arr {
        
    		fmt.Println(a)
    	}
    }

func printArray[T comparable](arr []T) {
        
    	for _, a := range arr {
        
    		fmt.Println(a)
    	}
    }

### 泛型解决的问题 ###

一切从函数的形参和实参说起，假设我们有个计算两数之和的函数：

func Add(a int, b int) int {
        
    	return a + b
    }

这个函数很简单，但是它有个问题——无法计算int类型之外的和。如果我们想计算浮点或者字符串的和该怎么办？

解决办法之一就是像下面这样为不同类型定义不同的函数：

func AddFloat32(a float32, b float32) float32 {
        
        return a + b
    }
    
    func AddString(a string, b string) string {
        
        return a + b
    }

完整示例代码

package main
    
    import "fmt"
    
    func main() {
        
    	result := Add(2, 3)
    	fmt.Println("Add(2, 3) =", result)
    
    	resultFloat := AddFloat32(2.5, 3.7)
    	fmt.Println("AddFloat32(2.5, 3.7) =", resultFloat)
    
    	resultString := AddString("Hello, ", "World!")
    	fmt.Println("AddString(\"Hello, \", \"World!\") =", resultString)
    }
    
    func Add(a int, b int) int {
        
    	return a + b
    }
    func AddFloat32(a float32, b float32) float32 {
        
    	return a + b
    }
    
    func AddString(a string, b string) string {
        
    	return a + b
    }

PS D:\TEXT\go_test> go run .\main.go
    Add(2, 3) = 5
    AddFloat32(2.5, 3.7) = 6.2
    AddString("Hello, ", "World!") = Hello, World!
    PS D:\TEXT\go_test>

### 基于泛型的队列 ###

队列是一种先入先出的数据结构，它和现实中排队一样，数据只能从队尾放入、从队首取出，先放入的数据优先被取出来。

package main
    
    import "fmt"
    
    func main() {
        
    	var q1 Queue[int] // 可存放int类型数据的队列
    	q1.Put(1)
    	q1.Put(2)
    	q1.Put(3)
    	fmt.Println(q1)
    	q1.Pop() // 1
    	q1.Pop() // 2
    	q1.Pop() // 3
    
    	var q2 Queue[string] // 可存放string类型数据的队列
    	q2.Put("A")
    	q2.Put("B")
    	q2.Put("C")
    	q2.Pop() // "A"
    	q2.Pop() // "B"
    	q2.Pop() // "C"
    	fmt.Println(q2)
    
    	// var q3 Queue[struct{ Name string }]
    	// var q4 Queue[[]int]     // 可存放[]int切片的队列
    	// var q5 Queue[chan int]  // 可存放int通道的队列
    	// var q6 Queue[io.Reader] // 可存放接口的队列
    }
    
    /*
    这里类型约束使用了空接口，
    代表的意思是所有类型都可以用来实例化泛型类型 Queue[T] (关于接口在后半部分会详细介绍）
    */
    type Queue[T interface{
        }] struct {
        
    	elements []T
    }
    
    // 将数据放入队列尾部
    func (q *Queue[T]) Put(value T) {
        
    	q.elements = append(q.elements, value)
    }
    
    // 从队列头部取出并从头部删除对应数据
    func (q *Queue[T]) Pop() (T, bool) {
        
    	var value T
    	if len(q.elements) == 0 {
        
    		return value, true
    	}
    
    	value = q.elements[0]
    	q.elements = q.elements[1:]
    	return value, len(q.elements) == 0
    }
    
    // 队列大小
    func (q Queue[T]) Size() int {
        
    	return len(q.elements)
    }

PS D:\TEXT\go_test> go run .\main.go
    {[1 2 3]}
    {[]}
    PS D:\TEXT\go_test>

### 动态判断变量的类型 ###

使用接口的时候经常会用到类型断言或 `type swith` 来确定接口具体的类型，然后对不同类型做出不同的处理，如：

package main
    
    import "fmt"
    
    var i interface{
        } = 123
    
    func main() {
        
    	swit()
    }
    
    func swit() {
        
    	value, ok := i.(int) // 类型断言
    	if ok {
        
    		fmt.Println("i is an int:", value)
    	}
    
    	// type switch
    	switch v := i.(type) {
        
    	case int:
    		fmt.Println("i is an int:", v)
    	case string:
    		fmt.Println("i is a string:", v)
    	default:
    		fmt.Println("i is of unknown type")
    	}
    }

PS D:\TEXT\go_test> go run .\main.go
    i is an int: 123
    i is an int: 123
    PS D:\TEXT\go_test>

Put 方法中使用反射来获取值的类型并进行相应处理：

package main
    
    import (
    	"fmt"
    	"reflect"
    )
    
    type Queue[T any] struct {
        
    	items []T
    }
    
    func (q *Queue[T]) Put(value T) {
        
    	fmt.Printf("Type of value: %T\n", value)
    
    	v := reflect.ValueOf(value)
    
    	switch v.Kind() {
        
    	case reflect.Int:
    		fmt.Println("Value is an int:", v.Int())
    	case reflect.String:
    		fmt.Println("Value is a string:", v.String())
    	default:
    		fmt.Println("Value is of unknown type")
    	}
    
    	// ...
    }
    
    func main() {
        
    	queue := Queue[int]{
        }
    	queue.Put(42)
    
    	strQueue := Queue[string]{
        }
    	strQueue.Put("Hello, World!")
    }

PS D:\TEXT\go_test> go run .\main.go
    Type of value: int
    Value is an int: 42
    Type of value: string
    Value is a string: Hello, World!
    PS D:\TEXT\go_test>