«

Go泛型generic设计源码分析

时间:2024-7-7 08:59     作者:韩俊     分类: Go语言


这篇文章主要讲解了“Go泛型generic设计源码分析”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Go泛型generic设计源码分析”吧!

Go 泛型

的设计融入了现代语言的风格,比如类型限制(type constraint),我们在 TypeScript 和 Python 也能看到这个特性。

demo

直接进入正题:

package main
import "fmt"
// 代码中首先定义了一个接口类型 `Number`,
// 它包含了两个类型:`int64` 和 `float64`。
// 这个接口类型可以被用来限制泛型函数的类型参数范围。
type Number interface {
    int64 | float64
}
// 定义了两个非泛型函数 `SumInts` 和 `SumFloats`,
// 它们分别用于计算 `int64` 类型和 `float64` 类型的 map 中所有值的总和。
// SumInts adds together the values of m.
func SumInts(m map[string]int64) int64 {
    var s int64
    for _, v := range m {
        s += v
    }
    return s
}
// SumFloats adds together the values of m.
func SumFloats(m map[string]float64) float64 {
    var s float64
    for _, v := range m {
        s += v
    }
    return s
}
// 定义了一个泛型函数 `SumIntsOrFloats`,它接受一个类型为 `map[K]V` 的 map,并返回这个 map 中所有值的总和。
// 这个函数使用了两个类型参数 `K` 和 `V`,其中 `V` 的类型可以是 `int64` 或 `float64` 中的一个。
// 函数中使用了 `for range` 语句来遍历 map 中的值并计算它们的总和,最终返回这个总和。
// SumIntsOrFloats sums the values of map m. It supports both floats and integers
// as map values.
func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
    var s V
    for _, v := range m {
        s += v
    }
    return s
}
// `SumNumbers`,它的类型参数 `V` 必须实现 `Number` 接口类型。
// 这个函数和 `SumIntsOrFloats` 函数类似,不同之处在于它使用了 `Number` 接口类型来限制 `V` 的取值范围
// 只有实现了 `Number` 接口类型的类型才能作为 `V` 的值类型。
// SumNumbers sums the values of map m. Its supports both integers
// and floats as map values.
func SumNumbers[K comparable, V Number](m map[K]V) V {
    var s V
    for _, v := range m {
        s += v
    }
    return s
}
func main() {
    // Initialize a map for the integer values
    ints := map[string]int64{
        "first": 34,
        "second": 12,
    }
    // Initialize a map for the float values
    floats := map[string]float64{
        "first": 35.98,
        "second": 26.99,
    }
    fmt.Printf("Non-Generic Sums: %v and %v
",
        SumInts(ints),
        SumFloats(floats))
    fmt.Printf("Generic Sums: %v and %v
",
        SumIntsOrFloats[string, int64](ints),
        SumIntsOrFloats[string, float64](floats))
    fmt.Printf("Generic Sums, type parameters inferred: %v and %v
",
        SumIntsOrFloats(ints),
        SumIntsOrFloats(floats))
    fmt.Printf("Generic Sums with Constraint: %v and %v
",
        SumNumbers(ints),
        SumNumbers(floats))
}

main
函数中,代码初始化了两个 map,分别用于存储
int64
类型和
float64
类型的值。接着,代码使用非泛型的
SumInts
SumFloats
函数来计算这两个 map 中所有值的总和,并打印出结果。然后,代码使用泛型的
SumIntsOrFloats
函数来计算这两个 map 中所有值的总和,并打印出结果。最后,代码使用带有类型约束的泛型函数
SumNumbers
来计算这两个 map 中所有值的总和,并打印出结果。

这段代码演示了 Go 语言中泛型的应用,通过这个例子,我们可以更好地理解 Go 语言中的泛型功能。

如果不用泛型,我们可能要进行多次复制粘贴,代码不易维护。

如果不用类型限制,一旦加入一个类型,原有模块也不易维护。

我们用类型限制,也就是所谓的 type contract 达成一种共识,大家一眼便知,这个和 interface 代表的接口特性是一个道理。

标签: golang

热门推荐