1.截取法（修改原切片）

这里利用对 slice 的截取删除指定元素。注意删除时，后面的元素会前移，所以下标 i 应该左移一位。

// DeleteSlice1 删除指定元素。
func DeleteSlice1(s []int, elem int) []int {
    for i := 0; i < len(s); i++ {
        if s[i] == elem {
            s = append(s[:i], s[i+1:]...)
            i--
        }
    }
    return s
}

注意，遍历切片时，不能使用for i := range s，否则会出现越界错误。

切片 s 在遍历前已经做了拷贝，注意不是 s 底层元素拷贝，而是切片 s 值拷贝，我们姑且称之为 s'。所以即便 s 发生改变且 i--，下次循环时，i 仍被正确地赋为切片 s' 下一个元素的下标。

因为 s 越来越短，s' 的长度不变，当通过下标 i 访问 s 时，便出现越界错误。

我们再看一个问题。下面的遍历会停止吗？

s := []int{1, 2, 3}
for i := range s {
    s = append(s, i)
}

答案是会停止。同样的道理，循环是对修改前 s 的遍历，而不是对修改后 s 的遍历。最终切片 s 内容为 [1, 2, 3, 0, 1, 2]。

2.拷贝法（不改原切片）

这种方法最容易理解，重新使用一个 slice，将要删除的元素过滤掉。缺点是需要开辟另一个 slice 的空间，优点是容易理解，而且不会修改原 slice。

// DeleteSlice2 删除指定元素。
func DeleteSlice2(s []int, elem int) []int {
    r := make([]int, 0, len(s))
    for _, v := range s {
        if v != elem {
            r = append(r, v)
        }
    }
    return r
}

3.移位法（修改原切片）

3.1 方式一

利用一个下标 index，记录下一个有效元素应该在的位置。遍历所有元素，当遇到有效元素，将其移动到 index 且 index 加一。最终 index 的位置就是所有有效元素的下一个位置，最后做一个截取就行了。这种方法会修改原来的 slice。

该方法可以看成对第一种方法截取法的改进，因为每次指需移动一个元素，性能更加。

// DeleteSlice3 删除指定元素。
func DeleteSlice3(s []int, elem int) []int {
    j := 0
    for _, v := range s {
        if v != elem {
            s[j] = v
            j++
        }
    }
    return s[:j]
}

3.2 方式二

创建了一个 slice，但是共用原始 slice 的底层数组。这样也不需要额外分配内存空间，直接在原 slice 上进行修改。

// DeleteSlice4 删除指定元素。
func DeleteSlice4(s []int, elem int) []int {
    r := s[:0]
    for _, v := range s {
        if v != elem {
            r = append(r, v)
        }
    }
    return r
}

4.性能对比

假设我们的切片有 0 和 1，我们要删除所有的 0。

这里分别对长度为 10、100、1000 的切片进行测试，来上下上面四种实现的性能差异。

生成切片函数如下：

func getSlice(n int) []int {
    a := make([]int, 0, n)
    for i := 0; i < n; i++ {
        if i%2 == 0 {
            a = append(a, 0)
            continue
        }
        a = append(a, 1)
    }
    return a
}

基准测试代码如下：

func BenchmarkDeleteSlice1(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = DeleteSlice1(getSlice(10), 0)
    }
}
func BenchmarkDeleteSlice2(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = DeleteSlice2(getSlice(10), 0)
    }
}
func BenchmarkDeleteSlice3(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = DeleteSlice3(getSlice(10), 0)
    }
}
func BenchmarkDeleteSlice4(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = DeleteSlice4(getSlice(10), 0)
    }
}

测试结果如下：原切片长度为 10：

go test -bench=. main/slice
goos: windows
goarch: amd64
pkg: main/slice
cpu: Intel(R) Core(TM) i7-9700 CPU @ 3.00GHz
BenchmarkDeleteSlice1-8         17466486                65.07 ns/op
BenchmarkDeleteSlice2-8         14897282                85.22 ns/op
BenchmarkDeleteSlice3-8         21952129                50.78 ns/op
BenchmarkDeleteSlice4-8         22176390                54.68 ns/op
PASS
ok      main/slice      5.427s

原切片长度为 100：

BenchmarkDeleteSlice1-8          1652146               762.1 ns/op
BenchmarkDeleteSlice2-8          2124237               578.4 ns/op
BenchmarkDeleteSlice3-8          3161318               359.9 ns/op
BenchmarkDeleteSlice4-8          2714158               423.7 ns/op

原切片长度为 1000：

BenchmarkDeleteSlice1-8            56067             21915 ns/op
BenchmarkDeleteSlice2-8           258662              5007 ns/op
BenchmarkDeleteSlice3-8           432049              2724 ns/op
BenchmarkDeleteSlice4-8           325194              3615 ns/op

5.小结

从基准测试结果来看，性能最佳的方法是移位法，其中又属第一种实现方式较佳。性能最差的也是最常用的方法是截取法。随着切片长度的增加，上面四种删除方式的性能差异会愈加明显。

实际使用时，我们可以根据不用场景来选择。如不能修改原切片使用拷贝法，可以修改原切片使用移位法中的第一种实现方式。

6.切片删除指定元素