Go1.18新特性之泛型怎么使用

本篇內(nèi)容主要講解“Go1.18新特性之泛型怎么使用”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學(xué)習(xí)“Go1.18新特性之泛型怎么使用”吧!

01 Go中的泛型是什么

眾所周知，Go是一門靜態(tài)類型的語言。靜態(tài)類型也就意味著在使用Go語言編程時，所有的變量、函數(shù)參數(shù)都需要指定具體的類型，同時在編譯階段編譯器也會對指定的數(shù)據(jù)類型進行校驗。這也意味著一個函數(shù)的輸入?yún)?shù)和返回參數(shù)都必須要和具體的類型強相關(guān)，不能被不同類型的數(shù)據(jù)結(jié)構(gòu)所復(fù)用。

而泛型就是要解決代碼復(fù)用和編譯期間類型安全檢查的問題而生的。這里給出我理解的泛型的定義：

泛型是靜態(tài)語言中的一種編程方式。這種編程方式可以讓算法不再依賴于某個具體的數(shù)據(jù)類型，而是通過將數(shù)據(jù)類型進行參數(shù)化，以達到算法可復(fù)用的目的。

下面，我們通過一個函數(shù)的傳統(tǒng)編寫方式和泛型編寫方式先來體驗一下。

1.1 傳統(tǒng)的函數(shù)編寫方式

例如，我們有一個函數(shù)Max，其功能是計算整型切片中的最大元素，則其傳統(tǒng)的編寫方式如下：

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函數(shù)的輸入?yún)?shù)和返回值類型已經(jīng)被指定都是int類型，不能使用其他類型的切片（例如s []float）。如果想要獲取float類型的切片中的最大元素，則需要再寫一個函數(shù)：

func MaxFloat(s []float) float {
	//...
}

傳統(tǒng)的編寫方式的缺點就是需要針對每一種類型都要編寫一個函數(shù)，除了函數(shù)的參數(shù)中的類型不一樣，其他邏輯完全一樣。

接下來我們看看使用泛型的寫法。

1.2 泛型函數(shù)編寫方式

為了能夠使編寫的程序更具有可復(fù)用性，通用編程（Generic programming）也應(yīng)運而生。使用泛型，函數(shù)或類型可以基于類型參數(shù)進行定義，并在調(diào)用該函數(shù)時動態(tài)指定具體的類型對其進行實例化，以達到函數(shù)或類型可以基于一組定義好的類型都能使用的目的。我們通過泛型將上述Max函數(shù)進行改寫：

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

// 定義泛型函數(shù)
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函數(shù)，在main函數(shù)中調(diào)用MaxNumber時，通過傳入一個具體的類型就能復(fù)用MaxNumber的代碼了。

好了，這里我們只是對泛型有了一個初探，至于泛型函數(shù)中的T和any等關(guān)鍵詞暫時不用關(guān)系，在后面我們會詳細講解。

接下來我們從泛型被加入之前說起，從而更好的的理解泛型被加入的動機。

02 從泛型被加入之前說起

為了更好的理解為什么需要泛型，我們看看如果不使用泛型如何實現(xiàn)可復(fù)用的算法。還是以上面的返回切片中元素的最大值函數(shù)為例。

為了能夠針對切片中不同的數(shù)據(jù)類型都可以復(fù)用，我們一般有以下幾種方案：

• 針對每一種類型編寫一套重復(fù)的代碼

• 傳遞一個空接口interface{}，使用類型斷言來判斷是哪種數(shù)據(jù)類型

• 傳遞一個空接口interface{}，使用反射機制來判斷是哪種數(shù)據(jù)類型

• 自定義接口類型，通過類型繼承的方式實現(xiàn)具體邏輯

下面我們看上面每一種實現(xiàn)方法都有哪些缺點。

2.1 針對每一種類型編寫一套重復(fù)的代碼

這種方法我們在第一節(jié)中已經(jīng)實現(xiàn)了。針對int切片和float切片各自實現(xiàn)一個函數(shù)，但在兩個函數(shù)中只有切片的數(shù)據(jù)類型不同，其他邏輯都相同。

這種方法的主要缺點就是大量的重復(fù)代碼。這兩個函數(shù)中除了切片元素的數(shù)據(jù)類型不同之外，其他都一樣。同時，大量重復(fù)的代碼也降低了代碼的可維護性。

2.2 使用空接口并通過類型斷言來判定具體的類型

另外一種方法是函數(shù)接收一個空接口的參數(shù)。在函數(shù)內(nèi)部使用類型斷言和switch語句來選擇是哪種具體的類型。最后將結(jié)果再包裝到一個空接口中返回。如下：

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

這種寫法的主要有兩個缺點。第一個缺點是在編譯期間缺少類型安全檢查。如果調(diào)用者傳遞了一個不支持的數(shù)據(jù)類型，該函數(shù)的實現(xiàn)應(yīng)該是返回一個錯誤。第二個缺點是這種實現(xiàn)的可用性也不是很好。因為無論是調(diào)用者處理返回值還是在函數(shù)內(nèi)部的實現(xiàn)代碼都需要將具體的類型包裝在一個空接口中，并使用類型斷言來判斷接口里的具體的類型。

2.3 傳遞空接口并使用反射解析具體類型

在從空接口中解析具體的類型時，我們還可以通過反射替代類型斷言。如下實現(xiàn)：

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

在這種方法中，在編譯期間不僅沒有類型的安全檢查，同時可讀性也差。而且在使用反射時，性能通常也會比較差。

2.4 通過自定義接口類型實現(xiàn)

另外一種方法，我們可以通過給函數(shù)傳遞一個具體的，預(yù)定義好的接口來實現(xiàn)。該接口應(yīng)該包含該函數(shù)要實現(xiàn)的功能的必備方法。只要實現(xiàn)了該接口的類型，該方法就都可以支持。我們還是以上面的MaxNumber函數(shù)為例，應(yīng)該有獲取元素個數(shù)的方法Len，比較大小的方法Less以及獲取元素的方法Elem。我們來看看具體的實現(xiàn)：

type ComparableSlice interface {
    // 返回切片的元素個數(shù).
    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}))

在該實現(xiàn)中，我們定義了一個ComparableSlice接口，其中ComparableIntSlice和ComparableFloat64Slice兩個具體的類型都實現(xiàn)了該接口，分別對應(yīng)int類型切片和float64類型切片。

該實現(xiàn)的一個明顯的缺點是難以使用。因為調(diào)用者必須將數(shù)據(jù)封裝到一個自定義的類型中（在該示例中是ComparableIntSlice和ComparableFloat64Slice），并且該自定義類型要實現(xiàn)已定義的接口ComparableSlice。

由以上示例可知，在有泛型功能之前，要想在Go中實現(xiàn)處理多種類型的可復(fù)用的函數(shù)，都會帶來一些問題。而泛型機制正是避免上述各種問題的解決方法。

03 深入理解泛型--泛型使用“三步曲”

在文章第一節(jié)處我們已經(jīng)提到過泛型要解決的問題--程序針對一組類型可進行復(fù)用。下面我們給出泛型函數(shù)的一般形式，如下圖：

由上圖的泛型函數(shù)的一般定義形式可知，使用泛型可以分三步，我將其稱之為“泛型使用三步曲”。

3.1 第一步：類型參數(shù)化

在定義泛型函數(shù)時，使用中括號給出類型參數(shù)類型，并在函數(shù)所接收的參數(shù)中使用該類型參數(shù)，而非具體類型，就是所謂的類型參數(shù)化。還是以上面的泛型函數(shù)為例：

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被稱為類型參數(shù)，即不再是一個具體的類型值，而是需要在調(diào)用該函數(shù)時再動態(tài)的傳入一個類型值（例如int，float64），以實例化化T。例如：Max[int](s[]int{4,-8,15})，那么T就代表的是int。

當(dāng)然，類型參數(shù)列表中可以有多個類型參數(shù)，多個類型參數(shù)之間用逗號隔開即可。類型參數(shù)名也不一定非要用T，任何符合變量規(guī)則的名稱都可以。

3.2 第二步：給類型添加約束

在上圖中，any被稱為是類型約束，用來描述傳給T的類型值應(yīng)該滿足什么樣的條件，不滿足約束的類型傳給T時會被報編譯錯誤，這樣就實現(xiàn)了類型的安全機制。當(dāng)然類型約束不僅僅像any這么簡單。

在Go中類型約束分兩類，分別是Go官方支持的內(nèi)建類型約束（包括內(nèi)建的類型約束any、comparable和在golang.org/x/exp/constraints 包中定義的類型約束）和自定義類型約束。因為在Go中泛型的約束是通過接口來實現(xiàn)的，所以我們可以通過定義接口來自定義類型約束。

3.2.1 Go官方支持的內(nèi)建類型約束

其中Go內(nèi)建的類型約束和constraints包定義的類型約束我們統(tǒng)一成為Go官方定義的類型約束。之所以是在golang.org/x/exp/constraints包中，是因為該約束帶有實驗性質(zhì)。

下面我們列出了Go官方支持的預(yù)定義的類型約束：

在上表中，我們看到的符號~。~T意思是說底層類型是T的類型。例如~int代表的是底層類型是int的類型。這個我們在下一節(jié)自定義類型約束一節(jié)有詳細介紹和示例。

3.2.2 自定義類型約束

由上面可知，類型的約束本質(zhì)上是一個接口。所以，如果官方提供的類型約束不滿足自己的業(yè)務(wù)場景下，可以按照Go中泛型的語法規(guī)則自定義類型約束即可。類型約束的定義一般有兩種形式：

• 定義成接口形式

• 直接定義在類型參數(shù)列表中

下面我們分別來看下各自的使用方法。

• 定義成接口形式

下面是定義成接口形式的類型約束示例：

// 自定義類型約束接口StringableFloat
type StringableFloat interface {
    ~float32 | ~float64 // 底層是float32或float64的類型就能滿足該約束
    String() string
}

// MyFloat 是滿足StringableFloat類型約束的float類型。
type MyFloat float64 

// 實現(xiàn)類型約束中的String方法
func (m MyFloat) String() string {
    return fmt.Sprintf("%e", m)
}

//泛型函數(shù)，對類型參數(shù)T使用了StringableFloat約束
func StringifyFloat[T StringableFloat](f T) string {
    return f.String()
}
// Usage
var f MyFloat = 48151623.42

//使用MyFloat類型對T進行實例化
s := StringifyFloat[MyFloat](f)

在該示例中，函數(shù)StringifyFloat是一個泛型函數(shù)，并使用StringableFloat接口來對T進行約束。MyFloat類型是一個滿足StringableFloat約束的具體類型。

在泛型中，類型約束被定義成了接口，該接口中可以包含具體類型的集合和方法。在該示例中，StringfyFloat類型約束包含float32和float64兩個類型以及一個String()方法。該約束允許任何滿足該接口的具體類型都可以實例化參數(shù)T。

在上述示例中，我們還看到一個新的關(guān)鍵符號：~。~T代表所有的類型的底層類型必須是類型T。在這里類型MyFloat是一個自定義的類型，但其底層類型或叫做基礎(chǔ)類型是float64。因此，MyFloat是滿足StringifyFloat約束的。

另外，在定義類型約束接口中，也可以引入類型參數(shù)。如下示例中，在類型約束SliceConstraints中的切片類型引入了類型參數(shù)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)
}

// 定義類型約束，并引入類型參數(shù)E
type SliceConstraint[E any] interface {
    ~[]E
}

// 泛型函數(shù)
func FirstElem1[S SliceConstraint[E], E any](s S) E {
	return s[0]
}

• 在類型參數(shù)列表中直接定義約束

下面的示例中，F(xiàn)irstElem2、FirstElem3泛型函數(shù)將類型約束直接定義在了類型參數(shù)列表中，我把它稱之為匿名類型約束接口，類似于匿名函數(shù)。如下示例代碼，三個泛型函數(shù)是等價的：

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

3.3 第三步：類型參數(shù)實例化

在調(diào)用泛型函數(shù)時，需要給函數(shù)的類型參數(shù)指定具體的類型，叫做類型實例化。在類型實例化過程中有時候是不需要指定的具體的類型，這時在編譯階段，編譯器會根據(jù)函數(shù)的參數(shù)自動推導(dǎo)出來T的實際參數(shù)值。如下：

類型參數(shù)實例化就比較簡單了，就是在調(diào)用泛型函數(shù)時要給泛型函數(shù)的類型參數(shù)傳遞一個具體的類型。就像第一步中調(diào)用Max函數(shù)時指定的一樣：r2 := Max[int]([]int{4, 8, 15})，這里Max后面中括號中的int就是類型實參，這樣Max函數(shù)就能知道處理的切片元素的具體類型了。

這里還有一點需要注意，在類型參數(shù)實例化時，還有方式是不需要指定具體的類型，這時在編譯階段，編譯器會根據(jù)函數(shù)的參數(shù)自動推導(dǎo)出來T的實際參數(shù)值： r3 := Max([]float64{4.1, -8.1, 15.1})。這里Max后面并沒有給出中括號以及對應(yīng)的具體類型，但Go編譯器能根據(jù)切片元素類型自動推斷出是float64類型。

04 泛型類型約束和普通接口的區(qū)別

首先二者都是接口，都可以定義方法。但類型約束接口中可以定義具體類型，例如上文中自定義的StringableFloat類型約束接口中的類型約束：~float32 | ~float64

type StringableFloat interface {
    ~float32 | ~float64 // 底層是float32或float64的類型就能滿足該約束
    String() string
}

當(dāng)接口中存在類型約束時，這時該接口就只能被用于泛型類型參數(shù)的約束。

到此，相信大家對“Go1.18新特性之泛型怎么使用”有了更深的了解，不妨來實際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進入相關(guān)頻道進行查詢，關(guān)注我們，繼續(xù)學(xué)習(xí)！