go语言泛型Generic最佳实践 --- slices包

在go的内置包slices中， 所有的函数函数都使用了泛型， 各种各样的泛型， 可以说这个包绝对是go语言泛型学习的最佳实践之一！

来，先来瞄一眼，看看这个slices包里面的函数原型定义：

func BinarySearch[S ~[]E, E cmp.Ordered](x S, target E) (int, bool)
func BinarySearchFunc[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool)
func Clip[S ~[]E, E any](s S) S
func Clone[S ~[]E, E any](s S) S
func Compact[S ~[]E, E comparable](s S) S
func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S
func Compare[S ~[]E, E cmp.Ordered](s1, s2 S) int
func CompareFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int
func Concat[S ~[]E, E any](slices ...S) S
func Contains[S ~[]E, E comparable](s S, v E) bool
func ContainsFunc[S ~[]E, E any](s S, f func(E) bool) bool
func Delete[S ~[]E, E any](s S, i, j int) S
func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S
func Equal[S ~[]E, E comparable](s1, s2 S) bool
func EqualFunc[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool
func Grow[S ~[]E, E any](s S, n int) S
func Index[S ~[]E, E comparable](s S, v E) int
func IndexFunc[S ~[]E, E any](s S, f func(E) bool) int
func Insert[S ~[]E, E any](s S, i int, v ...E) S
func IsSorted[S ~[]E, E cmp.Ordered](x S) bool
func IsSortedFunc[S ~[]E, E any](x S, cmp func(a, b E) int) bool
func Max[S ~[]E, E cmp.Ordered](x S) E
func MaxFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E
func Min[S ~[]E, E cmp.Ordered](x S) E
func MinFunc[S ~[]E, E any](x S, cmp func(a, b E) int) E
func Replace[S ~[]E, E any](s S, i, j int, v ...E) S
func Reverse[S ~[]E, E any](s S)
func Sort[S ~[]E, E cmp.Ordered](x S)
func SortFunc[S ~[]E, E any](x S, cmp func(a, b E) int)
func SortStableFunc[S ~[]E, E any](x S, cmp func(a, b E) int)

怎么样，是不是全部都是清一色的泛型函数？

来，我们先拿第一个大名鼎鼎的二分查找函数来说说

func BinarySearch[S ~[]E, E cmp.Ordered](x S, target E) (int, bool)

这个函数里面定义了S E泛型约束  [S ~[]E, E cmp.Ordered]  这个的意思就是 参数S 的底层类型必须是切片E, 同时 E类型必须是已排序的切片。

分解：

S ~[]E 约束S类型的底层类型必须是E的切片

E cmp.Ordered  这个约束E的类型必须是已排序的类型， 这里的emp.Ordered是一个专门用来做参数类型约束的接口定义。

E cmp.Ordered接口定义如下：

type Ordered interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~string
}

可见这个 cmp.Ordered 接口定义了他所能接收的参数类型列表，只要泛型约束里面使用了他， 那你的参数的类型就只能是这个里面定义的类型之一。

再来一个

func SortFunc[S ~[]E, E any](x S, cmp func(a, b E) int)

这个函数的泛型约束[S ~[]E, E any]里面 有一个 any  , 这个在go语言里面表示任意类型， 他是一个类型定义，即 type any = interface{}  ,  其他和上一个的泛型约束类似。

另外一个需要说的就是 comparable 这个泛型约束， 这个也是一个类型定义，即 type comparable interface{ comparable }  ，  comparable这个泛型约束是go语言的底层定义的一个约束接口，他约束数据类型必须是这些类型之一： booleans, numbers, strings, pointers, channels,  可比较类型的数组，所有字段是可比较类型的结构体

函数原型： func Index[S ~[]E, E comparable](s S, v E) int

示例代码：

package main

import (
	"fmt"
	"slices"
)

func main() {
	numbers := []int{0, 42, 8}
	fmt.Println(slices.Index(numbers, 8))
	fmt.Println(slices.Index(numbers, 7))
}

参考：

slices package - slices - Go Packages