Go1.18新特性之泛型使用三步曲(小結)

2022-04-19 19:02:28

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 從泛型被加入之前說起

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

為了能夠針對切片中不同的資料型別都可以複用，我們一般有以下幾種方案：

針對每一種型別編寫一套重複的程式碼
傳遞一個空介面interface{}，使用型別斷言來判斷是哪種資料型別
傳遞一個空介面interface{}，使用反射機制來判斷是哪種資料型別
自定義介面型別，通過型別繼承的方式實現具體邏輯

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

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官方支援的預定義的型別約束：

約束	描述	位置
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]
}

3.3 第三步：型別引數範例化

在呼叫泛型函數時，需要給函數的型別引數指定具體的型別，叫做型別範例化。在型別範例化過程中有時候是不需要指定的具體的型別，這時在編譯階段，編譯器會根據函數的引數自動推匯出來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型別。

04 泛型型別約束和普通介面的區別

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

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

當介面中存在型別約束時，這時該介面就只能被用於泛型型別引數的約束。

總結

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

到此這篇關於Go1.18新特性之泛型使用三步曲(小結)的文章就介紹到這了,更多相關Go1.18 泛型內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！