golang1.18 泛型初探

golang1.18 泛型初探

泛型出现之前

在泛型出现之前，go语言的灵活性很大部分是基于interface{}这个空接口来保证的。任何变量都可以继承空接口，但是在使用变量的时候，就需要对变量进行类型断言。而类型断言是基于反射来实现的，反射中的类型错误在真正运行的时候才会引发panic，而且大量使用反射会使得程序的效率变得非常低。

下面我们来看一个类型断言的例子：

package main

import (
	"fmt"
)

func SumInt(param []interface{}) (sum int) {
	for _, v := range param {
		sum += v.(int)
	}
	return
}
func ConnStrings(param []interface{}) (str string) {
	for _, v := range param {
		str += v.(string)
	}
	return
}

func AddSum(param ...interface{}) interface{} {
	switch param[0].(type) {
	case int:
		return SumInt(param)
	case string:
		return ConnStrings(param)
	default:
		fmt.Println("不支持相加的类型")
		return nil
	}
}

func main() {
	fmt.Println(AddSum(1, 2, 3))
	fmt.Println(AddSum("hello, ", "world"))
	fmt.Println(AddSum([]int{1, 2, 3}, []int{4, 5, 6}, []int{7, 8, 9}))
}

AddSum函数的参数是空接口类型，保证了传入参数的灵活性，但是参数在传入以后，需要进行解继承才能真正去使用。

但是泛型出现以后，就不需要这么麻烦了，使用以下的方式就可以去解决：

package main

import "fmt"

// 使用泛型约束函数的传入参数只能是int 和 string
// 如果是其它类型将会报错
func AddSum[T int | string](param ...T) (sum T) {
	for _, v := range param {
		sum += v
	}
	return
}

func main() {
	fmt.Println(AddSum(1, 2, 3))
	fmt.Println(AddSum("hello, ", "world"))
}

go1.18正式支持泛型，在goland中可以直接下载1.18版本。

泛型特性

泛型函数

package main

import "fmt"

func printSlice[T any](s []T) {
	for _, v := range s {
		fmt.Print(v)
	}
	fmt.Println()
}

func main() {
	printSlice[int]([]int{1, 2, 3, 4, 5})
	printSlice[string]([]string{"how", "are", "you"})
	printSlice[[]int]([][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}})
}

//12345
//howareyou
//[1 2 3][4 5 6][7 8 9]

T的后面是any表示传入函数的参数可以是任意类型，该函数的功能是打印传入切片的元素。

泛型slice

package main

import "fmt"

type vector[T any] []T

func printSlice[T any](s []T)  {
	for _, v := range s {
		fmt.Print(v)
	}
	fmt.Println()
}

func main() {
	arr := vector[int]{1, 2, 3}
	printSlice(arr)
	str := vector[string]{"how", "are", "you"}
	printSlice(str)
}

//123
//howareyou

上例中我们自定义了一种切片数据类型，该切片可以储存任意一种类型，但是要注意，声明一次只能存同一种数据类型。

泛型map

package main

import "fmt"

type M[K string, V any] map[K]V

func main() {
	m1 := make(M[string, int])
	m1["key1"] = 1
	m1["key2"] = 2
	for k, v := range m1{
		fmt.Println(k, v)
	}
	fmt.Println()

	m2 := make(M[string, string])
	m2["key1"] = "hello"
	m2["key2"] = "world"
	for k, v := range m2{
		fmt.Println(k, v)
	}
}

//key1 1
//key2 2
//
//key1 hello
//key2 world

要注意，map的K是不支持any的，所以在这里我把K约束成了string类型。

泛型channel

package main

import "fmt"

type C[T any] chan T

func main() {
	chan1 := make(C[int], 2)
	chan1 <- 1
	chan1 <- 2
	fmt.Println(<-chan1)

	chan2 := make(C[string], 2)
	chan2 <- "hello"
	chan2 <- "world"
	fmt.Println(<-chan2)
}

// 1
// hello

可比较类型

package main

import "fmt"

// FindFunc 泛型约束：可比较类型
func FindFunc[T comparable](a []T, v T) int {
	for i, e := range a {
		if e == v {
			return i
		}
	}
	return -1
}

func main() {
	fmt.Println(FindFunc([]int{1, 2, 3, 4, 5}, 10))
	fmt.Println(FindFunc([]string{"abc", "def", "ghi"}, "def"))
}

//-1
//1

泛型还可以约束一种可比较类型comparable，大致功能就是在一个切片中找一个数，具体的算法需要自己实现，在这里我简单的演示了一下。

使用interface中规定的类型来约束函数的参数

package main

import "fmt"

// Number 使用interface来约束泛型中可以传入的类型
type Number interface {
	~int | float64 | string
}

func Add[T Number](a, b T) T {
	return a + b
}

func main() {
	fmt.Println(Add(1, 2))
	fmt.Println(Add(1.1, 2.2))
	fmt.Println(Add("hello, ", "world"))

}

//3
//3.3000000000000003
//hello, world

如果函数的约束类型过多怎么办，如果直接写在函数名后面的方括号中，代码将显得非常丑陋，这个时候我们使用interface约束类型。注意，~符号表示约束某种类型的底层类型。

使用interface中规定的方法来约束函数的参数

package main

import (
	"fmt"
	"strconv"
)

type Price int

// ShowPrice 使用interface来约束传入ShowPriceList函数中的类型必须实现了String方法，不然就报错
type ShowPrice interface {
	String() string
}

func (i Price) String() string {
	return strconv.Itoa(int(i))
}

func ShowPriceList[T ShowPrice](s []T) (res []string) {
	for _, v := range s {
		res = append(res, v.String())
	}
	return
}

func main() {
	fmt.Println(ShowPriceList([]Price{1, 2}))
}

传入ShowPriceList函数的参数，必须实现String方法。

使用interface中规定的类型和方法来双重约束函数的参数

package main

import "strconv"

type PriceInt int
func (i PriceInt)String() string {
	return strconv.Itoa(int(i))
}

type PriceString string
func (i PriceString)String() string {
	return string(i)
}

// ShowPrice 约束底层类型必须是int和string 且 必须实现String方法
type ShowPrice interface {
	String() string
	~int | ~string
}

func ShowPriceList[T ShowPrice](s []T) (res []string) {
	for _, v := range s {
		res = append(res, v.String())
	}
	return res
}

func main() {
	ShowPriceList([]PriceInt{1, 2})
	ShowPriceList([]PriceString{"abc", "def"})
}

传入ShowPriceList函数的参数的底层类型必须是int或者string且必须实现String方法。