Golang泛型编程入门教程

Golang泛型编程入门教程中提到的类型参数约束在实际项目中应该如何应用？我按照教程示例写了个简单demo，但遇到类型断言失败的问题，想请教下具体应该如何处理？另外泛型函数和interface{}的性能差异有多大，在哪些场景下更适合使用泛型？教程最后提到的类型集概念感觉有点抽象，能否举个更具体的例子说明？

3 回复

Go 1.18 引入了泛型支持，以下是一个简单的入门教程：

  1. 基本语法
    泛型函数使用 func[类型参数] 定义，例如：

    func Add[T int | float64](a, b T) T {
    return a + b
}

    这里定义了一个接受 int 或 float64 的函数。

  2. 泛型结构体
    泛型也可以用于结构体：

    type Pair[T any] struct {
    First T
    Second T
}

  3. 约束
    使用 any 表示无约束，或自定义约束。例如限制类型为可比较：

    type Less interface {
    ~int | ~float64
}
func Max[T Less](a, b T) T {
    if a > b {
        return a
    }
    return b
}

  4. 实战案例
    实现一个栈（Stack）：

    type Stack[T any] struct {
    items []T
}
func (s *Stack[T]) Push(v T) {
    s.items = append(s.items, v)
}
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
}

泛型让代码更灵活、复用性更高，但也需注意性能和复杂度的平衡。

更多关于Golang泛型编程入门教程的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


作为屌丝程序员，我来简单介绍下Go泛型。Go 1.18引入了泛型，使用type关键字定义参数化类型。比如：

func Add[T int | float64](a, b T) T {
    return a + b
}

var sum = Add[int](10, 20)

泛型适用于集合操作、数据结构等场景。注意以下几点：

  1. 类型约束：可以用any或接口约束类型，如interface{}。
  2. 方法重载：Go不支持传统意义上的方法重载。
  3. 性能：泛型实例会被编译成具体类型代码，不会带来运行时开销。

写泛型时保持简洁，避免过度复杂化。推荐从常用的数据结构开始实践，比如链表、栈等。记住，泛型是工具，不是目的，学会适时使用才是关键。

Golang泛型编程入门指南

Go语言在1.18版本正式引入了泛型(Generics)特性，下面介绍基本概念和用法：

基本语法

// 定义泛型函数
func PrintSlice[T any](s []T) {
    for _, v := range s {
        fmt.Println(v)
    }
}

// 定义泛型结构体
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

类型约束

可以使用接口约束泛型类型：

type Number interface {
    int | float64
}

func Sum[T Number](nums []T) T {
    var sum T
    for _, num := range nums {
        sum += num
    }
    return sum
}

常见使用场景

  1. 容器类型：实现通用的栈、队列等数据结构
  2. 算法抽象：编写通用的排序、搜索等算法
  3. 类型安全：避免interface{}的类型断言

注意事项

  • 泛型会稍微增加编译时间
  • 目前不支持泛型方法(只能有泛型结构体方法)
  • 类型推断有时需要明确指定类型参数

示例：通用Map函数

func Map[T1, T2 any](s []T1, f func(T1) T2) []T2 {
    result := make([]T2, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

// 使用
strings := []string{"a", "b", "c"}
lengths := Map(strings, func(s string) int {
    return len(s)
})

Go泛型设计相对保守，但已能满足基本需求。如需更复杂特性，可能需要通过接口等方式补充实现。

回到顶部