到目前為止，使用 Go 泛型的場景有哪些？

作者：磊豐 2025-08-07 01:22:00

Go 泛型并非萬能藥，它無法替代傳統的接口和類型斷言，但它在處理類型不確定但邏輯相同的場景時表現出色。掌握以上 6 個泛型應用場景，能幫助你編寫出更 DRY（Don't Repeat Yourself）、更具類型安全和可維護性的 Go 代碼。

Go 1.18 引入的泛型（Generics）是一個重要特性，旨在減少重復代碼、提升代碼復用性。

對于 Go 開發者而言，理解泛型適用的場景，并將其恰當地應用到日常開發中，是提升代碼質量和生產力的關鍵。

本文將總結 Go 泛型在實際項目中最常見的應用場景，幫助你更好地利用這個強大的工具。

1. 實現通用數據結構

在沒有泛型之前，如果我們需要實現一個通用的數據結構（如棧、隊列、鏈表），通常只能依賴 interface{} 類型。

這不僅會帶來額外的裝箱/拆箱開銷，還會失去類型安全，需要在運行時進行類型斷言，增加了出錯的風險。

有了泛型，我們可以輕松創建類型安全、性能優越的通用數據結構。

示例：泛型棧（Stack）

package main

import"fmt"

// Stack 是一個泛型棧，可以存儲任何類型 T 的元素
type Stack[T any]struct{
    elements []T
}

// Push 方法將一個元素推入棧中
func(s *Stack[T])Push(elem T){
    s.elements =append(s.elements, elem)
}

// Pop 方法從棧中彈出一個元素
func(s *Stack[T])Pop()(T,bool){
iflen(s.elements)==0{
var zero T
return zero,false
}
    lastIndex :=len(s.elements)-1
    elem := s.elements[lastIndex]
    s.elements = s.elements[:lastIndex]
return elem,true
}

funcmain(){
// 創建一個存儲 int 類型的棧
    intStack := Stack[int]{}
    intStack.Push(10)
    intStack.Push(20)

// 創建一個存儲 string 類型的棧
    stringStack := Stack[string]{}
    stringStack.Push("Hello")
    stringStack.Push("World")

if elem, ok := intStack.Pop(); ok {
        fmt.Println("從 int 棧中彈出:", elem)// 輸出: 20
}
if elem, ok := stringStack.Pop(); ok {
        fmt.Println("從 string 棧中彈出:", elem)// 輸出: World
}
}

2. 編寫通用算法和函數

許多算法（如查找、排序、過濾等）的邏輯并不依賴于數據的具體類型，而是在不同類型上重復實現。泛型讓我們可以編寫一次，到處復用。

示例：泛型查找函數

package main

import"fmt"

// FindIndex 查找切片中第一個符合條件的元素的索引
func FindIndex[T any](slice []T, predicate func(T)bool)int{
for i, item :=range slice {
ifpredicate(item){
return i
}
}
return-1
}

funcmain(){
    numbers :=[]int{1,2,3,4,5}
    index :=FindIndex(numbers,func(n int)bool{
return n ==3
})
    fmt.Println("元素 3 的索引是:", index)// 輸出: 2

    strings :=[]string{"apple","banana","orange"}
    index =FindIndex(strings,func(s string)bool{
returnlen(s)>6
})
    fmt.Println("長度大于 6 的字符串索引是:", index)// 輸出: 1
}

擴展思考： 你還可以用泛型實現 Map、Filter、Reduce 等常見的高階函數，極大地簡化切片操作。

3. 通用 HTTP 響應與請求處理

在 Web 開發中，我們經常需要處理結構相似但數據類型不同的 JSON 響應。例如，一個 API 響應可能包含一個通用的狀態碼和消息，但其數據載荷 Data 部分的類型各不相同。

泛型可以幫助我們創建統一的響應結構，并在處理不同的業務數據時保持類型安全。

示例：泛型 API 響應結構

package main

import"fmt"

// APIResponse 泛型響應結構，Data 的類型可以由使用者指定
type APIResponse[T any]struct{
    Code    int`json:"code"`
    Message string`json:"message"`
    Data    T      `json:"data"`
}

type User struct{
    ID   int`json:"id"`
    Name string`json:"name"`
}

type Product struct{
    ID    int`json:"id"`
    Name  string`json:"name"`
    Price int`json:"price"`
}

funcmain(){
// 假設這是獲取用戶信息的響應
    userResponse := APIResponse[User]{
        Code:200,
        Message:"Success",
        Data:    User{ID:1, Name:"張三"},
}
    fmt.Printf("用戶數據: %+v\n", userResponse.Data)

// 假設這是獲取商品信息的響應
    productResponse := APIResponse[Product]{
        Code:200,
        Message:"Success",
        Data:    Product{ID:101, Name:"手機", Price:5999},
}
    fmt.Printf("商品數據: %+v\n", productResponse.Data)
}

通過泛型，我們無需為每個不同的業務模型都創建一個單獨的響應結構，從而減少了大量的冗余代碼。

4. 優化 Go 語言的錯誤處理

Go 的錯誤處理通常依賴于 if err != nil，而泛型則為我們提供了一種新的處理模式，特別是在處理可能失敗的函數時。

示例：泛型 `Result` 類型

Result 類型可以封裝一個操作的成功結果或錯誤，強制調用者在編譯時處理兩種情況。

package main

import"fmt"

// Result 泛型類型，封裝成功值和錯誤
type Result[T any]struct{
    Value T
    Err   error
}

// NewResult 創建一個成功的 Result
func NewResult[T any](value T) Result[T]{
return Result[T]{Value: value}
}

// NewErrorResult 創建一個失敗的 Result
func NewErrorResult[T any](err error) Result[T]{
var zero T
return Result[T]{Value: zero, Err: err}
}

funcGetUserByID(id int) Result[string]{
if id >0{
returnNewResult(fmt.Sprintf("用戶ID: %d", id))
}
return NewErrorResult[string](fmt.Errorf("無效的用戶ID"))
}

funcmain(){
    res :=GetUserByID(1)
if res.Err !=nil{
        fmt.Println("獲取用戶失敗:", res.Err)
}else{
        fmt.Println("獲取用戶成功:", res.Value)
}
}

5. 實現類型安全的并發原語

在沒有泛型時，Go 標準庫中的 sync.Pool 等并發原語只能存儲 interface{} 類型。泛型使我們能夠構建類型安全的并發工具。

示例：泛型緩存池

package main

import(
"fmt"
"sync"
)

// ObjectPool 泛型對象池
type ObjectPool[T any]struct{
    pool sync.Pool
}

func NewObjectPool[T any](newFunc func() T)*ObjectPool[T]{
return&ObjectPool[T]{
        pool: sync.Pool{
            New:func() any {
returnnewFunc()
},
},
}
}

func(p *ObjectPool[T])Get() T {
return p.pool.Get().(T)
}

func(p *ObjectPool[T])Put(x T){
    p.pool.Put(x)
}

funcmain(){
    stringPool :=NewObjectPool(func()*string{
        s :="default"
return&s
})

    s1 := stringPool.Get()
*s1 ="hello"
    fmt.Println("從池中獲取:",*s1)
    stringPool.Put(s1)

    s2 := stringPool.Get()
    fmt.Println("再次從池中獲取:",*s2)// 可能會輸出 "hello" 或 "default"，取決于 sync.Pool 的實現
}

6. 約束接口中的方法簽名

泛型也為接口提供了更強的約束能力。例如，我們可以定義一個接口，要求其實現者必須擁有一個返回自身類型的方法。

示例：泛型接口

package main

import"fmt"

// Sizer 泛型接口，要求實現者必須擁有 Size 方法
type Sizer[T any]interface{
Size() T
}

// MyInt 實現了 Sizer 接口，其 Size 方法返回 int 類型
type MyInt int
func(i MyInt)Size()int{
returnint(i)
}

// MyFloat32 實現了 Sizer 接口，其 Size 方法返回 float32 類型
type MyFloat32 float32
func(f MyFloat32)Size()float32{
return f
}

// GetSize 函數可以處理任何實現了 Sizer 接口的類型
func GetSize[T any, S Sizer[T]](s S) T {
return s.Size()
}

funcmain(){
var i MyInt =10
var f MyFloat32 =20.5

    fmt.Println("MyInt 的 Size:",GetSize(i))
    fmt.Println("MyFloat32 的 Size:",GetSize(f))
}

總結

Go 泛型并非萬能藥，它無法替代傳統的接口和類型斷言，但它在處理類型不確定但邏輯相同的場景時表現出色。

掌握以上 6 個泛型應用場景，能幫助你編寫出更 DRY（Don't Repeat Yourself）、更具類型安全和可維護性的 Go 代碼。

責任編輯：武曉燕來源： GO語言圈

Go 泛型場景