Hello! 欢迎来到小浪资源网!



Go 的泛型:编写适用于多种类型的更智能的代码


Go 的泛型:编写适用于多种类型的更智能的代码

泛型即将进入 go,这是一件大事。我一直在深入研究 go 2 的拟议更改,并且很高兴分享我对这一强大新功能的了解。

从本质上讲,泛型允许我们编写适用于多种类型的代码。我们可以编写一个通用函数来处理所有这些类型,而不是为整数、字符串和自定义类型编写单独的函数。这会带来更灵活和可重用的代码。

让我们从一个基本示例开始。以下是我们编写通用“max”函数的方法:

func max[t constraints.ordered](a, b t) t {     if a > b {         return a     }     return b } 

此函数适用于任何满足 ordered 约束的类型 t。我们可以将它与整数、浮点数、字符串或任何实现比较运算符的自定义类型一起使用。

类型约束是 go 泛型实现的关键部分。它们允许我们指定泛型类型必须支持哪些操作。约束包提供了几个预定义的约束,但我们也可以创建自己的约束。

例如,我们可以为可以转换为字符串的类型定义一个约束:

type stringer interface {     string() string } 

现在我们可以编写适用于任何可以转换为字符串的类型的函数:

func printanything[t stringer](value t) {     fmt.println(value.string()) } 

go 泛型最酷的事情之一就是类型推断。很多情况下,我们在调用泛型函数时不需要显式指定类型参数。编译器可以计算出来:

result := max(5, 10) // type inferred as int 

这使我们的代码保持干净和可读,同时仍然提供泛型的好处。

让我们进入一些更高级的领域。类型参数列表允许我们指定多个类型参数之间的关系。以下是在两种类型之间进行转换的函数示例:

func convert[from, to any](value from, converter func(from) to) to {     return converter(value) } 

这个函数接受任何类型的值,一个转换器函数,并返回转换后的值。它非常灵活,可以在许多不同的场景中使用。

泛型在数据结构方面确实很出色。让我们实现一个简单的通用

type stack[t any] struct {     items []t }  func (s *stack[t]) push(item t) {     s.items = append(s.items, item) }  func (s *stack[t]) pop() (t, bool) {     if len(s.items) == 0 {         var zero t         return zero, false     }     item := s.items[len(s.items)-1]     s.items = s.items[:len(s.items)-1]     return item, true } 

这个可以容纳任何类型的物品。我们可以使用相同的代码创建整数、字符串或自定义结构的堆栈。

泛型还为 go 中的设计模式开辟了新的可能性。例如,我们可以实现一个通用的观察者模式:

type observable[t any] struct {     observers []func(t) }  func (o *observable[t]) subscribe(f func(t)) {     o.observers = append(o.observers, f) }  func (o *observable[t]) notify(data t) {     for _, f := range o.observers {         f(data)     } } 

这使我们能够为任何类型的数据创建可观察的对象,从而轻松实现事件驱动的架构

重构现有 go 代码以使用泛型时,保持平衡很重要。虽然泛型可以使我们的代码更加灵活和可重用,但它们也可以使其变得更加复杂和难以理解。我发现通常最好从具体实现开始,只有当我们看到清晰的重复模式时才引入泛型。

例如,如果我们发现自己为不同类型编写类似的函数,那么这是泛化的一个很好的候选者。但如果一个函数仅用于一种类型,最好保持原样。

泛型真正发挥作用的一个领域是实现算法。让我们看一下通用的快速排序实现:

func quicksort[t constraints.ordered](slice []t) {     if len(slice) < 2 {         return     }     pivot := slice[0]     left, right := 1, len(slice)-1     for left <= right {         if slice[left] <= pivot {             left++         } else if slice[right] > pivot {             right--         } else {             slice[left], slice[right] = slice[right], slice[left]         }     }     slice[0], slice[right] = slice[right], slice[0]     quicksort(slice[:right])     quicksort(slice[right+1:]) } 

该函数可以对任何有序类型的切片进行排序。我们可以使用它对整数、浮点数、字符串或任何实现比较运算符的自定义类型进行排序。

在大型项目中使用泛型时,考虑灵活性和编译时类型检查之间的权衡至关重要。虽然泛型允许我们编写更灵活的代码,但如果我们不小心,它们也可能更容易引入运行时错误。

我发现有用的一个策略是对内部库代码使用泛型,但在公共 api 中公开具体类型。这为我们带来了内部代码重用的好处,同时仍然为我们库的用户提供了清晰的、类型安全的界面。

另一个重要的考虑因素是性能。虽然 go 的泛型实现被设计得非常高效,但与具体类型相比,仍然存在一些运行时开销。在性能关键型代码中,可能值得对通用实现与非通用实现进行基准测试,看看是否存在显着差异。

泛型还为 go 中的元编程开辟了新的可能性。我们可以编写对类型本身进行操作的函数,而不是对值进行操作。例如,我们可以编写一个在运行时生成新结构类型的函数:

func MakeStruct[T any](fields ...string) (reflect.Type, error) {     var structFields []reflect.StructField     for _, field := range fields {         structFields = append(structFields, reflect.StructField{             Name: field,             Type: reflect.TypeOf((*T)(nil)).Elem(),         })     }     return reflect.StructOf(structFields), nil } 

该函数创建一个新的结构类型,其中字段类型为 t。它是在运行时创建动态数据结构的强大工具。

在我们结束时,值得注意的是,虽然泛型是一个强大的功能,但它们并不总是最好的解决方案。有时,简单的接口或具体的类型更合适。关键是明智地使用泛型,它们在代码重用和类型安全方面提供了明显的好处。

go 2 中的泛型代表了该语言的重大演变。它们提供了新的工具来编写灵活、可重用的代码,同时保持 go 对简单性和可读性的重视。随着我们继续探索和试验此功能,我很高兴看到它将如何塑造 go 编程的未来。


我们的创作

一定要看看我们的创作:

投资者中心 | 智能生活 | 时代与回声 | 令人费解的谜团 | 印度教 | 精英开发 | JS学校


我们在媒体上

科技考拉洞察 | 时代与回响世界 | 投资者中央媒体 | 令人费解的谜团 | 科学与时代媒介 | 现代印度教

相关阅读