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"))
}

o1.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方法。