Golang 泛型(generic)数据处理插件库使用指南

Go 1.18 引入的泛型(generic)特性极大地增强了 Go 语言处理灵活数据类型的能力。下面我将介绍如何使用 Go 泛型来处理各种数据类型。

基础泛型使用

1. 基本泛型函数

package main

import "fmt"

// 泛型函数，可以处理任意可比较类型
func Contains[T comparable](slice []T, item T) bool {
    for _, v := range slice {
        if v == item {
            return true
        }
    }
    return false
}

func main() {
    // 用于int类型
    intSlice := []int{1, 2, 3, 4, 5}
    fmt.Println(Contains(intSlice, 3)) // true
    
    // 用于string类型
    strSlice := []string{"a", "b", "c"}
    fmt.Println(Contains(strSlice, "d")) // false
}

2. 泛型结构体

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 {
    if len(s.items) == 0 {
        panic("stack is empty")
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item
}

func main() {
    intStack := Stack[int]{}
    intStack.Push(1)
    intStack.Push(2)
    fmt.Println(intStack.Pop()) // 2
    
    stringStack := Stack[string]{}
    stringStack.Push("hello")
    stringStack.Push("world")
    fmt.Println(stringStack.Pop()) // "world"
}

高级泛型应用

1. 类型约束

import "golang.org/x/exp/constraints"

// Number 约束，限制为所有数字类型
type Number interface {
    constraints.Integer | constraints.Float
}

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

func main() {
    ints := []int{1, 2, 3}
    fmt.Println(Sum(ints)) // 6
    
    floats := []float64{1.1, 2.2, 3.3}
    fmt.Println(Sum(floats)) // 6.6
}

2. 泛型Map/Filter/Reduce

// Map 对切片中的每个元素应用函数
func Map[T, U any](slice []T, f func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = f(v)
    }
    return result
}

// Filter 过滤切片元素
func Filter[T any](slice []T, f func(T) bool) []T {
    var result []T
    for _, v := range slice {
        if f(v) {
            result = append(result, v)
        }
    }
    return result
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    
    // 平方
    squares := Map(numbers, func(n int) int {
        return n * n
    })
    fmt.Println(squares) // [1 4 9 16 25]
    
    // 过滤偶数
    evens := Filter(numbers, func(n int) bool {
        return n%2 == 0
    })
    fmt.Println(evens) // [2 4]
}

实用泛型工具库

1. 通用转换函数

// ToPtr 返回值的指针
func ToPtr[T any](v T) *T {
    return &v
}

// Deref 安全解引用指针
func Deref[T any](p *T) T {
    if p == nil {
        var zero T
        return zero
    }
    return *p
}

func main() {
    num := 42
    ptr := ToPtr(num)
    fmt.Println(*ptr) // 42
    
    var nilPtr *int
    fmt.Println(Deref(nilPtr)) // 0
}

2. 通用JSON处理

import "encoding/json"

// FromJSON 泛型JSON解析
func FromJSON[T any](data []byte) (T, error) {
    var v T
    err := json.Unmarshal(data, &v)
    return v, err
}

// ToJSON 泛型JSON编码
func ToJSON[T any](v T) ([]byte, error) {
    return json.Marshal(v)
}

func main() {
    type Person struct {
        Name string `json:"name"`
        Age  int    `json:"age"`
    }
    
    jsonData := []byte(`{"name":"Alice","age":30}`)
    p, err := FromJSON[Person](jsonData)
    if err != nil {
        panic(err)
    }
    fmt.Println(p.Name) // Alice
    
    newData, err := ToJSON(p)
    fmt.Println(string(newData)) // {"name":"Alice","age":30}
}

注意事项

1. 泛型会增加编译时间，适度使用
2. 不是所有场景都需要泛型，简单场景用接口可能更合适
3. 类型约束要合理设计，避免过度约束
4. 运行时类型信息有限，无法进行反射类型检查

Go 泛型为数据处理提供了强大的工具，合理使用可以大幅减少重复代码，提高类型安全性。