Go语言泛型，类型约束用法_go interface算泛型吗-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_74109207/article/details/143840693

Go语言的泛型类型约束是通过接口（interface）来实现的。类型约束允许你在定义泛型函数或类型时，指定类型参数必须满足的条件。以下是Go语言中类型约束的所有语法和用法的详细讲解。

基本类型约束

具体类型：
你可以直接指定一个具体的类型作为约束。
```
func add[T int](a, b T) T {
    return a + b
}
```

接口类型：
你可以使用接口来约束类型参数。接口可以包含方法签名，也可以包含类型列表。

type Number interface {
    int | float32 | float64
}

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

类型列表

联合类型：
使用|符号来表示联合类型，即类型参数可以是这些类型中的任意一种。

type MyType interface {
    ~int | ~string | ~bool
}

func print[T MyType](v T) {
    fmt.Println(v)
}

约束条件

方法约束：
你可以要求类型参数实现特定的方法。

type Stringer interface {
    String() string
}

func printString[T Stringer](s T) {
    fmt.Println(s.String())
}

预声明类型：
你可以使用预声明的类型（如any、comparable等）作为约束。

// 任何类型
func printAny[T any](v T) {
    fmt.Println(v)
}

// 可比较类型
func find[T comparable](slice []T, value T) int {
    for i, v := range slice {
        if v == value {
            return i
        }
    }
    return -1
}

组合约束

多个约束条件：
你可以组合多个约束条件，使类型参数同时满足多个条件。

type Ordered interface {
    ~int | ~float64
}

type Comparable interface {
    comparable
}

type OrderedComparable interface {
    Ordered
    Comparable
}

func max[T OrderedComparable](a, b T) T {
    if a > b {
        return a
    }
    return b
}

预声明的类型约束

any：
任何类型都可以满足any约束。

func printAny[T any](v T) {
    fmt.Println(v)
}

comparable：
只有可比较的类型才能满足comparable约束。

func find[T comparable](slice []T, value T) int {
    for i, v := range slice {
        if v == value {
            return i
        }
    }
    return -1
}

示例

下面是一个综合示例，展示了如何使用各种类型的约束：

package main

import (
    "fmt"
)

// 定义一个接口，包含所有基本数字类型
type Number interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 | 
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | 
    ~float32 | ~float64
}

// 定义一个接口，包含所有字符串类型
type Stringy interface {
    ~string
}

// 定义一个接口，包含所有可比较的类型
type Comparable interface {
    comparable
}

// 定义一个接口，包含所有实现了String方法的类型
type Stringer interface {
    String() string
}

// 定义一个泛型函数，支持所有数字类型
func add[T Number](a, b T) T {
    return a + b
}

// 定义一个泛型函数，支持所有字符串类型
func concat[T Stringy](a, b T) T {
    return a + b
}

// 定义一个泛型函数，支持所有可比较的类型
func find[T Comparable](slice []T, value T) int {
    for i, v := range slice {
        if v == value {
            return i
        }
    }
    return -1
}

// 定义一个泛型函数，支持所有实现了String方法的类型
func printStringer[T Stringer](s T) {
    fmt.Println(s.String())
}

func main() {
    // 测试add函数
    fmt.Println(add[int](1, 2)) // 输出: 3

    // 测试concat函数
    fmt.Println(concat[string]("hello", " world")) // 输出: hello world

    // 测试find函数
    slice := []int{1, 2, 3, 4, 5}
    index := find(slice, 3)
    fmt.Println(index) // 输出: 2

    // 测试printStringer函数
    type MyStruct struct{}
    func (m MyStruct) String() string {
        return "MyStruct"
    }
    printStringer(MyStruct{}) // 输出: MyStruct
}