Go泛型從1.18開始支持，用於編寫類型安全的通用代碼。 1. 泛型函數PrintSlice[T any](s []T)可打印任意類型切片，如[]int或[]string。 2. 通過類型約束Number限制T為int、float等數字類型，實現Sum[T Number](slice []T) T安全求和。 3. 泛型結構體type Box[T any] struct { Value T }可封裝任意類型值，配合NewBox[T any](v T) *Box[T]構造函數使用。 4. 為Box[T]添加Set(v T)和Get() T方法，無需在方法中重複聲明[T]。 5. 多類型參數函數ContainsValue[K comparable, V any](m map[K]V, value V) bool判斷map中是否存在某值，K需可比較。 6. 實際應用如通用緩存type Cache[K comparable, V any] struct { data map[K]V }，提供Set、Get操作，實現類型安全的鍵值存儲。泛型通過類型參數、約束、聯合類型提升代碼復用性與安全性，語法簡潔實用。

Go 的泛型（Generics）從Go 1.18 開始正式支持，它允許你編寫可以處理多種類型的通用函數和數據結構。下面通過幾個典型的Go 泛型示例，幫你快速理解如何在實際中使用泛型。

? 1. 泛型函數： PrintSlice[T any]

你想打印任意類型的切片內容，比如[]int 、 []string ，可以寫一個泛型函數：

 func PrintSlice[T any](s []T) {
    for _, v := range s {
        fmt.Print(v, " ")
    }
    fmt.Println()
}

// 使用示例PrintSlice([]int{1, 2, 3}) // 輸出: 1 2 3
PrintSlice([]string{"a", "b"}) // 輸出: ab

• [T any]表示類型參數T可以是任意類型。
• any是interface{}的別名，表示無約束。

? 2. 泛型函數：帶類型約束（Constraint）

如果你想對類型做限制，比如只允許數字類型，可以定義約束：

 type Number interface {
    int | int32 | int64 | float32 | float64
}

func Sum[T Number](slice []T) T {
    var total T
    for _, v := range slice {
        total = v
    }
    return total
}

// 使用fmt.Println(Sum([]int{1, 2, 3})) // 6
fmt.Println(Sum([]float64{1.1, 2.2})) // 3.3

• Number是一個接口類型，用|表示聯合類型（union），限制T必須是列出的類型之一。
• 這樣可以防止你傳入string或struct等不支持 操作的類型。

? 3. 泛型結構體

定義一個通用的Box容器，可以裝任何類型的值：

 type Box[T any] struct {
    Value T
}

func NewBox[T any](v T) *Box[T] {
    return &Box[T]{Value: v}
}

// 使用intBox := NewBox(42)
strBox := NewBox("hello")

fmt.Println(intBox.Value) // 42
fmt.Println(strBox.Value) // hello

• Box[T]是一個泛型結構體。
• NewBox是泛型構造函數，自動推導類型。

? 4. 泛型方法

為泛型結構體添加方法：

 func (b *Box[T]) Set(v T) {
    b.Value = v
}

func (b *Box[T]) Get() T {
    return b.Value
}

// 使用box := NewBox(100)
box.Set(200)
fmt.Println(box.Get()) // 200

方法本身不需要聲明[T] ，因為已經屬於Box[T]類型。

? 5. 泛型與Map：查找鍵值

寫一個通用函數，在map 中查找是否存在某個值：

 func ContainsValue[K comparable, V any](m map[K]V, value V) bool {
    for _, v := range m {
        if v == value {
            return true
        }
    }
    return false
}

// 使用m := map[string]int{"a": 1, "b": 2}
fmt.Println(ContainsValue(m, 2)) // true
fmt.Println(ContainsValue(m, 3)) // false

• K comparable ：鍵類型必須是可比較的（如string、int、struct 等）。
• V any ：值可以是任意類型。
• 多個類型參數用逗號分隔。

? 6. 實際應用場景：通用緩存

你可以用泛型實現一個簡單的緩存結構：

 type Cache[K comparable, V any] struct {
    data map[K]V
}

func NewCache[K comparable, V any]() *Cache[K, V] {
    return &Cache[K, V]{
        data: make(map[K]V),
    }
}

func (c *Cache[K, V]) Set(key K, value V) {
    c.data[key] = value
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
    v, ok := c.data[key]
    return v, ok
}

使用：

 cache := NewCache[string, int]()
cache.Set("users", 100)
if val, ok := cache.Get("users"); ok {
    fmt.Println("Count:", val)
}

小結：泛型的關鍵點

• 使用[T any]或[T Constraint]定義類型參數。
• comparable是預定義約束，用於可比較的類型（用於map key、== 判斷等）。
• 聯合類型（ | ）可以限制類型集合。
• 泛型讓函數和結構體更通用、類型安全、減少重複代碼。

基本上就這些。 Go 泛型不追求復雜，而是強調實用和清晰。剛開始用會覺得語法有點新，但寫幾個例子後就會覺得挺自然。

以上是以身作則的詳細內容。更多資訊請關注PHP中文網其他相關文章！