前言

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)

总结

这里以删除指定元素为例说明泛型切片封装的一般思路，其他功能也可以采用相同的思路，举一隅以三隅反吧。