深入淺出 Go 泛型之泛型使用三步曲

大家好，我是漁夫子，又跟大家見面了。今天跟大家聊聊 Go1.18 中新增的泛型功能。。

01 Go 中的泛型是什麼

衆所周知，Go 是一門靜態類型的語言。靜態類型也就意味着在使用 Go 語言編程時，所有的變量、函數參數都需要指定具體的類型，同時在編譯階段編譯器也會對指定的數據類型進行校驗。這也意味着一個函數的輸入參數和返回參數都必須要和具體的類型強相關，不能被不同類型的數據結構所複用。

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

泛型是靜態語言中的一種編程方式。這種編程方式可以讓算法不再依賴於某個具體的數據類型，而是通過將數據類型進行參數化，以達到算法可複用的目的。

下面，我們通過一個函數的傳統編寫方式和泛型編寫方式先來體驗一下。

1.1 傳統的函數編寫方式

例如，我們有一個函數 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 {
    //...
}

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

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

1.2 泛型函數編寫方式

爲了能夠使編寫的程序更具有可複用性，通用編程（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等關鍵詞暫時不用關係，在後面我們會詳細講解。

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

02 從泛型被加入之前說起

爲了更好的理解爲什麼需要泛型，我們看看如果不使用泛型如何實現可複用的算法。還是以上面的返回切片中元素的最大值函數爲例。

我們一般有以下幾種方案：

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

2.1 針對每一種類型編寫一套重複的代碼

這種方法我們在第一節中已經實現了。針對 int 切片和 float 切片各自實現一個函數，但在兩個函數中只有切片的數據類型不同，其他邏輯都相同。

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

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

另外一種方法是函數接收一個空接口的參數。在函數內部使用類型斷言和 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})

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

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

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

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 通過自定義接口類型實現

另外一種方法，我們可以通過給函數傳遞一個具體的，預定義好的接口來實現。該接口應該包含該函數要實現的功能的必備方法。只要實現了該接口的類型，該方法就都可以支持。我們還是以上面的 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 中實現處理多種類型的可複用的函數，都會帶來一些問題。而泛型機制正是避免上述各種問題的解決方法。

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

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

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

3.1 第一步：類型參數化

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

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，任何符合變量規則的名稱都可以。

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

在上圖中，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 官方支持的預定義的類型約束：

7AYDfn

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

3.3 第三步：類型參數實例化

在調用泛型函數時，需要給函數的類型參數指定具體的類型，叫做類型實例化。還是以上面的 Max 函數爲例，我們在 Max 後面的中括號中指定了 int 類型：

r2 := Max[int]([]int{4, 8, 15})

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

04 泛型類型約束和普通接口的區別

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

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

當接口中存在類型約束時，這時該接口就只能被用於泛型類型參數的約束。

05 總結

泛型在 Go1.18 中才被加入實際上是有其原因的。之前一直都有泛型的提案，但一直沒被加入到該語言中，其中一個很重要的原因就是因爲之前的泛型提案不夠簡單。而 Go 又是以簡單著稱的語言，所以只有泛型的實現方案足夠簡單，同時對 Go 之前的版本又兼容時才被加入進來。

歡迎關注「Go 學堂」，讓知識活起來

Go 學堂 專注 Go 編程知識和案例。分享編程思想、編程技巧和實例應用

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/1qtAMerSS3hqCLVlXf670Q

猜你喜歡