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

語言: CN / TW / HK
時間 2022-10-11 15:15:09

攜手創作，共同成長！這是我參與「掘金日新計劃 · 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繫結的方法也就可以直接使用宣告好的泛型型別，和匿名函式直接用父級泛型是一個意思。

結語

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

「其他文章」
「」
「」