golang1.18 泛型学习

2022-05-27 14:35:16 阅读：121 来源： 互联网

标签：string int fmt golang1.18 学习 Println func 泛型 main

泛型出现之前

在泛型出现之前，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方法。

标签：string,int,fmt,golang1.18,学习,Println,func,泛型,main
来源： https://www.cnblogs.com/sunlong88/p/16317471.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9