Go 泛型Generics实战场景示例

// Go 1.17 及以前：不安全的通用栈
type Stack []interface{}
func (s *Stack) Push(v interface{}) {
    *s = append(*s, v)
}
func (s *Stack) Pop() interface{} {
    if len(*s) == 0 {
        panic("empty stack")
    }
    v := (*s)[len(*s)-1]
    *s = (*s)[:len(*s)-1]
    return v
}
// 使用时需类型断言，易出错
stack := Stack{}
stack.Push("hello")
v := stack.Pop().(string) // 若类型写错，运行时 panic！

// 函数泛型
func Max[T comparable](a, b T) T {
    if a > b {
        return a
    }
    return b
}
// 类型泛型
type Stack[T any] struct {
    data []T
}

// 定义数字约束
type Number interface {
    int | int32 | int64 | float32 | float64
}
func Add[T Number](a, b T) T {
    return a + b
}

type Queue[T any] struct {
    items []T
}
func (q *Queue[T]) Enqueue(item T) {
    q.items = append(q.items, item)
}
func (q *Queue[T]) Dequeue() (T, bool) {
    var zero T // 零值
    if len(q.items) == 0 {
        return zero, false
    }
    item := q.items[0]
    q.items = q.items[1:]
    return item, true
}
// 使用
intQueue := &Queue[int]{}
intQueue.Enqueue(42)
strQueue := &Queue[string]{}
strQueue.Enqueue("hello")

// 切片查找
func Find[T comparable](slice []T, target T) int {
    for i, v := range slice {
        if v == target {
            return i
        }
    }
    return -1
}
// 使用
idx := Find([]string{"a", "b", "c"}, "b") // idx = 1

type Response[T any] struct {
    Code int
    Data T
    Msg  string
}
func (r Response[T]) IsSuccess() bool {
    return r.Code == 200
}
// 使用
userResp := Response[User]{Code: 200, Data: User{Name: "Alice"}}
if userResp.IsSuccess() {
    fmt.Println(userResp.Data.Name)
}

import "golang.org/x/exp/constraints" // Go 1.18~1.21
// Go 1.22+ 直接使用 builtin
func Sort[T constraints.Ordered](slice []T) {
    // Ordered = Integer | Float | ~string
    // 支持 <, >, <=, >=
}

// 支持 String() 方法的类型
type Stringer interface {
    String() string
}
func Print[T Stringer](v T) {
    fmt.Println(v.String())
}

func bad[T any](v T) {
    switch v.(type) { // ❌ 编译错误！
    case string:
        // ...
    }
}

var _ T          // ❌ 不能直接使用类型参数 T
var _ []T        // ✅ 可以（切片、指针、chan 等复合类型可以）

type Pointer interface {
    ~*int | ~*string // 枚举常见指针类型（不通用）
}

var bufferPool = sync.Pool{
    New: func() interface{} { return new(bytes.Buffer) },
}
// 但 Pool.Get() 返回 interface{}，仍需断言
// Go 1.21+ 可封装泛型 Pool（社区方案）