Golang比较两个slice是否相等

比较两个slice包含的元素是否完全相等的情况：

• reflect.DeepEqual
• 循环遍历

通常reflect的方法性能都比较低，在此使用Benchmark测试两种方法的性能，以明确具体性能差异。

两种方式的实现

新建文件： path/test/compare.go

package test

import "reflect"

// ReflectDeepEqual 直接使用 reflect 包的 reflect.DeepEqual 方法进行比较
func ReflectDeepEqual(a, b []int) bool {
    return reflect.DeepEqual(a, b)
}

// LoopCompare 循环遍历比较
// 先比较两个数的长度是否相等
// 再循环遍历每一个元素进行比较
func LoopCompare(a, b []int) bool {
    if len(a) != len(b) {
        return false
    }
    if (a == nil) != (b == nil) {
        return false
    }
    for i, v := range a {
        if v != b[i] {
            return false
        }
    }
    return true
}

Benchmark测试效率

使用Benchmark来简单的测试下二者的效率，新建文件： path/test/compar_test.go

package test

import (
    "testing"
)

var (
    compareTester1 = []int{5, 9, 3, 8, 6, 4, 7, 10, 1}
    compareTester2 = []int{5, 9, 3, 8, 6, 4, 7, 10, 999}
)


// BenchmarkReflectDeepEqual 测试 reflect.DeepEqual 效率
func BenchmarkReflectDeepEqual(b *testing.B) {
    for n := 0; n < b.N; n++ {
        ReflectDeepEqual(compareTester1, compareTester2)
    }
}

// BenchmarkLoopCompare 测试 循环比较 效率
func BenchmarkLoopCompare(b *testing.B) {
    for n := 0; n < b.N; n++ {
        LoopCompare(compareTester1, compareTester2)
    }
}

在测试文件所在目录执行
go test -v -bench=. -benchtime=1s compare_test.go compare.go
命令，结果如下：

goos: darwin
goarch: amd64
BenchmarkReflectDeepEqual-4      1000000          1250 ns/op
BenchmarkLoopCompare-4          200000000            9.51 ns/op
PASS
ok      command-line-arguments  4.138s

• 使用循环遍历的方式，9.51 ns完成一次比较；
• 使用reflect的方式，1250 ns完成一次操作，效率对比十分明显。

reflect 接收任意类型的参数，方法内部要对类型做判断；循环遍历仅支持已知固定类型，效率自然要高些。

有疑问加站长微信联系（非本文作者）