溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“Go1.18新特性之泛型怎么使用”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Go1.18新特性之泛型怎么使用”吧!
眾所周知，Go是一門靜態類型的語言。靜態類型也就意味著在使用Go語言編程時，所有的變量、函數參數都需要指定具體的類型，同時在編譯階段編譯器也會對指定的數據類型進行校驗。這也意味著一個函數的輸入參數和返回參數都必須要和具體的類型強相關，不能被不同類型的數據結構所復用。
而泛型就是要解決代碼復用和編譯期間類型安全檢查的問題而生的。這里給出我理解的泛型的定義：
泛型是靜態語言中的一種編程方式。這種編程方式可以讓算法不再依賴于某個具體的數據類型，而是通過將數據類型進行參數化，以達到算法可復用的目的。
下面，我們通過一個函數的傳統編寫方式和泛型編寫方式先來體驗一下。
例如，我們有一個函數Max，其功能是計算整型切片中的最大元素，則其傳統的編寫方式如下：
func Max(s []int) int {
if len(s) == 0 {
return 0
}
max := s[0]
for _, v := range s[1:] {
if v > max {
max = v
}
}
return max
}
m1 := Max([]int{4, -8, 15})在該示例中，Max函數的輸入參數和返回值類型已經被指定都是int類型，不能使用其他類型的切片（例如s []float）。如果想要獲取float類型的切片中的最大元素，則需要再寫一個函數：
func MaxFloat(s []float) float {
//...
}傳統的編寫方式的缺點就是需要針對每一種類型都要編寫一個函數，除了函數的參數中的類型不一樣，其他邏輯完全一樣。
接下來我們看看使用泛型的寫法。
為了能夠使編寫的程序更具有可復用性，通用編程（Generic programming）也應運而生。使用泛型，函數或類型可以基于類型參數進行定義，并在調用該函數時動態指定具體的類型對其進行實例化，以達到函數或類型可以基于一組定義好的類型都能使用的目的。我們通過泛型將上述Max函數進行改寫：
import (
"fmt"
"golang.org/x/exp/constraints"
)
func main() {
m1 := Max[int]([]int{4, -8, 15})
m2 := Max[float64]([]float64{4.1, -8.1, 15.1})
fmt.Println(m1, m2)
}
// 定義泛型函數
func Max[T constraints.Ordered](s []T) T {
var zero T
if len(s) == 0 {
return zero
}
var max T
max = s[0]
for _, v := range s[1:] {
max = v
if v > max {
max = v
}
}
return max
}由以上示例可知，我們通過使用泛型改寫了MaxNumber函數，在main函數中調用MaxNumber時，通過傳入一個具體的類型就能復用MaxNumber的代碼了。
好了，這里我們只是對泛型有了一個初探，至于泛型函數中的T和any等關鍵詞暫時不用關系，在后面我們會詳細講解。
接下來我們從泛型被加入之前說起，從而更好的的理解泛型被加入的動機。
為了更好的理解為什么需要泛型，我們看看如果不使用泛型如何實現可復用的算法。還是以上面的返回切片中元素的最大值函數為例。
為了能夠針對切片中不同的數據類型都可以復用，我們一般有以下幾種方案：
針對每一種類型編寫一套重復的代碼
傳遞一個空接口interface{}，使用類型斷言來判斷是哪種數據類型
傳遞一個空接口interface{}，使用反射機制來判斷是哪種數據類型
自定義接口類型，通過類型繼承的方式實現具體邏輯
下面我們看上面每一種實現方法都有哪些缺點。
這種方法我們在第一節中已經實現了。針對int切片和float切片各自實現一個函數，但在兩個函數中只有切片的數據類型不同，其他邏輯都相同。
這種方法的主要缺點就是大量的重復代碼。這兩個函數中除了切片元素的數據類型不同之外，其他都一樣。同時，大量重復的代碼也降低了代碼的可維護性。
另外一種方法是函數接收一個空接口的參數。在函數內部使用類型斷言和switch語句來選擇是哪種具體的類型。最后將結果再包裝到一個空接口中返回。如下：
func Max(s []interface{}) (interface{}, error) {
if len(s) == 0 {
return nil, errors.New("no values given")
}
switch first := s[0].(type) {
case int:
max := first
for _, rawV := range s[1:] {
v := rawV.(int)
if v > max {
max = v
}
}
return max, nil
case float64:
max := first
for _, rawV := range s[1:] {
v := rawV.(float64)
if v > max {
max = v
}
}
return max, nil
default:
return nil, fmt.Errorf("unsupported element type of given slice: %T", first)
}
}
// Usage
m1, err1 := Max([]interface{}{4, -8, 15})
m2, err2 := Max([]interface{}{4.1, -8.1, 15.1})這種寫法的主要有兩個缺點。第一個缺點是在編譯期間缺少類型安全檢查。如果調用者傳遞了一個不支持的數據類型，該函數的實現應該是返回一個錯誤。第二個缺點是這種實現的可用性也不是很好。因為無論是調用者處理返回值還是在函數內部的實現代碼都需要將具體的類型包裝在一個空接口中，并使用類型斷言來判斷接口里的具體的類型。
在從空接口中解析具體的類型時，我們還可以通過反射替代類型斷言。如下實現：
func Max(s []interface{}) (interface{}, error) {
if len(s) == 0 {
return nil, errors.New("no values given")
}
first := reflect.ValueOf(s[0])
if first.Type().Name() == "int" {
max := first.Int()
for _, ifV := range s[1:] {
v := reflect.ValueOf(ifV)
if v.Type().Name() == "int" {
intV := v.Int()
if intV > max {
max = intV
}
}
}
return max, nil
}
if first.Type().Name() == "float64" {
max := first.Float()
for _, ifV := range s[1:] {
v := reflect.ValueOf(ifV)
if v.Type().Name() == "float64" {
intV := v.Float()
if intV > max {
max = intV
}
}
}
return max, nil
}
return nil, fmt.Errorf("unsupported element type of given slice: %T", s[0])
}
// Usage
m1, err1 := Max([]interface{}{4, -8, 15})
m2, err2 := Max([]interface{}{4.1, -8.1, 15.1})在這種方法中，在編譯期間不僅沒有類型的安全檢查，同時可讀性也差。而且在使用反射時，性能通常也會比較差。
另外一種方法，我們可以通過給函數傳遞一個具體的，預定義好的接口來實現。該接口應該包含該函數要實現的功能的必備方法。只要實現了該接口的類型，該方法就都可以支持。我們還是以上面的MaxNumber函數為例，應該有獲取元素個數的方法Len，比較大小的方法Less以及獲取元素的方法Elem。我們來看看具體的實現：
type ComparableSlice interface {
// 返回切片的元素個數.
Len() int
// 比較索引i的元素值是否比索引j的元素值要小
Less(i, j int) bool
// 返回索引i位置的元素
Elem(i int) interface{}
}
func Max(s ComparableSlice) (interface{}, error) {
if s.Len() == 0 {
return nil, errors.New("no values given")
}
max := s.Elem(0)
for i := 1; i < s.Len(); i++ {
if s.Less(i-1, i) {
max = s.Elem(i)
}
}
return max, nil
}
type ComparableIntSlice []int
func (s ComparableIntSlice) Len() int { return len(s) }
func (s ComparableIntSlice) Less(i, j int) bool { return s[i] < s[j] }
func (s ComparableIntSlice) Elem(i int) interface{} { return s[i] }
type ComparableFloat64Slice []float64
func (s ComparableFloat64Slice) Len() int { return len(s) }
func (s ComparableFloat64Slice) Less(i, j int) bool { return s[i] < s[j] }
func (s ComparableFloat64Slice) Elem(i int) interface{} {return s[i]}
// Usage
m1, err1 := Max(ComparableIntSlice([]int{4, -8, 15}))
m2, err2 := Max(ComparableFloat64Slice([]float64{4.1, -8.1, 15.1}))在該實現中，我們定義了一個ComparableSlice接口，其中ComparableIntSlice和ComparableFloat64Slice兩個具體的類型都實現了該接口，分別對應int類型切片和float64類型切片。
該實現的一個明顯的缺點是難以使用。因為調用者必須將數據封裝到一個自定義的類型中（在該示例中是ComparableIntSlice和ComparableFloat64Slice），并且該自定義類型要實現已定義的接口ComparableSlice。
由以上示例可知，在有泛型功能之前，要想在Go中實現處理多種類型的可復用的函數，都會帶來一些問題。而泛型機制正是避免上述各種問題的解決方法。
在文章第一節處我們已經提到過泛型要解決的問題--程序針對一組類型可進行復用。下面我們給出泛型函數的一般形式，如下圖：
由上圖的泛型函數的一般定義形式可知，使用泛型可以分三步，我將其稱之為“泛型使用三步曲”。
在定義泛型函數時，使用中括號給出類型參數類型，并在函數所接收的參數中使用該類型參數，而非具體類型，就是所謂的類型參數化。還是以上面的泛型函數為例：
func Max[T constraints.Ordered](s []T) T {
var zero T
if len(s) == 0 {
return zero
}
var max T
max = s[0]
for _, v := range s[1:] {
max = v
if v > max {
max = v
}
}
return max
}其中T被稱為類型參數，即不再是一個具體的類型值，而是需要在調用該函數時再動態的傳入一個類型值（例如int，float64），以實例化化T。例如：Max[int](s[]int{4,-8,15})，那么T就代表的是int。
當然，類型參數列表中可以有多個類型參數，多個類型參數之間用逗號隔開即可。類型參數名也不一定非要用T，任何符合變量規則的名稱都可以。
在上圖中，any被稱為是類型約束，用來描述傳給T的類型值應該滿足什么樣的條件，不滿足約束的類型傳給T時會被報編譯錯誤，這樣就實現了類型的安全機制。當然類型約束不僅僅像any這么簡單。
在Go中類型約束分兩類，分別是Go官方支持的內建類型約束（包括內建的類型約束any、comparable和在golang.org/x/exp/constraints 包中定義的類型約束）和自定義類型約束。因為在Go中泛型的約束是通過接口來實現的，所以我們可以通過定義接口來自定義類型約束。
3.2.1 Go官方支持的內建類型約束
其中Go內建的類型約束和constraints包定義的類型約束我們統一成為Go官方定義的類型約束。之所以是在golang.org/x/exp/constraints包中，是因為該約束帶有實驗性質。
下面我們列出了Go官方支持的預定義的類型約束：
| 約束 | 描述 | 位置 |
|---|---|---|
| any | 任意類型；可以看做是空接口interface{}的別名 | go內建 |
| comparable | 可比較的值類型，即該類型的值可以使用==和!=操作符進行比較（例如bool、數字類型、字符串、指針、通道、接口、值是可比較類型的數組、字段都是可比較類型的結構體等） | go內建 |
| Signed - 有符號整型 | ~int | ~int8 | ~int16 | ~int32 | ~int64 | golang.org/x/exp/constraints |
| Unsigned - 有符號整型 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | golang.org/x/exp/constraints |
| Integer - 整型 | Signed | Unsigned | golang.org/x/exp/constraints |
| Float - 浮點型 | ~float32 | ~float64 | golang.org/x/exp/constraints |
| Complex - 復數型 | ~complex64 | ~complex128 | golang.org/x/exp/constraints |
| Ordered | Integer | Float | ~string(支持<、<=、>=、>操作符的任意類型） | golang.org/x/exp/constraints |
在上表中，我們看到的符號~。~T意思是說底層類型是T的類型。例如~int代表的是底層類型是int的類型。這個我們在下一節自定義類型約束一節有詳細介紹和示例。
3.2.2 自定義類型約束
由上面可知，類型的約束本質上是一個接口。所以，如果官方提供的類型約束不滿足自己的業務場景下，可以按照Go中泛型的語法規則自定義類型約束即可。類型約束的定義一般有兩種形式：
定義成接口形式
直接定義在類型參數列表中
下面我們分別來看下各自的使用方法。
定義成接口形式
下面是定義成接口形式的類型約束示例：
// 自定義類型約束接口StringableFloat
type StringableFloat interface {
~float32 | ~float64 // 底層是float32或float64的類型就能滿足該約束
String() string
}
// MyFloat 是滿足StringableFloat類型約束的float類型。
type MyFloat float64
// 實現類型約束中的String方法
func (m MyFloat) String() string {
return fmt.Sprintf("%e", m)
}
//泛型函數，對類型參數T使用了StringableFloat約束
func StringifyFloat[T StringableFloat](f T) string {
return f.String()
}
// Usage
var f MyFloat = 48151623.42
//使用MyFloat類型對T進行實例化
s := StringifyFloat[MyFloat](f)在該示例中，函數StringifyFloat是一個泛型函數，并使用StringableFloat接口來對T進行約束。MyFloat類型是一個滿足StringableFloat約束的具體類型。
在泛型中，類型約束被定義成了接口，該接口中可以包含具體類型的集合和方法。在該示例中，StringfyFloat類型約束包含float32和float64兩個類型以及一個String()方法。該約束允許任何滿足該接口的具體類型都可以實例化參數T。
在上述示例中，我們還看到一個新的關鍵符號：~。~T代表所有的類型的底層類型必須是類型T。在這里類型MyFloat是一個自定義的類型，但其底層類型或叫做基礎類型是float64。因此，MyFloat是滿足StringifyFloat約束的。
另外，在定義類型約束接口中，也可以引入類型參數。如下示例中，在類型約束SliceConstraints中的切片類型引入了類型參數E，這樣該約束就可以對任意類型的切片進行約束了。
package main
import (
"fmt"
"golang.org/x/exp/constraints"
)
func main() {
r1 := FirstElem1[[]string, string]([]string{"Go", "rocks"})
r2 := FirstElem1[[]int, int]([]int{1, 2})
fmt.Println(r1, r2)
}
// 定義類型約束，并引入類型參數E
type SliceConstraint[E any] interface {
~[]E
}
// 泛型函數
func FirstElem1[S SliceConstraint[E], E any](s S) E {
return s[0]
}在類型參數列表中直接定義約束
下面的示例中，FirstElem2、FirstElem3泛型函數將類型約束直接定義在了類型參數列表中，我把它稱之為匿名類型約束接口，類似于匿名函數。如下示例代碼，三個泛型函數是等價的：
package main
import (
"fmt"
"golang.org/x/exp/constraints"
)
func main() {
s := []string{"Go", "rocks"}
r1 := FirstElem1[[]string, string](s)
r2 := FirstElem2[[]string, string](s)
r3 := FirstElem3[[]string, string](s)
fmt.Println(r1, r2, r3)
}
type SliceConstraint[E any] interface {
~[]E
}
func FirstElem1[S SliceConstraint[E], E any](s S) E {
return s[0]
}
func FirstElem2[S interface{ ~[]E }, E any](s S) E {
return s[0]
}
func FirstElem3[S ~[]E, E any](s S) E {
return s[0]
}在調用泛型函數時，需要給函數的類型參數指定具體的類型，叫做類型實例化。在類型實例化過程中有時候是不需要指定的具體的類型，這時在編譯階段，編譯器會根據函數的參數自動推導出來T的實際參數值。如下：
類型參數實例化就比較簡單了，就是在調用泛型函數時要給泛型函數的類型參數傳遞一個具體的類型。就像第一步中調用Max函數時指定的一樣：r2 := Max[int]([]int{4, 8, 15})，這里Max后面中括號中的int就是類型實參，這樣Max函數就能知道處理的切片元素的具體類型了。
這里還有一點需要注意，在類型參數實例化時，還有方式是不需要指定具體的類型，這時在編譯階段，編譯器會根據函數的參數自動推導出來T的實際參數值： r3 := Max([]float64{4.1, -8.1, 15.1})。這里Max后面并沒有給出中括號以及對應的具體類型，但Go編譯器能根據切片元素類型自動推斷出是float64類型。
首先二者都是接口，都可以定義方法。但類型約束接口中可以定義具體類型，例如上文中自定義的StringableFloat類型約束接口中的類型約束：~float32 | ~float64
type StringableFloat interface {
~float32 | ~float64 // 底層是float32或float64的類型就能滿足該約束
String() string
}當接口中存在類型約束時，這時該接口就只能被用于泛型類型參數的約束。
到此，相信大家對“Go1.18新特性之泛型怎么使用”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
