因勢而變,因時而動,Go lang1.18入門精煉教程，由白丁入鴻儒，Go lang泛型(generic)的使用EP15_劉悦的技術博客

攜手創作，共同成長！這是我參與「掘金日新計劃 · 8 月更文挑戰」的第21天，點擊查看活動詳情

事實上，泛型才是Go lang1.18最具特色的所在，但為什麼我們一定要拖到後面才去探討泛型？類比的話，我們可以想象一下給小學一年級的學生講王勃的千古名篇《滕王閣序》，小學生有多大的概率可以理解作者的青雲之志以及壯志難酬的憤懣心情？恐怕很難罷，是的，如果對Go lang的強類型語法沒有一段時間的體驗期，就很難理解泛型這種“反”靜態語言概念。

基本概念

什麼是泛型？泛型泛型，顧名思義，泛用的類型，説白了，就是在靜態類型語言環境使用動態類型語言的特性：

```

package main

import (
"fmt"
)

func sum(a string, b string) string {

s := a + b  
return s

}

func main() {

a := "1"  
b := "2"

fmt.Println(sum(a, b))

}

```

比方説有一個函數可以實現兩個字符串合併，參數聲明瞭字符串，也就不支持其他的數據類型，但如果邏輯上差不多，需要兩個整形求和的函數怎麼辦？那就得再寫一個差不多的函數，這樣就影響了代碼邏輯的複用性。

相同邏輯下可以針對不同的數據類型進行泛用，這就是泛型的意義所在。

泛型聲明

Go lang中的泛型使用 [] 來申明類型範圍：

``` func sumv int | float64 | string v {

s := a + b

return s

} ```

如果是多個數據類型，可以使用|分隔，這裏定義了一個泛型變量v，可以是整形、浮點以及字符串：

``` package main

import (
"fmt"
)

func sumv int | float64 | string v {

s := a + b

return s

}

func main() {

a := "1"  
b := "2"

fmt.Println(sum(a, b))

} ```

程序返回：

12

注意，由於參數的類型未定，所以返回值也必須是泛型類型，現在動態的把參數改為整形：

``` package main

import (
"fmt"
)

func sumv int | float64 | string v {

s := a + b

return s

}

func main() {

a := 1  
b := 2

fmt.Println(sum(a, b))

} ```

返回值也因為參數類型的改變而改變：

3

藉此，我們就聲明瞭一個可以“泛用”的函數。

高階應用

事實上，泛型的出現並非可以豐富函數的聲明和構建，更多的，是戰略層面上的多樣化選擇，比如容器內的類型，進而言之，隊列：

``` type Queue[T interface{}] struct {
elements []T
}

// 將數據放入隊列尾部
func (q *Queue[T]) Put(value T) {
q.elements = append(q.elements, value)
}

// 從隊列頭部取出並從頭部刪除對應數據
func (q *Queue[T]) Pop() (T, bool) {
var value T
if len(q.elements) == 0 {
return value, true
}

value = q.elements[0]  
q.elements = q.elements[1:]  
return value, len(q.elements) == 0

} ```

這裏結構體的類型約束使用了空接口，代表的意思是所有類型都可以用來實例化泛型類型，同時基於泛型結構體，我們定義兩個方法，分別是：入隊和出隊。

因為這個隊列是泛型隊列，所以隊內元素的類型可以在實現結構體接口時進行定義：

``` package main

import (
"fmt"
)

type Queue[T interface{}] struct {
elements []T
}

// 將數據放入隊列尾部
func (q *Queue[T]) Put(value T) {
q.elements = append(q.elements, value)
}

// 從隊列頭部取出並從頭部刪除對應數據
func (q *Queue[T]) Pop() (T, bool) {
var value T
if len(q.elements) == 0 {
return value, true
}

value = q.elements[0]  
q.elements = q.elements[1:]  
return value, len(q.elements) == 0

}

func main() {

var q1 Queue[int] // 可存放int類型數據的隊列  
q1.Put(1)  
q1.Put(2)  
q1.Put(3)  
fmt.Println(q1)

var q2 Queue[string] // 可存放string類型數據的隊列  
q2.Put("A")  
q2.Put("B")  
q2.Put("C")

fmt.Println(q2)

} ```

程序返回：

{[1 2 3]} {[A B C]}

匿名函數和方法暫不支持泛型

Golang中，我們經常會使用匿名函數：

``` package main

import (
"fmt"
)

func main() {

fn := func(a, b int) int {  
    return a + b  
} // 定義了一個匿名函數並賦值給 fn

fmt.Println(fn(1, 2)) // 輸出: 3

} ```

程序返回：

3

大體上，和Python的lambda表達式類似，如果封裝的邏輯相對簡單或者和上下游邏輯連貫性較強，那麼，在不影響代碼可讀性的前提下，我們就沒必要單獨聲明一個函數，而是選擇匿名函數。

但1.18版本中，匿名函數並不支持參數為泛型，因為匿名函數不能自己定義類型形參：

fnGeneric := func[T int | string](a, b T) T { return a + b }

程序報錯：

./hello.go:9:19: syntax error: function literal must have no type parameters

但匿名函數可以使用已經被合法定義的泛型類型：

``` package main

import (
"fmt"
)

func testT int | float32 | float64 {

// 匿名函數可使用已經定義好的類型形參  
fn2 := func(i T, j T) T {  
    return i + j  
}

fmt.Println(fn2(a, b))

}

func main() {

test(1, 2)

} ```

程序返回：

3

也就是説，匿名函數可以使用父級函數定義好的泛型類型參數，這意味着，在泛型函數內，我們可以通過匿名函數對邏輯進行二次封裝。

同樣地，1.18版本中的方法也不支持泛型：

``` type A struct {
}

// 不支持泛型方法
func (receiver A) AddT int | float32 | float64 T {
return a + b
} ```

程序報錯：

syntax error: method must have no type parameters

但是和匿名函數類型，因為receiver支持泛型，所以我們可以聲明結構體內receiver的參數為泛型類型：

``` package main

import "fmt"

type A[T int | float32 | float64] struct {
}

// 方法可以使用類型定義中的形參 T
func (receiver A[T]) Add(a T, b T) T {
return a + b
}

func main() {

var a A[int]  
res := a.Add(1, 2)

fmt.Println(res)

} ```

程序返回：

3

因為receiver聲明瞭泛型參數，我們為結構體A綁定的方法也就可以直接使用聲明好的泛型類型，和匿名函數直接用父級泛型是一個意思。

結語

事實上，靜態語言在設計上基本都有泛型的概念，這並不是自我矛盾，對應的，在動態語言為函數聲明形參時，我們其實也可以指定具體的參數類型或者返回值類型，正所謂無招勝有招，真正的高手，可以脱離語言類型的桎梏，達到一種無我無眾生的境界，比如，在固有思維模式中，降龍十八掌是一種至剛至猛的武功，威力無窮，無堅不摧，但郭大俠後期再使用這門神功時，降龍十八掌的勁力忽強忽弱，忽吞忽吐，從至剛之中竟生出至柔的妙用，那已是洪七公當年所領悟不到的境界，所以，剛柔並濟、虛中有實、實中有虛、虛實相生才是泛型使用的最高境界。