一文彻底掌握Go语言泛型的使用及应用

package main
import "fmt"
// 定义泛型函数，支持int和float64类型
func Sum[T int | float64](a, b T) T {
    return a + b
}
func main() {
    fmt.Println(Sum(1, 2))       // 输出: 3
    fmt.Println(Sum(1.5, 2.5))  // 输出: 4.0
}

package main

import "fmt"

// 定义一个泛型函数，T是类型参数
func PrintSlice[T any](s []T) {
    for _, v := range s {
        fmt.Printf("%v ", v)
    }
    fmt.Println()
}

func main() {
    // 使用int切片
    PrintSlice[int]([]int{1, 2, 3})
    
    // 使用string切片（类型参数可以省略，编译器可以推断）
    PrintSlice([]string{"a", "b", "c"})
}

package main
import "fmt"
// 定义泛型结构体
type Box[T any] struct {
    Value T
}
func main() {
    intBox := Box[int]{Value: 42}
    strBox := Box[string]{Value: "Hello"}
    fmt.Println(intBox.Value)  // 输出: 42
    fmt.Println(strBox.Value)  // 输出: Hello
}

package main

import "fmt"

// 定义一个泛型栈类型
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
}

package main
import "fmt"
// 查找切片中的最大值
func Max[T int | float64](slice []T) T {
    if len(slice) == 0 {
        var zero T
        return zero
    }
    max := slice[0]
    for _, v := range slice[1:] {
        if v > max {
            max = v
        }
    }
    return max
}
func main() {
    intSlice := []int{1, 2, 3, 4}
    floatSlice := []float64{1.1, 2.2, 3.3}
    fmt.Println(Max(intSlice))    // 输出: 4
    fmt.Println(Max(floatSlice))  // 输出: 3.3
}

package main
import "fmt"
// 定义泛型队列
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) {
    if len(q.items) == 0 {
        var zero T
        return zero, false
    }
    item := q.items[0]
    q.items = q.items[1:]
    return item, true
}
func main() {
    queue := Queue[int]{}
    queue.Enqueue(1)
    queue.Enqueue(2)
    item, ok := queue.Dequeue()
    if ok {
        fmt.Println(item)  // 输出: 1
    }
}

type Repository[T any] interface {
    GetByID(id int) (*T, error)
    Create(entity *T) error
    Update(entity *T) error
    Delete(id int) error
}

type GormRepository[T any] struct {
    db *gorm.DB
}

func (r *GormRepository[T]) GetByID(id int) (*T, error) {
    var entity T
    err := r.db.First(&entity, id).Error
    if err != nil {
        return nil, err
    }
    return &entity, nil
}

// 其他方法实现...

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

// 检查元素是否存在
func Contains[T comparable](slice []T, target T) bool {
    for _, item := range slice {
        if item == target {
            return true
        }
    }
    return false
}

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    even := Filter(numbers, func(n int) bool {
        return n%2 == 0
    })
    fmt.Println(even) // [2 4 6]
    
    fmt.Println(Contains(numbers, 3)) // true
    fmt.Println(Contains(numbers, 7)) // false
}