深度学习go判断各个类型相等-日常实战总结8
阅读：535
分享次数：0
今天我们讲一下如何判断golang的各个类型之间是否相等，可能很多人没了解之前或者深度理解之前都可能觉得一个相等不就是“==”就行了？并不是，如果是复杂的类型，需要同特殊的处理方式，下面我们一一介绍不同类型的判断是否相等如何处理。
下面我们介绍一下字符串判断是否相等。字符串涉及到其实有三种情况，对我们了解这个使用和代码的优化很有帮助。
package main
import (
"fmt"
"strings"
)
func main() {
//字符串判断是否相等
a := "zengzhihai"
b := "ZengZhiHai"
//1.直接用等号，区分大小写是否相等
if a == b {
fmt.Println("yes")
} else {
fmt.Println("no")
}
//2.用strings.Compare判断是否相等 功能和 == 一样 但是效率比 == 高
if strings.Compare(a, b) == 0 {
fmt.Println("yes 1")
} else {
fmt.Println("no 1")
}
//3.针对于utf8编码有特殊的字符串判断，区分大小写
if strings.EqualFold(a, b) {
fmt.Println("yes 2")
} else {
fmt.Println("no 2")
}
}
下面是例子结果
no
no 1
yes 2
下面我们看一下整形类型或者浮点型判断是否相等，其实直接用“==”就可以。
package main
import "fmt"
func main() {
//int类型判断是否相等，直接用== 就ok
c := 4
d := 5
if c == d {
fmt.Println("yes 3")
} else {
fmt.Println("no 3")
}
}
下面是返回结果
no 3
如何判断slice是否相等，我这里总结了一个情况。1：循环每个都去判断是否等于。2：reflect.DeepEqual判断，还有就是其他特殊情况的总结，我们直接看代码吧。但是这里我要强调一下，如果slice顺序不对，两个slice也是不一样的。下面我们就直接看例子。
package main
import (
"reflect"
"fmt"
"bytes"
)
func main() {
//判断slice是否相等
e := []string{"aaa", "bbbb"}
f := []string{"bbbb", "aaa"}
g := []string{}
//1.直接循环判断，我就不写例子了，大家自己去写一下
//2.用reflect.DeepEqual
if reflect.DeepEqual(e, f) {
fmt.Println("yes 4")
} else {
fmt.Println("no 4")
}
if reflect.DeepEqual(e, g) {
fmt.Println("yes 44")
} else {
fmt.Println("no 44")
}
//3.如果是特殊的slice byte的话可以用byte的函数
h := []byte{1, 2}
i := []byte{1, 7}
j := []byte{}
if bytes.Equal(h, i) {
fmt.Println("yes 5")
} else {
fmt.Println("no 5")
}
if bytes.Equal(h, j) {
fmt.Println("yes 55")
} else {
fmt.Println("no 55")
}
}
看完例子我们就清楚了，有byte的特殊使用，下面我们看一下结果
no 4
no 44
no 5
no 55
下面我们看一下map的判断，这里我就不列举了，直接看代码，我在代码上面进行总结
package main
import (
"reflect"
"fmt"
)
func main() {
//判断map是否相等
//1.直接循环判断，k和v是否相等，这里我也不写例子了,如果是里面的类型不一样，那就其实都不用判断了，
//2.用reflect.DeepEqual,针对于不同的map，如果写的顺序不一样，只要key和value都一样，那就是map也相等。
i := map[string]string{
"cc": "bb",
"aa": "dd",
}
j := map[string]string{
"aa": "dd",
"cc": "bb",
}
if reflect.DeepEqual(i, j) {
fmt.Println("yes 6")
} else {
fmt.Println("no 6")
}
}
下面我们看一下例子结果
yes 6
下面我们看一下自定义类型的。
package main
import (
"reflect"
"fmt"
)
func main() {
//针对于自定义的struct类型如何判断相等呢？下面看一个例子,我们都还是得使用reflect.DeppEqual
//第一种情况
type A1 struct {
AA string
BB string
}
a1 := new(A1)
a1.AA = "aa"
a1.BB = "bb"
a2 := new(A1)
a2.AA = "aa"
a2.BB = "bb"
if reflect.DeepEqual(a1, a2) {
fmt.Println("yes 7")
} else {
fmt.Println("no 7")
}
//第二种情况
type A2 struct {
AA string
BB string
CC A1
DD interface{}
}
a3 := new(A2)
a3.AA = "aa"
a3.BB = "bb"
t1 := new(A1)
t1.AA = "1"
t1.BB = "2"
a3.CC = *t1
a3.DD = []string{"11"}
a4 := new(A2)
a4.AA = "aa"
a4.BB = "bb"
t2 := new(A1)
t2.AA = "1"
t2.BB = "2"
a4.CC = *t2
a4.DD = []string{"11"}
fmt.Println(a3)
fmt.Println(a4)
if reflect.DeepEqual(a3, a4) {
fmt.Println("yes 8")
} else {
fmt.Println("no 8")
}
//reflect.DeepEqual 主要处理同类型，同深度 不同的值不一样的进行判断。
}
下面我们看一下结果。
yes 7
a3地址：0xc0000a0000
a4地址：0xc0000a0050
yes 8
好了，这里我主要总结了这几种的使用，也是最常用的使用，比如指针，函数类型等其实也可以介绍下，后面看看有时间再介绍，这里用的最多的就是reflect.DeepEqual，到底他的性能怎么样，可能我们不了解，后面我们对针对于性能也介绍一下。
感觉本站内容不错，读后有收获？
