浅析go中的类型比较概述在最近的面试中被面试官问到go之间的类型比较，回答的并不是非常好，根本上来说还是基础不够牢固啊！看了网上的一堆资料，自己做了一些简单的总结，哈哈！
go中的类型首先来看看go包含的最基础的集中类型
基本类型：go中最基本类型包括整型（int、uint、int8、uint8、int16、uint16、int32、uint32、int64、uint64、byte、rune等）、浮点型（float32、float64）、字符串（string也是个[]rune数组）和比较不常用的复数类型（complex64/complex128）。复合类型：主要包括结构体和数组。引用类型：slice、map、channel、指针。接口类型：error、io.reader等。go作为强类型语言并不会和php等高级语言自动帮我们进行类型转换，所以我们在比较时必须用==两边的类型必须一致，即使他们底部类型一致也不行。看下面的代码
package mainimport fmttype a struct { id int}type b struct { id int}func main() { var a int var b int16 // 编译报错：invalid operation a == b (mismatched types int and int16) fmt.println(a == b) astruct := a{id:5} bstruct := b{id:5} // 编译报错：invalid operation: astruct == bstruct (mismatched types a and b) fmt.println(astruct == bstruct)}
所以go不会帮我们做隐式转换，即使底层的类型一致，也不能比较。
接下来我们从不同的类型来分析是否可以进行比较。
基本类型go的基本类型就比较简单，只要类型是一样的，那么他们就是可以比较的，举个栗子：
package mainimport fmtfunc main() { var a int = 0 var b int = 1 // 输出false fmt.println(a == b)}
不过基本类型中也要注意浮点型的比较就不像我们现实中的一样，比如0.1+0.2在计算中运行结果就不是0.3了，而是0.30000000000000004了
package mainimport fmtfunc main() { var a float64=0.1 var b float64=0.2 // 0.30000000000000004 fmt.println(a+b)}
为什么会这样，可以看下draveness(https://github.com/draveness) 大佬的这篇文章https://draveness.me/whys-the...
复合类型数组面试中也经常会问到go数组和切片的区别。数组在go中是必须先确定长度的，也就是长度不能再去扩容。并且它是个值拷贝，做参数传到一个函数中被修改，那么外部的值还是一样的不变的。slice则相反。那么数组是否可以比较呢，看下面的例子：
package mainimport fmtfunc main() { a := [2]int{1, 2} b := [2]int{1, 2} c := [2]int{1, 3} d := [3]int{1, 2, 4} fmt.println(a == b) // true fmt.println(a == c) // false fmt.println(a == d) // invalid operation: a == d (mismatched types [2]int and [3]int)}
可以看出，相同长度的数组是可以比较的，而不同长度的数组是不能进行比较的。原因是什么呢？这是因为数组类型中,数组的长度也是类型的一部分，不同长度的数组那么他们的类型也就被认为不同的，所以无法比较。
结构体同样的struct也是一样的。struct的比较也从内部类型开始比较，每一类型的值相等才是相等的。如下例子：
package mainimport fmttype a struct { id int name string}func main() { a := a{id:5,name:123} b := a{id:5,name:123} c := a{id:5,name:1234} fmt.println(a == b) // true fmt.println(a == c) // false}
那么可以理解成struct结构体是可以比较的吗。我们再来看个例子：
package mainimport fmttype a struct { id int name string son []int}func main() { a := a{id:5,name:123,son:[]int{1,2,3}} b := a{id:5,name:123,son:[]int{1,2,3}} fmt.println(a == b) // invalid operation: a == b (struct containing []int cannot be compared)}
怎么又变成不可比较的呢？这就要看下面的引用类型了。
引用类型上面中的例子结构体中带上切片就无法比较了，在go中slice和map被定义成不能比较的类型。我们来看
如果slice是可比较，那么用什么来定义是一样的切片呢？如果用地址，那么如果两个地址指向的slice是一样的呢？这显然不合适。如果和数组一样的方式，那么我切片扩容了呢，就不相等了。所以长度和容量导致不好比较。虽然可以在语言层面解决这个问题，但是 golang 团队认为不值得为此耗费精力。所以slice被当成不可比较。
同样的map也被定义成不可比较类型。那么引用类型都是不可比较吗?也不是，看个例子：
package mainimport fmttype a struct { id int name string}func main() { a := &a { a : 1, b : test1 } b := &a { a : 1, b : test1 } c := a fmt.println(a == b) // false fmt.println(a == c) // true ch1 := make(chan int, 1) ch2 := make(chan int, 1) ch3 := ch1 fmt.println(ch1 == ch2) // false fmt.println(ch1 == ch3) // true}
引用类型变量存储的是某个变量的内存地址。所以引用类型变量的比较，判断的是这两个引用类型存储的是不是同一个变量。
如果是同一个变量，则内存地址肯定也一样，则引用类型变量相等，用==判断为true如果不是同一个变量，则内存地址肯定不一样，==结果为false接口类型go 语言根据接口类型是否包含一组方法将接口类型分成了两类：
使用 runtime.iface结构体表示包含方法的接口使用 runtime.eface结构体表示不包含任何方法的 interface{} 类型type eface struct { // 16 字节 _type *_type data unsafe.pointer}type iface struct { // 16 字节 tab *itab data unsafe.pointer}
所以我们可以得知，一个接口值是由两个部分组成的，即该接口对应的类型和接口对应具体的值。接口值的比较涉及这两部分的比较，只有当类型和值都相等（动态值使用==比较），两个接口值才是相等的。看个例子：
var a interface{} = 0var b interface{} = 2var c interface{} = 0var d interface{} = 0.0fmt.println(a == b) // falsefmt.println(a == c) // truefmt.println(a == d) // false
a和c类型相同（都是int），值也相同（都是0，基本类型比较），故两者相等。 a和b类型相同，值不等，故两者不等。 a和d类型不同，a为int，d为float64，故两者不等。
type a struct { a int b string}var a interface{} = a { a: 1, b: test }var b interface{} = a { a: 1, b: test }var c interface{} = a { a: 2, b: test }fmt.println(a == b) // truefmt.println(a == c) // falsevar d interface{} = &a { a: 1, b: test }var e interface{} = &a { a: 1, b: test }fmt.println(d == e) // false
a和b类型相同（都是a），值也相同（结构体a），故两者相等。 a和c类型相同，值不同，故两者不等。 d和e类型相同（都是*a），值使用指针（引用）类型的比较，由于不是指向同一个地址，故不等。
不过需要注意的是，如果接口中类型是切片或者map不可比较的类型，那么会直接报错的。看个例子：
var a interface{} = []int{1, 2}var b interface{} = []int{1, 2}// panic: runtime error: comparing uncomparable type []intfmt.println(a == b)
a和b的类型是切片类型，而切片类型不可比较，所以a == b会panic。
接口值的比较不要求接口类型（注意不是动态类型）完全相同，只要一个接口可以转化为另一个就可以比较。例如：
var f *os.filevar r io.reader = fvar rc io.readcloser = ffmt.println(r == rc) // truevar w io.writer = f// invalid operation: r == w (mismatched types io.reader and io.writer)fmt.println(r == w)
r的类型为io.reader接口，rc的类型为io.readcloser接口。查看源码，io.readcloser的定义如下：
type readcloser interface { reader closer}
io.readcloser可转化为io.reader，故两者可比较。
而io.writer不可转化为io.reader，编译报错。
总结可比较：int、ifloat、string、bool、complex、pointe、channel、interface、array不可比较：slice、map、function复合类型中如果带有不可比较的类型，那么该类型也是不可比较的。可以理解不可比较类型具有传递性。以上就是分析go中的类型比较的详细内容。