golang 泛型的格式写法

golang · 浏览次数 : 2

小编点评

Go语言中的泛型是一种重要的特性，它允许开发者编写可重用的代码，而不必针对每种数据类型重复相同的逻辑。泛型通过参数化类型实现，使得函数、方法、接口和结构体能够与多种类型协同工作。 ### 泛型函数的基本格式泛型函数的基本格式包括以下几个部分： - `func functionName[TypeParameters constraints](arguments) returnType {`: 指定函数名、类型参数列表、类型约束、参数列表以及返回值类型。 - `TypeParameters`: 类型参数列表，用逗号分隔。 - `constraints`: 可选的类型约束，用于限制类型参数的可实例化类型。 - `arguments`: 函数参数列表，与非泛型函数一致。 - `returnType`: 函数的返回值类型，也可以是泛型类型。 ### 示例以一个泛型的Max函数为例，该函数接受两个类型为T的参数，并返回较大的那个： ```go package main import ( "fmt" ) // 假设我们要编写一个泛型的 Max 函数，它可以接受两种类型的参数并返回较大的那个 type comparable interface { // 这里示例说明 T 必须是 int 或 float64 或 string 类型 } // 类型约束，用来限制类型参数可以被哪些具体类型实例化。 // 它可以是一个预定义的约束如 any（表示可以是任何类型），或者是自定义的接口约束。 func MyFunction[T any](t T) { // 函数体 } // 类型约束，要求 T 实现了 comparable 接口，意味着 T 可以用于比较操作。 // 注意这里的类型约束不能用 any，因为 T 默认情况下并不保证是可以比较的,会编译报错。 // 比如尝试对不支持的操作（如比较、算术运算）使用该类型参数时，会在编译时遇到错误。 func Max[T comparable](a, b T) T { if a > b { return a } return b } func main() { // 使用Max函数打印数值 PrintValue(42) // 输出: Value is: 42 // 使用Max函数比较两个整数值 fmt.Println(Max[int](1, 2)) // 输出: 2 // 使用Max函数比较两个浮点数值 fmt.Println(Max[float64](3.14, 2.71)) // 输出: 3.14 // 使用Max函数比较两个字符串 fmt.Println(Max[string]("apple", "banana")) // 输出: banana } ``` 在上面的示例中，`comparable` 是一个预定义的约束，表示这个类型参数需要是一个可以比较的类型，例如基本的数值类型或字符串等。 ### 结论通过在函数、方法或接口中使用类型参数并添加类型约束，Go语言使得开发者能够创建高度可复用的代码。这样可以有效避免对于每种可能的数据类型都需要重新编写相似逻辑的问题，从而提高开发效率和代码质量。

正文

Go语言中的泛型（Generics）是在 Go 1.18 版本中引入的一个重要特性，它允许你编写可重用的代码，而不需要为每种数据类型重复编写相同的逻辑。

泛型通过参数化类型（type parameters）来实现，使得函数、方法、接口和结构体可以与多种类型一起工作。

下面详细介绍Go语言中泛型的基本格式和用法：

泛型函数的基本格式如下：

func functionName[TypeParameters constraints](arguments) returnType {
    // 函数体
}

　　functionName: 是泛型函数的名字。

　　TypeParameters: 是类型参数列表，放在函数名后的方括号中，用逗号分隔多个类型参数。每个类型参数代表一个待定的类型。

　　constraints: 是类型约束，可选，用来限制类型参数可以被哪些具体类型实例化。它可以是一个预定义的约束如any（表示可以是任何类型），或者是自定义的接口约束。

　　arguments: 是函数的参数列表，与非泛型函数相同。

　　returnType: 是函数的返回类型，同样可以是泛型类型。

类型约束用来限制类型参数可以被哪些类型实例化。

你可以使用预定义的约束，如 any（等同于空接口interface{}，可以匹配任何类型），或者定义自己的接口约束。

自定义类型约束的示例：

type MyConstraint interface {
    // 这里列出约束条件，比如必须实现的方法
    SomeMethod()
}

func MyFunction[T MyConstraint](t T) {
    // 函数体
}

【示例】

假设我们要编写一个泛型的 Max 函数，它可以接受两种类型的参数并返回较大的那个：

package main

import (
    "fmt"
)


type comparable interface {
    ~int | ~float64 | ~string // 这里示例说明 T 必须是 int 或 float64 或 string 类型
}

// 类型约束，用来限制类型参数可以被哪些具体类型实例化。
// 它可以是一个预定义的约束如 any（表示可以是任何类型），或者是自定义的接口约束。
func PrintValue[T any](value T) {
    fmt.Println("Value is:", value)
}

// 类型约束，要求 T 实现了 comparable 接口，意味着 T 可以用于比较操作。
// 注意这里的类型约束不能用 any，因为 T 默认情况下并不保证是可以比较的,会编译报错。
// 比如尝试对不支持的操作（如比较、算术运算）使用该类型参数时，会在编译时遇到错误。
func Max[T comparable](a, b T) T {
    if a > b {
        return a
    }
    return b
}

func main() {
    PrintValue(42)    // 输出: Value is: 42

    fmt.Println(Max[int](1, 2))    // 输出: 2
    fmt.Println(Max[float64](3.14, 2.71)) // 输出: 3.14
    fmt.Println(Max[string]("apple", "banana")) // 输出: banana
}

在这个例子中，comparable 是一个预定义的约束，表示这个类型参数需要是一个可以比较的类型，比如基本的数值类型、字符串等。

Link：https://www.cnblogs.com/farwish/p/18242833