前言
Go是一门使用比较简单的编程语言，以其天生支持高并发的特点深受程序员们的欢迎。语法简单的同时，也时常需要自己封装一些函数或者方法，本身较少地提供了高级API。
比如定义一个切片：
var s = []string{"abc", "123", "abc", ..., "abc", "123"}
现在需要删除这个切片所有的字符串"abc"，没有捷径，只能循环查找abc的索引（下标），然后通过子切片的方式逐一删除。伪代码如下：
for {
idx := findIndex(s, "abc")
if idx == -1 {
break
} else {
removeByIndex(s, idx)
}
}
问题很严峻
1）没有封装的话，每个切片都得重复写这段代码，简直是不可接受的。另外findIndex和removeByIndex两个函数，也需要实现一下。
2）这只是以字符串切片为例，如果是int/float/自定义的struct切片，怎么办？复制一份代码，修改参数类型，这也是不可接受的。
怎么办？
问题1：我们可以封装函数，如
func Remove(s []string, tar string){
...
}
这样封装，只能用在字符串切片上，显然不够完美，go 1.18引入了泛型，那让这个函数支持泛型，是可以的：
func Remove[T any](s []T, tar T){
...
}
理论上可行了，别忘了我们还需要实现FindIndex这个函数，由于T的范围是any，所以没有办法用 == 去判断相等
func FindIndex[T any](s []T, tar T) int {
for i, e := range s {
if e == tar { // 编译报错
return i
}
return -1
}
所以这里我们需要传入一个匿名函数，让上层确定FindIndex的规则。所以FindIndex的方法就变成这样：
func FindIndex[T any](s []T, compare func(t T) bool) int {
for i, e := range s {
if compare(e) {
return i
}
return -1
}
// 相应的remove的函数签名得是这样：
func Remove[T any](s []T, compare func(t T) bool){
...
}
到这里应该是可以用了。
升华
上述内容还是典型的面向过程思维，我们要让程序看着更“面向对象”一些。所以我们封装一个“泛型类”，go里面没有类的叫法，所以叫泛型机构体，定义很简单，
type Slice[T any] []T
//同时给它配个“构造函数”
func NewSlice[T any]() *Slice[T] {
s := make(Slice[T], 0)
return &s
}
//再配个Append方法，让它可以被追加元素
func (s *Slice[T]) Append(t ...T) {
*s = append(*s, t...)
}
实现FindIndex方法，
func (s *Slice[T]) FindIndex(compare func(t T) bool) int {
for i, e := range *s {
if compare(e) {
// 由于T的范围是any, 无法简单地判断t==e, 故需传入比较函数
return i
}
}
return -1
}
实现Remove方法，
func (s *Slice[T]) Remove(compare func(t T) bool) {
for {
idx := s.FindIndex(compare)
if idx == -1 {
break
} else {
*s = append((*s)[:idx], (*s)[idx+1:]...)
}
}
}
测试一下：
// 实例化
s := NewSlice[string]()
// 往切片里追加元素
s.Append("abc", "123", "xyz", "abc", "ABC")
// 定义一个匿名函数，指定要删除的元素
toDel := func(s string) bool { return strings.ToUpper(s)=="ABC"}
// 调用删除方法
s.Remove(toDel)
总结
这里以删除指定元素为例说明泛型切片封装的一般思路，其他功能也可以采用相同的思路，举一隅以三隅反吧。