Go语言Slice删除元素的三种方式及性能对比

准备测试环境与代码

为了准确评估不同删除策略的性能，我们需要在一个稳定的环境中运行 Benchmark 测试。本次测试在一台 MacBook Pro (Intel i5, 8GB RAM) 上进行，以确保结果的可参考性。测试的核心在于比较在处理包含10个整数的小型切片时，不同逻辑下的耗时与内存分配情况。

我们设定了一个基础切片 origin 用于存放初始数据，并定义一个目标值 targetEle 作为需要移除的元素。以下是三种常见删除方法的 Go 代码实现：

package benchmark

import (
    "testing"
)

var (
    // 原始slice
    origin = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    // 需要删除的元素
    targetEle = 6
)

// 第一种：创建新切片进行过滤
func BenchmarkMake(t *testing.B) {
    t.ResetTimer()
    for i := 0; i < t.N; i++ {
        target := make([]int, 0, len(origin))
        for _, item := range origin {
            if item != targetEle {
                target = append(target, item)
            }
        }
    }
}

// 第二种：复用底层数组
func BenchmarkReuse(t *testing.B) {
    t.ResetTimer()
    for i := 0; i < t.N; i++ {
        target := origin[:0]
        for _, item := range origin {
            if item != targetEle {
                target = append(target, item)
            }
        }
    }
}

// 第三种：原地遍历修改
func BenchmarkEditOne(t *testing.B) {
    t.ResetTimer()
    for i := 0; i < t.N; i++ {
        for j := 0; j < len(origin); j++ {
            if origin[j] == targetEle {
                origin = append(origin[:j], origin[j+1:]...)
                j-- // 修正索引以保持正确遍历
            }
        }
    }
}

执行Benchmark测试结果

使用以下命令在终端中运行性能测试，观察各个函数的平均单次执行时间和内存分配次数：

go test -v -bench=. -benchtime=3s -benchmem

运行结果摘要：

• BenchmarkMake-4: 95345845 ops, 35.8 ns/op, 80 B/op, 1 allocs/op
• BenchmarkReuse-4: 255912920 ops, 14.4 ns/op, 0 B/op, 0 allocs/op
• BenchmarkEditOne-4: 473434452 ops, 7.56 ns/op, 0 B/op, 0 allocs/op

结果分析与总结

通过上述 Benchmark 结果，我们可以清晰地看到三种处理方式在性能上的巨大差异，这主要源于内存管理的机制：

• BenchmarkMake（新建切片法）：
  这是最直观的做法，创建一个全新的切片，将非目标元素逐个 append 进去。
  特点： 保留了原始 slice 的不变性，但会产生额外的内存分配（80 Bytes），导致速度最慢（35.8 ns/op）。适合必须保留原数据场景。
• BenchmarkReuse（复用内存法）：
  利用 origin[:0] 创建一个指向原底层数组的新切片（长度归零，容量不变），随后同样使用 append。
  特点： 没有触发新的内存分配（0 allocs/op），因为复用了原有空间。速度提升明显（14.4 ns/op），且同样会修改原底层数组中的数据。
• BenchmarkEditOne（原地覆盖法）：
  直接遍历原切片，找到目标元素后，利用 append 的特性将后面的元素向前移位覆盖。
  特点： 这是最快的方法（7.56 ns/op），完全没有内存分配开销。原理是将待删元素之后的所有元素拷贝到其位置，本质上也是对底层数组的直接操作。

排错与注意事项

在使用后两种“修改原数组”的方法时，务必确认业务逻辑允许修改原始 Slice 的内部状态。如果其他地方仍有引用指向该切片或其子切片，数据被意外清空或移位可能导致不可预知的 Bug。若追求极致性能且不依赖原始数据完整性，推荐使用 EditOne 方式；若仅需复用内存且代码更简洁，Reuse 方式是良好的折中选择。

以上就是Golang中slice删除元素的性能对比的详细分析，更多关于Go语言高性能编程技巧的资料请关注本站其它相关文章！