Go泛型系列:slices 包讲解

大家好,我是 polarisxu。

前段时间,Russ Cox 明确了泛型相关的事情 ,原计划在标准库中加入泛型相关的包,改放到 golang.org/x/exp 下。

目前,Go 泛型的主要设计者 ianlancetaylor 完成了 slices 和 maps 包的开发,代码提交到了 golang.org/x/exp 中,如果经过使用、讨论等,社区认可后,预计在 1.19 中会合入标准库中。

今天,通过学习 slices 包,掌握 Go 泛型的使用方法。

01 为什么增加 slices 包

标准库有 bytes 和 strings 包,分别用来处理 []byte 和 string 类型,提供了众多方便的函数,但对普通的 slice,却没有相关的包可以使用。

比如 bytes 和 strings 都有 Index 函数,用来在 []byte 或 string 查找某个 byte 或字符串的索引。对于普通的 slice,没法写一大堆包来处理,只能用户自己实现,这也是没有泛型的弊端。

提供 bytes 和 strings,主要是因为它们使用频率高

现在有了泛型,可以实现一些便利的 slice 操作方法,必须要针对某一个具体类型的 slice 都实现一遍相同的功能。

02 constraints 包

继续讲解 slices 包之前,先看看 contraints 包。

该包定义了一组用于类型参数(泛型)的有用约束,这个包已经确定在 Go 1.18 标准库中包含,截止目前(2021.11.27),该包定义了 6 个约束类型:

// Signed is a constraint that permits any signed integer type.
// If future releases of Go add new predeclared signed integer types,
// this constraint will be modified to include them.
type Signed interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64
}

// Unsigned is a constraint that permits any unsigned integer type.
// If future releases of Go add new predeclared unsigned integer types,
// this constraint will be modified to include them.
type Unsigned interface {
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

// Integer is a constraint that permits any integer type.
// If future releases of Go add new predeclared integer types,
// this constraint will be modified to include them.
type Integer interface {
	Signed | Unsigned
}

// Float is a constraint that permits any floating-point type.
// If future releases of Go add new predeclared floating-point types,
// this constraint will be modified to include them.
type Float interface {
	~float32 | ~float64
}

// Complex is a constraint that permits any complex numeric type.
// If future releases of Go add new predeclared complex numeric types,
// this constraint will be modified to include them.
type Complex interface {
	~complex64 | ~complex128
}

// Ordered is a constraint that permits any ordered type: any type
// that supports the operators < <= >= >.
// If future releases of Go add new ordered types,
// this constraint will be modified to include them.
type Ordered interface {
	Integer | Float | ~string
}

前面 3 个是整型相关类型约束,Float 是浮点型约束,Complex 是负数类型约束,而 Ordered 表示支持排序的类型约束,表示支持大小比较的类型。

之前文章:《Go泛型系列:Go1.18 类型约束那些事》 提到,约束语法变更了,一个是 | 符号,一个是 ~,上面定义中,很多地方都用到了 ~ 符号,它表示出了类型自身,底层类型是它的类型也适用该约束。

03 slices 包详解

目前,slices 包有 14 个函数,可以分成几组:

  • slice 比较
  • 元素查找
  • 修改 slice
  • 克隆 slice

其中,修改 slice 分为插入元素、删除元素、连续元素去重、slice 扩容和缩容。

slice 比较

比较两个 slice 中的元素,细分为是否相等和普通比较:

func Equal[E comparable](s1, s2 []E) bool
func EqualFunc[E1, E2 any](s1 []E1, s2 []E2, eq func(E1, E2) bool) bool
func Compare[E constraints.Ordered](s1, s2 []E) int
func CompareFunc[E1, E2 any](s1 []E1, s2 []E2, cmp func(E1, E2) int) int

其中 comparable 约束是语言实现的(因为很常用),表示可比较约束(相等与否的比较)。主要,其中的 E、E1、E2 等,只是泛型类型表示,你定义时,可以用你喜欢的,比如 T、T1、T2 等。

看一个具体的实现:

func Equal[E comparable](s1, s2 []E) bool {
	if len(s1) != len(s2) {
		return false
	}
	for i, v1 := range s1 {
		v2 := s2[i]
		if v1 != v2 {
			return false
		}
	}
	return true
}

没有什么特别的,只不过把 s1、s2 当成同类型的 slice 进行操作而已。

元素查找

在 slice 中查找某个元素,分为普通的所有查找和包含判断:

func Index[E comparable](s []E, v E) int
func IndexFunc[E any](s []E, f func(E) bool) int
func Contains[E comparable](s []E, v E) bool

其中,IndexFunc 的类型参数没有使用任何约束(即用的 any),说明查找是通过 f 参数进行的,它的实现如下:

func IndexFunc[E any](s []E, f func(E) bool) int {
	for i, v := range s {
		if f(v) {
			return i
		}
	}
	return -1
}

参数 f 是一个函数,它接收一个参数,类型是 E,是一个泛型,和 IndexFunc 的第一个参数类型 []E 的元素类型保持一致即可,因此可以直接将遍历 s 的元素传递给 f。

修改 slice

一般不建议做相关操作,因为性能较差。如果有较多这样的需求,可能需要考虑更换数据结构。

// 往 slice 的位置 i 处插入元素(可以多个)
func Insert[S ~[]E, E any](s S, i int, v ...E) S
// 删除 slice 中 i 到 j 的元素,即删除 s[i:j] 元素
func Delete[S ~[]E, E any](s S, i, j int) S
// 将连续相等的元素替换为一个,类似于 Unix 的 uniq 命令。Compact 修改切片的内容,它不会创建新切片
func Compact[S ~[]E, E comparable](s S) 
func CompactFunc[S ~[]E, E any](s S, eq func(E, E) bool) S
// 增加 slice 的容量,至少增加 n 个
func Grow[S ~[]E, E any](s S, n int) S
// 移除没有使用的容量,相当于缩容
func Clip[S ~[]E, E any](s S) S

以上类型约束都包含了两个:

  • S ~[]E:表明这是一个泛型版 slice,这是对 slice 的约束。注意 [] 前面的 ~,表明支持自定义 slice 类型,如 type myslice []int
  • E any 或 E comparable:对上面 slice 元素类型的约束。

克隆 slice

即获得 slice 的副本,会进行元素拷贝,注意,slice 中元素的拷贝是浅拷贝,非值类型不会深拷贝。

func Clone[S ~[]E, E any](s S) S {
	// Preserve nil in case it matters.
	if s == nil {
		return nil
	}
	return append(S([]E{}), s...)
}

04 总结

因为泛型的存在,同样的功能,对不同类型的 slice 再也不用写多份代码。因为一些功能很常见,因此 Go 官方将其封装,将来会在标准库中提供。

出于谨慎考虑,slices 包不会在 1.18 中包含,如果你需要用到 slices 中的功能,可以采用从 slices 代码中复制的方式,个人觉得依赖 golang.org/x/exp 还是不太好。

slices 源码地址:https://github.com/golang/exp/blob/master/slices/slices.go



Go泛型

1932 字

2021-11-27 20:30 +0800