细细探究Go泛型generic设计

2023-05-15 14:05:36 设计 探究 细细

Go 泛型

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

今天我就好好品味一下这个泛型设计,和老版本的 Go 做一个对比,并且加入类型限制的例子。

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\n",
        SumInts(ints),
        SumFloats(floats))
    fmt.Printf("Generic Sums: %v and %v\n",
        SumIntsOrFloats[string, int64](ints),
        SumIntsOrFloats[string, float64](floats))
    fmt.Printf("Generic Sums, type parameters inferred: %v and %v\n",
        SumIntsOrFloats(ints),
        SumIntsOrFloats(floats))
    fmt.Printf("Generic Sums with Constraint: %v and %v\n",
        SumNumbers(ints),
        SumNumbers(floats))
}

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

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

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

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

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

以上就是细细探究Go 泛型generic设计的详细内容,更多关于Go 泛型generic设计的资料请关注其它相关文章!

相关文章