介绍：
对于array、slice、map、struct等类型，想要比较两个值是否相等，不能使用==，处理起来十分麻烦，在对效率没有太大要求的情况下，reflect包中的DeepEqual函数完美的解决了比较问题。
函数签名：
func DeepEqual(a1, a2 interface{}) bool
文档中对该函数的说明：
DeepEqual函数用来判断两个值是否深度一致：除了类型相同；在可以时（主要是基本类型）会使用==；但还会比较array、slice的成员，map的键值对，结构体字段进行深入比对。map的键值对，对键只使用==，但值会继续往深层比对。DeepEqual函数可以正确处理循环的类型。函数类型只有都会nil时才相等；空切片不等于nil切片；还会考虑array、slice的长度、map键值对数。
示例：
如果有两个map，内容都一样，只有顺序不同
m1:=map[string]int{"a":1,"b":2,"c":3};
m2:=map[string]int{"a":1,"c":3,"b":2};
我们怎么判断二者是否一致呢？
如果你打算这么写：
fmt.Println("m1==m2",m1==m2)
这是行不通的，go没有重写map的==操作符，编译器会报告错误：
invalid operation: m1 == m2 (map can only be compared to nil)
意思是map的变量只能和空（nil）比较，例如：
fmt.Println("m1 == nil?",m1==nil)
fmt.Println("m2 != nil?",m2!=nil)
这没有问题，执行结果是：
Running...
m1 == nil? false
m2 != nil? true
那怎么比较呢？如果要编程实现，还真是麻烦，比如我的想法是：循环m1,看看每个key是否都在m2中存在，再比较m1[key]是否和m2[key]相等，如果都ok，再依次循环m2。还真是麻烦：
func cmpMap(m1,m2 map[string]int)bool{
for k1,v1 :=range m1{
if v2,has:=m2[k1];has{
if v1!=v2 {
return false
}
}else{
return false;
}
}
for k2,v2:=range m2{
if v1,has:=m1[k2];has{
if v1!=v2{
return false;
}
}else{
return false;
}
}
return true;
}
其实，go的反射包中有一个巨好用的武器reflect.DeepEqual,可以方便解决这个问题，请看：
package main
import(
"fmt"
"reflect"
)
type tt struct{
Code int
}
func main(){
m1:=map[string]int{"a":1,"b":2,"c":3};
m2:=map[string]int{"a":1,"c":3,"b":2};
fmt.Println("m1 == nil?",m1==nil)
fmt.Println("m2 != nil?",m2!=nil)
//fmt.Println("m1==m2",m1==m2)
fmt.Println("cmpMap(m1,m2) = ",cmpMap(m1,m2));
fmt.Println("reflect.DeepEqual(m1,m2) = ",reflect.DeepEqual(m1,m2))
fmt.Println()
m3:=map[string]int{"a":1,"b":2,"c":3,"d":1};
fmt.Println("cmpMap(m1,m3)=",cmpMap(m1,m3));
fmt.Println("reflect.DeepEqual(m1,m3) = ",reflect.DeepEqual(m1,m3))
}
func cmpMap(m1,m2 map[string]int)bool{
for k1,v1 :=range m1{
if v2,has:=m2[k1];has{
if v1!=v2 {
return false
}
}else{
return false;
}
}
for k2,v2:=range m2{
if v1,has:=m1[k2];has{
if v1!=v2{
return false;
}
}else{
return false;
}
}
return true;
}
执行结果：
Running... m1 == nil? false m2 != nil? true cmpMap(m1,m2) = true reflect.DeepEqual(m1,m2) = true cmpMap(m1,m3)= false reflect.DeepEqual(m1,m3) = false Success: process exited with code 0.
但是美中不足的是，由于reflect.DeepEqual需要经过反射操作，效率比我们自己写的函数差的多了，写个简单的测试：
start:=time.Now();
for i:=0;i<100000;i++{
cmpMap(m1,m2)
}
end:=time.Now();
du:=end.Sub(start)
fmt.Println("100000 call cmpMap(m1,m2) elapsed=",du)
start=time.Now();
for i:=0;i<100000;i++{
reflect.DeepEqual(m1,m2);
}
end=time.Now();
du=end.Sub(start);
fmt.Println("100000 call reflect.DeepEqual(m1,m2) elapsed=",du)
看看结果，大约有10倍的差距
100000 call cmpMap(m1,m2) elapsed= 75.544992ms 100000 call reflect.DeepEqual(m1,m2) elapsed= 735.577069ms
当然，在一般情况下，这点儿性能损失不算什么，尤其在不确定类型需要反射的时候，更是我们不可不用的强大工具。
比如：
func main(){
m1:=map[string]interface{}{"a":"1", "b":2, "c":3};
m2:=map[string]interface{}{"a":1, "c":"3", "b":2};
fmt.Println(`reflect.DeepEqual(m1["a"],m2["a"]`,reflect.DeepEqual(m1["a"],m2["a"]));
fmt.Println(`reflect.DeepEqual(m1["b"],m2["b"]`,reflect.DeepEqual(m1["b"],m2["b"]));
}
执行结果：
Running... reflect.DeepEqual(m1["a"],m2["a"] false reflect.DeepEqual(m1["b"],m2["b"] true
这种情况，如果我们自己写代码比较，势必要使用switch type语法，实在是太麻烦了，感谢go包含了这么好的工具。