go语言的反射和泛型

反射

反射可以在程序的运行时获取变量的各种信息。Go语言中光反射在reflect包下。

http://c.bian Cheng.net/view/4407.html

泛型

Go语言中通过断言转化为指定类型。

func main() {
    
	arr := []string{
    "int", "dghjs", "hdk"}
	printArr(arr)
	arr1 := []int{
    1, 2, 3}
	printArr(arr1)
}

// 多类型判断
// 保证参数的多样性
// 保证处理值的多样性
func printArr(arr interface{
    }) {
    
	//string
	if v, ok := arr.([]string); ok {
    
		for _, v := range v {
    
			fmt.Println(v)
		}
	}
	//int
	if v, ok := arr.([]int); ok {
    
		for _, v := range v {
    
			fmt.Println(v)
		}
	}
	//...
}

但这并不普遍。通过断言进行的判断必须是已定义的类型。如果未定义，则不可用，因此不具有通用性。泛型是这个问题的解决方案，使类型判断变得普遍。

Go 泛型学习之路

在下面的add函数中，我们需要将两个数字相加，可以写成下面的函数

func add(x int, y int) int {
    
	return x + y
}

事实上，可能还有更多的类型需要传入，比如浮点类型、字符串等，所以需要编写如下函数：

func addF(x float32, y float32) float32 {
    
	return x + y
}

//
func addS(x string, y string) string {
    
	return x + y
}

这样，要实现相同的功能，就需要编写几个相同的方法。函数中变化的量都在参数和返回值中，而这三个量在定义时并不分配内存，即传入实际参数时类型是未知的。

那么参数和返回值定义就可以直接指向任何类型的变量。泛型用于实现协调类型和相关解决方案。

在go语言中interface{}可以指代任何类型，那么就可以使用接口作为参数课返回值。如下：

package main

import "fmt"

func main() {
    
	println("hello")
	//a1 := add(10, 100)
	s1 := add("hello", "world")
	fmt.Printf("value=%v,type=%T", s1, s1)
}

//泛型优势
/* 1. 函数参数和返回值的人类型 2. 集合元素类型的显式声明 */

// func add(x int, y int) int {
    
// return x + y
// }

func add(x any, y any) any {
    
	var resultINT int
	var resultFLOAT float32
	var resultSTRING string
	n, ok := x.(int)
	if ok {
    
		resultINT = n + y.(int)
	}
	m, ok := x.(float32)
	if ok {
    
		resultFLOAT = m + y.(float32)
	}
	z, ok := x.(string)
	if ok {
    
		resultSTRING = fmt.Sprint(z, y.(string))
	}
	if n != 0 {
    
		return resultINT
	}
	if z != "" {
    
		return resultSTRING
	}
	return resultFLOAT
}

小编使用的go版本是1.19已经支持泛型了，而且返回值为接口时已经会自动转化成返回的实际类型了。
不想Java若用Object作为参数还需要强转。

声明式的返回值类型还是any接口，但是在运行后就变成了string，这就是泛型自动转换了。

如果没有泛型，则需要手动转换，如下：

a2 := add(10, 15).(int)
s2 := add("你好", "泛型").(string)

在Java中类是一等公民，所以泛型围绕着类展开，如ArrayList<String>，而在go中函数是一等公民泛型围绕函数展开。

在go中方法通过泛型通过[泛型 类型]声明，并紧跟方法之后，支持|逻辑的多个类型声明。

[T int]
[T int | float32| float 64 | string]

注意只能是|不能是||，前者取一个后者取两个。

func add[T int | float32 | string](a, b T) T {
    
	return a + b
}

泛型声明编辑器可以自动转换和指定类型，如下：

//不指明类型
a3 := add(1, 8)
fmt.Println(a3)
s3 := add("hello", "world")
fmt.Println(s3)
//声明类型
a4 := add[int](19, 25)

s4 := add[string]("你好", "泛型")