思路

开发中经常会遇到需要比较两个slice或map包含的元素是否完全相等的情况,一般来说有两个思路:

  • reflect比较的方法
  • 循环遍历比较的方法

这里用检查两个字符串slice和两个map[string]string是否相等的例子来测试一下这两种思路的效率 我当然知道你知道reflect方法效率更差啦

reflect比较的方法

1
2
3
4
5
6
7
func StringSliceReflectEqual(a, b []string) bool {
    return reflect.DeepEqual(a, b)
}

func StringMapReflectEqual(a, b map[string]string) bool {
    return reflect.DeepEqual(a, b)
}

这个写法很简单,就是直接使用reflect包的reflect.DeepEqual方法来比较a和b是否相等

循环遍历比较的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
func StringSliceEqual(a, b []string) 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
}

func StringMapEqual(a, b map[string]string) 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
}

代码逻辑很简单;先比较长度是否相等,否则false;再比较两个slice是否都为nil或都不为nil,否则false;再比较对应索引处两个slice的元素是否相等,否则false;前面都为是则true

需要注意

1
2
3
if (a == nil) != (b == nil) {
    return false
}

这段代码是必须的,虽然如果没有这段代码,在大多数情况下,上面的函数可以正常工作,但是增加这段代码的作用是与reflect.DeepEqual的结果保持一致:

1
2
[]int{} != []int(nil)
map[string]string{}!=nil

Benchmark测试效率

我们都知道Golang中reflect效率很低,所以虽然循环遍历的方法看起来很啰嗦,但是如果真的效率比reflect方法高很多,就只能忍痛放弃reflect了

使用Benchmark来简单的测试下二者的效率

以 []string 为例

Benchmark StringSliceEqual

1
2
3
4
5
6
7
8
func BenchmarkEqual(b *testing.B) {
    sa := []string{"q", "w", "e", "r", "t"}
    sb := []string{"q", "w", "a", "s", "z", "x"}
    b.ResetTimer()
    for n := 0; n < b.N; n++ {
        StringSliceEqual(sa, sb)
    }
}

Benchmark StringSliceReflectEqual

1
2
3
4
5
6
7
8
func BenchmarkDeepEqual(b *testing.B) {
    sa := []string{"q", "w", "e", "r", "t"}
    sb := []string{"q", "w", "a", "s", "z", "x"}
    b.ResetTimer()
    for n := 0; n < b.N; n++ {
        StringSliceReflectEqual(sa, sb)
    }
}

上面两个函数中,b.ResetTimer()一般用于准备时间比较长的时候重置计时器减少准备时间带来的误差,这里可用可不用

在测试文件所在目录执行go test -bench=.命令

Benchmark对比测试结果

在我的电脑,使用循环遍历的方式,3.43纳秒完成一次比较;使用reflect的方式,208纳米完成一次操作,效率对比十分明显

map[string]string 同理

参考:https://www.jianshu.com/p/80f5f5173fca