一、引言

泛型編程在許多編程語言中都是一項非常強大的特性，它可以使程序更加通用、具有更高的重用性。然而，Go語言在很長一段時間內一直沒有提供泛型功能。在過去的一些版本中，Go語言開發者試圖引入泛型，但最終都因為各種原因被取消或擱置了。直到Go 1.18版本，終于引入了泛型功能。在本文中，將會介紹這項新特性及其使用方法。

二、什么是泛型？

泛型是一種編程語言的特性，它可以將類型參數化，并以類型參數形式傳遞到不同的算法和數據結構中。泛型使得程序可以更加通用、安全且具有更高的重用性。不同的類型參數可以通過參數化類型類型來表示。例如，在Java中，可以使用ArrayList<Integer>來表示包含整數的動態數組，其中Integer是類型參數的類型。

在Go語言中，泛型的類型參數可以是任何類型，包括基本類型、引用類型、結構體和接口等。這些類型參數可以用在函數、方法、結構體、接口、通道和映射等語法結構中。

三、得一切從函數的形參和實參說起

當談到泛型編程時，我們需要了解兩個重要的概念：類型形參和類型實參。

• 類型形參（Type Parameters）：類型形參是一種在泛型代碼中使用的占位符類型。它們允許我們定義函數、方法或數據結構，這些代碼可以處理多種類型的數據而不是特定的類型。在 Go 語言中，類型形參使用方括號 [] 包圍，并且可以在函數、方法或結構體的名稱后面定義。例如，func Test[T any](x T) 中的 [T any] 就是一個類型形參。在使用泛型函數或結構體時，我們需要提供實際的類型實參來替換類型形參的位置。
• 類型實參（Type Arguments）：類型實參是在使用泛型代碼時提供的具體類型。當我們調用泛型函數或實例化泛型結構體時，我們需要指定具體的類型實參，以替換泛型代碼中的類型形參。類型實參可以是任何合法的類型，包括基本類型、結構體、接口類型等。例如，Test[int](3) 中的 [int] 就是一個類型實參。

使用類型形參和類型實參的一個典型例子是在泛型函數中定義類型形參，然后調用該函數時提供類型實參的類型。例如：

package main


import "fmt"


// 定義泛型函數
func PrintType[T any](x T) {
    fmt.Printf("Type: %T\n", x)
}


func main() {
    // 調用泛型函數，類型實參為 int
    PrintType[int](42)
    // 調用泛型函數，類型實參為 string
    PrintType[string]("hello")
}
輸出結果：
Type: int
Type: string

在上面的示例中，我們定義了一個名為 PrintType 的泛型函數，并使用 [T any] 聲明了一個類型形參。然后，在調用該函數時，我們使用類型實參來具體化類型形參，例如使用 int 和 string。這樣，在函數內部，我們就可以使用具體的類型信息來打印數據的類型。

類型形參和類型實參的使用為我們提供了更大的靈活性和通用性，使得我們可以編寫可處理多種類型的泛型代碼。

四、Go的泛型

通過上面的代碼，我們對Go的泛型編程有了最初步也是最重要的認識——類型形參 和類型實參。而Go 1.18也是通過這種方式實現的泛型，但是單純的形參實參是遠遠不能實現泛型編程的，所以Go還引入了非常多全新的概念：

• 類型形參 (Type parameter)：用于定義泛型類型、泛型函數等模板中，形參類型的占位符。在Go中用[T any]這樣的方式表示。
• 類型實參(Type argument)：在使用泛型類型或泛型函數的時候，為泛型中的類型參傳遞具體的類型實參。比如，如果一個結構體類型定義了一個字段類型是泛型類型 T，在使用這個結構體類型的時候可以指定 T 的類型實參，如 MyStruct[int]。
• 類型形參列表( Type parameter list)：泛型函數、泛型類型等中聲明的形參列表，語法形如：[T any,U any]
• 類型約束(Type constraint)：為泛型類型參與約束其類型范圍的限制，以確保對應的類型實具有部分或者接口關系后代等。僅在Go 1.18版本及更高版本中支持。
• 實例化(Instantiations)：根據泛型類型的模板和類型實參生成具體類型的過程，本質上是傳統意義下函數調用時的實參傳遞和函數執行的過程。
• 泛型類型(Generic type)：包含一個或多個類型形參的類型。在定義時可以通過使用type關鍵字進行，例如 type MyStruct[T any] struct {}，表示定義了一個名為MyStruct的泛型結構體。
• 泛型接收器(Generic receiver)：用于為泛型類型聲明方法，可以通過定義泛型接收器來為泛型類型定義具有泛型類型參數的方法，實現代碼復用的目的。
• 泛型函數(Generic function)：包含一個或多個類型參參的函數，在調用時可以傳遞類型實參，確定具體類型的函數實例。在使用時，可以通過像調用普通函數一樣調用它，但需要在函數名后面使用 [T any] 等形式聲明其類型形參。

type MySlice[T int|float32|float64 ] []T


var mySlice MySlice[int]
上面這段代碼定義了一個具有類型約束的泛型類型MySlice，T為類型參，必須是int、float32或float64之一，表示只能用這個明確的類型代替T。MySlice[T]表示一個元素類型為T切片類型。
T 就是類型形參(Type parameter)，類似一個占位符
int|float32|float64 就是類型約束(Type constraint)，中間的 | 就是或的意思，表示類型形參 T 只接收 int 或 float32 或 float64 這三種類型的實參
中括號里的 T int|float32|float64 這一整串因為定義了所有的類型形參(在這個例子里只有一個類型形參T），所以我們稱其為 類型形參列表(Type parameter list)
在使用MySlice時，如MySlice[int]表示元素類型為int切片類型，int 就是類型實參(Type argument)
上面只是個最簡單的例子，實際上類型形參的數量可以遠遠不止一個，如下：
// CostMap類型定義了兩個類型形參 KEY 和 VALUE。分別為兩個形參指定了不同的類型約束
// 這個泛型類型的名字叫：CostMap[KEY, VALUE]
type CostMap[KEY int | string, VALUE float32 | float64] map[KEY]VALUE  


// 用類型實參 string 和 flaot64 替換了類型形參 KEY 、 VALUE，
// 泛型類型被實例化為具體的類型：CostMap[string, float64]
var a CostMap[string, float64] = map[string]float64{
    "dept1_cost": 8913.34,
    "dept2_cost": 4295.64,
}

用上面的例子重新復習下各種概念：

• KEY和VALUE是類型形參。
• int|string 是KEY的類型約束， float32|float64 是VALUE的類型約束。
• KEY int|string, VALUE float32|float64 整個一串文本因為定義了所有形參所以被稱為類型形參列表。
• Map[KEY, VALUE] 是泛型類型，類型的名字就叫 Map[KEY, VALUE]。
• var a CostMap[string, float64] 中的string和float64是類型實參，用于分別替換KEY和VALUE，實例化出了具體的類型 CostMap[string, float64]。

用如下一張圖就能簡單說清楚：

圖片

五、Go泛型實現方式

在Go語言中，泛型的實現方式是使用類型參數化函數和類型參數化結構體。類型參數化函數是一種函數，接受類型參數作為輸入，并根據這些類型參數返回不同的結果。類型參數化結構體是一種結構體，其中一些或全部成員字段由類型參數確定。

以下是一個用于從切片中查找元素并返回其索引的類型參數化函數的代碼示例：

func Find[T comparable](slice []T, value T) int {
    for i, v := range slice {
        if v == value {
            return i
        }
    }
    return -1
}

這個函數接收一個任意類型的切片和一個具有相同類型的值，并返回第一次出現該值的索引。類型參數T必須是“comparable”類型，也就是說，它必須是可比較的類型，這是Go泛型的一個限制。

以下是一個用于實現一個類型安全的棧的類型參數化結構體代碼示例：

type Stack[T any] struct {
    data []T
}


func (s *Stack[T]) Push(v T) {
    s.data = append(s.data, v)
}


func (s *Stack[T]) Pop() (t T, err error) {
   if len(s.data) == 0 {
      return t, errors.New("stack is empty")
   }
   res := s.data[len(s.data)-1]
   s.data = s.data[:len(s.data)-1]
   return res, nil
}


func main() {
   var stack Stack[int]
   stack.Push(1)
   stack.Push(2)
   stack.Push(3)
   item, err := stack.Pop()if err != nil {
      fmt.Println("Error:", err)
   } else {
      fmt.Println("Pop item:", item)
   }
   item, err = stack.Pop()if err != nil {
      fmt.Println("Error:", err)
   } else {
      fmt.Println("Pop item:", item)
   }
}

這個結構體表示棧，其中T是元素類型，并且在Push和Pop函數中使用。注意，這里的類型參數T沒有任何限制，因此可以傳遞任何類型。var stack Stack[int] 在初始化實例時，就把類型設置好了。

以上是一些示例代碼，展示了Go泛型的使用。在復雜的程序中，泛型的使用可以使代碼更加通用、易于閱讀、安全且具有更高的重用性。

六、Go語言和其他語言在泛型上的對比

Go語言的泛型實現與其他編程語言（如Java、C++、C#等）的泛型實現有一些不同的地方。以下是它們在一些方面的對比：

1. 語法：Go泛型的語法相對簡單，采用了類似接口的方式聲明泛型類型參數，用[Tany]這樣的方式表示。而其他語言的泛型語法則比較復雜，涉及到泛型類、泛型型式方法等多個方面。
2. 實現方式：Go泛型的實現方式采用了代碼生成（代碼生成）的方式，即在編譯時自動生成特定類型的代碼。而其他語言則采用了編譯時靜態類型檢查的方式，即在編譯時對泛型類型參數進行類型檢查，并生成相應的代碼。
3. 類型限制：泛型的類型限制比較廣泛，可以使用任意類型作為泛型類型參數。而其他語言則通常需要對泛型類型參數進行限制，以確保其滿足特定的類型要求（如繼承關系、實現接口等）。
4. 性能：Go泛型的性能比其他的泛型實現要低一些，因為其采用了代碼生成的方式，在運行時需要額外生成和加載對應的代碼。而其他語言則采用了預編譯的方式，在編譯時已經生成了相應的代碼，運行時不需要再進行額外的操作。

總的來說，Go泛型的實現方式比較簡單、靈活，但在性能方面有些損失。但同時，Go語言也在持續地改進其泛型實現，以提高其性能，并加入更多的功能特性。

七、Go的實戰應用

以下代碼是Go中用泛型實現Set無序集合，包含了添加，刪除，是否存在，轉成列表等方法。

type Set[T comparable] struct {
   m map[T]struct{}
}


func (s *Set[T]) Add(t T) {
   s.m[t] = struct{}{}
}


func (s *Set[T]) Remove(t T) {
   delete(s.m, t)
}


func (s *Set[T]) Exist(t T) bool {
   _, ok := s.m[t]
   return ok
}


func (s *Set[T]) List() []T {
   t := make([]T, len(s.m))
   var i int
   for k := range s.m {
      t[i] = k
      i++
   }
   return t
}


func (s *Set[T]) ForEach(f func(T)) {
   for k, _ := range s.m {
      f(k)
   }
}

八、Go泛型的優勢

Go泛型的出現，使得我們可以更加通用、安全且具有更高的重用性。它的出現具有以下優勢：

1. 更加通用：泛型使得我們可以創建能夠操作任何類型的數據結構和算法，從而使得代碼可以更加通用。
2. 安全性：類型參數化函數和類型參數化結構體使得編譯器可以對代碼進行更嚴格的類型檢查，從而減少了許多類型相關的運行時錯誤。
3. 可讀性：類型參數化使得代碼可以更加清晰、簡潔和易于閱讀。在不同的數據結構和算法中，使用相同的代碼模板可以減少代碼量。

九、總結

在Golang中，泛型功能的引入提高了Go的通用性、可讀性和安全性。使用類型參數化的方式，我們可以編寫出可以處理任何類型的代碼。盡管Go泛型的實現方式略有不同于其他語言，但仍然可以為程序員提供實用的工具和功能，使代碼更加通用、安全、易讀和易于維護。