事實上，泛型才是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 sum[v int | float64 | string](a v, b v) v {
s := a + b
return s
}
如果是多個資料型別，可以使用|分隔，這里定義了一個泛型變數v，可以是整形、浮點以及字串：
package main
import (
"fmt"
)
func sum[v int | float64 | string](a v, b v) v {
s := a + b
return s
}
func main() {
a := "1"
b := "2"
fmt.Println(sum(a, b))
}
程式回傳：
12
注意，由于引數的型別未定，所以回傳值也必須是泛型型別，現在動態的把引數改為整形：
package main
import (
"fmt"
)
func sum[v int | float64 | string](a v, b v) 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 = https://www.cnblogs.com/v3ucn/p/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 = https://www.cnblogs.com/v3ucn/p/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 test[T int | float32 | float64](a, b T) {
// 匿名函式可使用已經定義好的型別形參
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) Add[T int | float32 | float64](a T, b T) 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系結的方法也就可以直接使用宣告好的泛型型別，和匿名函式直接用父級泛型是一個意思，
結語
事實上，靜態語言在設計上基本都有泛型的概念，這并不是自我矛盾，對應的，在動態語言Python中為函式宣告形參時，我們其實也可以指定具體的引數型別或者回傳值型別，正所謂無招勝有招，真正的高手，可以脫離語言型別的桎梏，達到一種無我無眾生的境界，比如，在固有思維模式中，降龍十八掌是一種至剛至猛的武功，威力無窮，無堅不摧，但郭大俠后期再使用這門神功時，降龍十八掌的勁力忽強忽弱，忽吞忽吐，從至剛之中竟生出至柔的妙用，那已是洪七公當年所領悟不到的境界，所以，剛柔并濟、虛中有實、實中有虛、虛實相生才是泛型使用的最高境界，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/503246.html
標籤：Go
上一篇：HashMap面試相關