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。
