Go 泛型学习链路图

// Ptr 返回值的指针，常用于需要指针类型的 API（如 AWS SDK、Kubernetes CRD）
func Ptr[T any](value T) *T {
    return &value
}
 
// Value 返回指针的值，如果为 nil 则返回零值
func Value[T any](ptr *T) T {
    if ptr == nil {
        var zero T
        return zero
    }
    return *ptr
}
 
// Zero 返回类型 T 的零值
func Zero[T any]() T {
    var zero T
    return zero
}
 
// 使用示例
type Config struct {
    Host *string
    Port *int
    Timeout *time.Duration
}
 
func NewConfig() *Config {
    return &Config{
        Host:    Ptr("localhost"),
        Port:    Ptr(8080),
        Timeout: Ptr(30 * time.Second),
    }
}

// Numeric 约束：支持所有数值类型
type Numeric interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
    ~float32 | ~float64
}
 
// Sum 计算数值切片的总和
func Sum[T Numeric](values ...T) T {
    var sum T
    for _, v := range values {
        sum += v
    }
    return sum
}
 
// Max 返回两个值中的较大者
func Max[T Numeric](a, b T) T {
    if a > b {
        return a
    }
    return b
}
 
// Contains 检查切片是否包含指定值
func Contains[T comparable](slice []T, value T) bool {
    for _, v := range slice {
        if v == value {
            return true
        }
    }
    return false
}
 
// Map 将切片中的每个元素通过函数转换
func Map[T, U any](slice []T, fn func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}
 
// Filter 过滤切片，保留满足条件的元素
func Filter[T any](slice []T, fn func(T) bool) []T {
    var result []T
    for _, v := range slice {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}
 
// 使用示例
func Example() {
    // 数值计算
    sum := Sum(1, 2, 3, 4, 5)  // 15
    max := Max(10.5, 20.3)     // 20.3
    
    // 切片操作
    numbers := []int{1, 2, 3, 4, 5}
    doubled := Map(numbers, func(n int) int { return n * 2 })  // [2, 4, 6, 8, 10]
    evens := Filter(numbers, func(n int) bool { return n%2 == 0 })  // [2, 4]
    
    // 字符串切片
    names := []string{"alice", "bob", "charlie"}
    found := Contains(names, "bob")  // true
}

// Stack 泛型栈实现
type Stack[T any] struct {
    items []T
}
 
func NewStack[T any]() *Stack[T] {
    return &Stack[T]{items: make([]T, 0)}
}
 
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
}
 
func (s *Stack[T]) Peek() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    return s.items[len(s.items)-1], true
}
 
// Queue 泛型队列实现
type Queue[T any] struct {
    items []T
}
 
func NewQueue[T any]() *Queue[T] {
    return &Queue[T]{items: make([]T, 0)}
}
 
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
}
 
// Set 泛型集合实现（基于 map）
type Set[T comparable] struct {
    items map[T]struct{}
}
 
func NewSet[T comparable](items ...T) *Set[T] {
    s := &Set[T]{items: make(map[T]struct{})}
    for _, item := range items {
        s.items[item] = struct{}{}
    }
    return s
}
 
func (s *Set[T]) Add(item T) {
    s.items[item] = struct{}{}
}
 
func (s *Set[T]) Remove(item T) {
    delete(s.items, item)
}
 
func (s *Set[T]) Contains(item T) bool {
    _, exists := s.items[item]
    return exists
}
 
// 使用示例
func Example() {
    // 栈操作
    stack := NewStack[int]()
    stack.Push(1)
    stack.Push(2)
    val, _ := stack.Pop()  // 2
    
    // 队列操作
    queue := NewQueue[string]()
    queue.Enqueue("first")
    queue.Enqueue("second")
    item, _ := queue.Dequeue()  // "first"
    
    // 集合操作
    set := NewSet(1, 2, 3)
    set.Add(4)
    exists := set.Contains(2)  // true
}

// 类型安全的运行时检查示例
// Go 泛型在编译时和运行时都保持类型安全
 
// 类型断言辅助函数
func TypeAssert[T any](v interface{}) (T, bool) {
    t, ok := v.(T)
    return t, ok
}
 
// 类型安全的转换
func SafeConvert[T, U any](value T, converter func(T) U) U {
    return converter(value)
}
 
// 使用示例：展示运行时类型安全
func Example() {
    var x interface{} = 42
    
    // 类型安全的断言
    if val, ok := TypeAssert[int](x); ok {
        fmt.Println("是 int 类型:", val)
    }
    
    // 类型安全的转换
    str := SafeConvert(123, func(n int) string {
        return strconv.Itoa(n)
    })
    // str = "123"
}

// 高性能的泛型列表（避免装箱）
type FastList[T any] struct {
    items []T
}
 
func NewFastList[T any](capacity int) *FastList[T] {
    return &FastList[T]{
        items: make([]T, 0, capacity),
    }
}
 
func (l *FastList[T]) Add(item T) {
    l.items = append(l.items, item)
}
 
func (l *FastList[T]) Get(index int) (T, bool) {
    if index < 0 || index >= len(l.items) {
        var zero T
        return zero, false
    }
    return l.items[index], true
}
 
// 性能对比：泛型 vs interface{}
// 泛型版本（无装箱）：
type GenericList[T any] []T
 
// 装箱版本（性能较差）：
type BoxedList []interface{}
 
// 使用示例
func Example() {
    // 泛型版本：无装箱，性能好
    intList := NewFastList[int](100)
    for i := 0; i < 1000; i++ {
        intList.Add(i)
    }
    
    // 装箱版本：有装箱开销，性能差
    boxedList := make([]interface{}, 0, 100)
    for i := 0; i < 1000; i++ {
        boxedList = append(boxedList, i)  // 装箱发生在这里
    }
}

// 1. 容器模式 - 最适合泛型 ✅
type Container[T any] struct {
    items []T
    mu    sync.RWMutex
}
 
func NewContainer[T any]() *Container[T] {
    return &Container[T]{items: make([]T, 0)}
}
 
func (c *Container[T]) Add(item T) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items = append(c.items, item)
}
 
func (c *Container[T]) GetAll() []T {
    c.mu.RLock()
    defer c.mu.RUnlock()
    result := make([]T, len(c.items))
    copy(result, c.items)
    return result
}
 
// 2. 类型安全的缓存 ✅
type Cache[K comparable, V any] struct {
    data map[K]V
    mu   sync.RWMutex
}
 
func NewCache[K comparable, V any]() *Cache[K, V] {
    return &Cache[K, V]{data: make(map[K]V)}
}
 
func (c *Cache[K, V]) Get(key K) (V, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    val, ok := c.data[key]
    return val, ok
}
 
func (c *Cache[K, V]) Set(key K, value V) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = value
}
 
// 3. 配置管理 ✅
type Config[T any] struct {
    value T
    mu    sync.RWMutex
}
 
func NewConfig[T any](defaultValue T) *Config[T] {
    return &Config[T]{value: defaultValue}
}
 
func (c *Config[T]) Get() T {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.value
}
 
func (c *Config[T]) Set(value T) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value = value
}
 
// 使用示例
func Example() {
    // 容器模式
    container := NewContainer[string]()
    container.Add("item1")
    container.Add("item2")
    
    // 类型安全的缓存
    cache := NewCache[string, int]()
    cache.Set("count", 42)
    val, _ := cache.Get("count")  // 42, 类型安全
    
    // 配置管理
    config := NewConfig(8080)
    port := config.Get()  // 8080
    config.Set(9090)
}