一、引言

泛型編程在許多編程語(yǔ)言中都是一項(xiàng)非常強(qiáng)大的特性，它可以使程序更加通用、具有更高的重用性。然而，Go語(yǔ)言在很長(zhǎng)一段時(shí)間內(nèi)一直沒有提供泛型功能。在過去的一些版本中，Go語(yǔ)言開發(fā)者試圖引入泛型，但最終都因?yàn)楦鞣N原因被取消或擱置了。直到Go 1.18版本，終于引入了泛型功能。在本文中，將會(huì)介紹這項(xiàng)新特性及其使用方法。

二、什么是泛型？

泛型是一種編程語(yǔ)言的特性，它可以將類型參數(shù)化，并以類型參數(shù)形式傳遞到不同的算法和數(shù)據(jù)結(jié)構(gòu)中。泛型使得程序可以更加通用、安全且具有更高的重用性。不同的類型參數(shù)可以通過參數(shù)化類型類型來(lái)表示。例如，在Java中，可以使用ArrayList<Integer>來(lái)表示包含整數(shù)的動(dòng)態(tài)數(shù)組，其中Integer是類型參數(shù)的類型。

在Go語(yǔ)言中，泛型的類型參數(shù)可以是任何類型，包括基本類型、引用類型、結(jié)構(gòu)體和接口等。這些類型參數(shù)可以用在函數(shù)、方法、結(jié)構(gòu)體、接口、通道和映射等語(yǔ)法結(jié)構(gòu)中。

三、得一切從函數(shù)的形參和實(shí)參說起

當(dāng)談到泛型編程時(shí)，我們需要了解兩個(gè)重要的概念：類型形參和類型實(shí)參。

• 類型形參（Type Parameters）：類型形參是一種在泛型代碼中使用的占位符類型。它們?cè)试S我們定義函數(shù)、方法或數(shù)據(jù)結(jié)構(gòu)，這些代碼可以處理多種類型的數(shù)據(jù)而不是特定的類型。在 Go 語(yǔ)言中，類型形參使用方括號(hào) [] 包圍，并且可以在函數(shù)、方法或結(jié)構(gòu)體的名稱后面定義。例如，func Test[T any](x T) 中的 [T any] 就是一個(gè)類型形參。在使用泛型函數(shù)或結(jié)構(gòu)體時(shí)，我們需要提供實(shí)際的類型實(shí)參來(lái)替換類型形參的位置。
• 類型實(shí)參（Type Arguments）：類型實(shí)參是在使用泛型代碼時(shí)提供的具體類型。當(dāng)我們調(diào)用泛型函數(shù)或?qū)嵗盒徒Y(jié)構(gòu)體時(shí)，我們需要指定具體的類型實(shí)參，以替換泛型代碼中的類型形參。類型實(shí)參可以是任何合法的類型，包括基本類型、結(jié)構(gòu)體、接口類型等。例如，Test[int](3) 中的 [int] 就是一個(gè)類型實(shí)參。

使用類型形參和類型實(shí)參的一個(gè)典型例子是在泛型函數(shù)中定義類型形參，然后調(diào)用該函數(shù)時(shí)提供類型實(shí)參的類型。例如：

package main


import "fmt"


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


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

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

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

四、Go的泛型

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

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

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


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


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

用上面的例子重新復(fù)習(xí)下各種概念：

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

用如下一張圖就能簡(jiǎn)單說清楚：

圖片

五、Go泛型實(shí)現(xiàn)方式

在Go語(yǔ)言中，泛型的實(shí)現(xiàn)方式是使用類型參數(shù)化函數(shù)和類型參數(shù)化結(jié)構(gòu)體。類型參數(shù)化函數(shù)是一種函數(shù)，接受類型參數(shù)作為輸入，并根據(jù)這些類型參數(shù)返回不同的結(jié)果。類型參數(shù)化結(jié)構(gòu)體是一種結(jié)構(gòu)體，其中一些或全部成員字段由類型參數(shù)確定。

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

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

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

以下是一個(gè)用于實(shí)現(xiàn)一個(gè)類型安全的棧的類型參數(shù)化結(jié)構(gòu)體代碼示例：

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)
   }
}

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

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

六、Go語(yǔ)言和其他語(yǔ)言在泛型上的對(duì)比

Go語(yǔ)言的泛型實(shí)現(xiàn)與其他編程語(yǔ)言（如Java、C++、C#等）的泛型實(shí)現(xiàn)有一些不同的地方。以下是它們?cè)谝恍┓矫娴膶?duì)比：

1. 語(yǔ)法：Go泛型的語(yǔ)法相對(duì)簡(jiǎn)單，采用了類似接口的方式聲明泛型類型參數(shù)，用[Tany]這樣的方式表示。而其他語(yǔ)言的泛型語(yǔ)法則比較復(fù)雜，涉及到泛型類、泛型型式方法等多個(gè)方面。
2. 實(shí)現(xiàn)方式：Go泛型的實(shí)現(xiàn)方式采用了代碼生成（代碼生成）的方式，即在編譯時(shí)自動(dòng)生成特定類型的代碼。而其他語(yǔ)言則采用了編譯時(shí)靜態(tài)類型檢查的方式，即在編譯時(shí)對(duì)泛型類型參數(shù)進(jìn)行類型檢查，并生成相應(yīng)的代碼。
3. 類型限制：泛型的類型限制比較廣泛，可以使用任意類型作為泛型類型參數(shù)。而其他語(yǔ)言則通常需要對(duì)泛型類型參數(shù)進(jìn)行限制，以確保其滿足特定的類型要求（如繼承關(guān)系、實(shí)現(xiàn)接口等）。
4. 性能：Go泛型的性能比其他的泛型實(shí)現(xiàn)要低一些，因?yàn)槠洳捎昧舜a生成的方式，在運(yùn)行時(shí)需要額外生成和加載對(duì)應(yīng)的代碼。而其他語(yǔ)言則采用了預(yù)編譯的方式，在編譯時(shí)已經(jīng)生成了相應(yīng)的代碼，運(yùn)行時(shí)不需要再進(jìn)行額外的操作。

總的來(lái)說，Go泛型的實(shí)現(xiàn)方式比較簡(jiǎn)單、靈活，但在性能方面有些損失。但同時(shí)，Go語(yǔ)言也在持續(xù)地改進(jìn)其泛型實(shí)現(xiàn)，以提高其性能，并加入更多的功能特性。

七、Go的實(shí)戰(zhàn)應(yīng)用

以下代碼是Go中用泛型實(shí)現(xiàn)Set無(wú)序集合，包含了添加，刪除，是否存在，轉(zhuǎn)成列表等方法。

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泛型的優(yōu)勢(shì)

Go泛型的出現(xiàn)，使得我們可以更加通用、安全且具有更高的重用性。它的出現(xiàn)具有以下優(yōu)勢(shì)：

1. 更加通用：泛型使得我們可以創(chuàng)建能夠操作任何類型的數(shù)據(jù)結(jié)構(gòu)和算法，從而使得代碼可以更加通用。
2. 安全性：類型參數(shù)化函數(shù)和類型參數(shù)化結(jié)構(gòu)體使得編譯器可以對(duì)代碼進(jìn)行更嚴(yán)格的類型檢查，從而減少了許多類型相關(guān)的運(yùn)行時(shí)錯(cuò)誤。
3. 可讀性：類型參數(shù)化使得代碼可以更加清晰、簡(jiǎn)潔和易于閱讀。在不同的數(shù)據(jù)結(jié)構(gòu)和算法中，使用相同的代碼模板可以減少代碼量。

九、總結(jié)

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