go的比较

学习博客：https://www.jianshu.com/p/a982807819fa

golang的变量类型：

基本类型
整型，包括int，uint，int8，uint8，int16，uint16，int32，uint32，int64，uint64，byte，rune，uintptr等
浮点型，包括float32，float64
复数类型，包括complex64，complex128
字符串类型，string
布尔型，bool
复合类型
数组
struct结构体
引用类型
slice
map
channel
pointer or 引用类型
接口类型
interface{}

基本类型变量的比较

比较的两个变量类型必须相等：
golang没有隐式类型转换，比较的两个变量类型必须完全一样，类型别名也不行。
如果要比较，先做类型转换再比较。
类型完全不一样的，不能比较
类型再定义，不能比较，可以强转比较
类型别名，可以比较

fmt.Println("2" == 2) //invalid operation: "2" == 2 (mismatched types string and int)

type A int
var a int = 1
var b A = 1
fmt.Println(a == b) //invalid operation: a == b (mismatched types int and A)
fmt.Println(a == int(b)) //true

type C = int
var c C = 1
fmt.Println(a == c) //true

复合类型的变量比较

复合类型是逐个字段，逐个元素比较的。

注意:
array 或者struct中每个元素必须要是可比较的，
如果某个array的元素或者struct的成员不能比较(slice，map等)，则此复合类型也不能比较。

数组类型变量比较
数组的长度是类型的一部分，如果数组长度不同，则无法比较。
逐个元素比较类型和值。
每个对应元素的比较遵循基本类型变量的比较规则。
跟struct一样，如果item是不可比较的类型，则array也不能做比较。
struct类型变量比较
逐个成员比较类型和值。每个对应成员的比较遵循基本类型变量的比较规则。

type Student struct {
    Name string
    Age  int
}

a := Student{"minping", 30}
b := Student{"minping", 30}
fmt.Println(a == b)   //true
fmt.Println(&a == &b) //false

但是如果struct中有不可比较的成员类型时：

type Student struct {
    Name string
    Age  int
    Info []string
}

a := Student{
    Name: "minping",
    Age:  30,
}

b := Student{
    Name: "minping",
    Age:  30,
}
fmt.Println(a == b)   //invalid operation: a == b (struct containing []string cannot be compared)

struct中有slice不可比较的成员时，整个struct都不能做比较，
即使没有对slice那个成员赋值(slice默认值为nil)

引用类型的变量比较

先说普通的变量引用类型&val和channel的比较规则:

引用类型变量存储的是某个变量的内存地址。
所以引用类型变量的比较，判断的是这两个引用类型存储的是不是同一个变量。
如果是同一个变量，则内存地址肯定也一样，则引用类型变量相等，用==判断为true
如果不是同一个变量，则内存地址肯定不一样，==结果为false

type Student struct {
    Name string
    Age  int
}

a := &Student{"minping", 30}
b := &Student{"minping", 30}
fmt.Println(a == b) //false

c := a
fmt.Println(a == c) //true

//作为引用类型，channel和普通的&val判断规则一致
ch1 := make(chan int, 1)
ch2 := make(chan int, 1)
ch3 := ch1

fmt.Println(ch1 == ch2) //false
fmt.Println(ch1 == ch3) //true

slice引用类型的比较
slice类型不可比较，只能与零值nil做比较。

a := []string{}
b := []string{}
fmt.Println(a == b)  //invalid operation: a == b (slice can only be compared to nil)

var b []string
fmt.Println(a == nil) // false
fmt.Println(b == nil) // true

map类型的比较
map类型和slice一样，不能比较，只能与nil做比较。

四，interface{}类型变量的比较
接口类型的变量，包含接口的动态类型和动态值。
只有动态类型和动态值都相同时，两个接口变量才相同:

type Person interface {
    getName() string
}

type Student struct {
    Name string
}

type Teacher struct {
    Name string
}

func (s Student) getName() string {
    return s.Name
}

func (t Teacher) getName() string {
    return t.Name
}

// 形参是两个接口
// 内容是对接口进行比较
func compare(s, t Person) bool {
    return s == t
}

func main() {
    s1 := Student{"minping"}
    s2 := Student{"minping"}
    t := Teacher{"minping"}

    fmt.Println(compare(s1, s2)) //true
    fmt.Println(compare(s1, t))  //false 类型不同
}

接口的动态类型必须可比较，如果不能比较(比如slice，map)，则运行时panic。
因为编译器在编译时无法获取接口的动态类型，所以编译能通过，但运行时panic:

type Person interface {
    getName() string
}

type Student map[string]string

type Teacher map[string]string

func (s Student) getName() string {
    return s["name"] //name做键值，返回实值
}

func (t Teacher) getName() string {
    return t["name"] //name做键值，返回实值
}

func compare(s, t Person) bool {
    return s == t
}

func main() {
    s1 := Student{}
    s1["name"] = "minping"
    s2 := Student{}
    s2["name"] = "minping"

    fmt.Println(compare(s1, s2)) //runtime error: comparing uncomparable type main.Student
}

五，函数类型的比较
golang的func作为一等公民，也是一种类型，而且不可比较，只能跟nil比较

f := func(int) int { return 1 }
g := func(int) int { return 2 }
f == g

f := func(int) int { return 1 }
fmt.Println(f == nil) // false
var g func(int) int
fmt.Println(g == nil) // true

六，slice和map的特殊比较
map和slice是不可比较类型，有特殊方法对slice和map做比较

[]byte类型的变量，使用工具包byte提供的函数就可以比较

s1 := []byte{'f', 'o', 'o'}
s2 := []byte{'f', 'o', 'o'}
fmt.Println(bytes.Equal(s1, s2)) // true
s2 = []byte{'b', 'a', 'r'}
fmt.Println(bytes.Equal(s1, s2)) // false

s2 = []byte{'f', 'O', 'O'}
fmt.Println(bytes.EqualFold(s1, s2)) // true
s1 = []byte("źdźbło")
s2 = []byte("źdŹbŁO")
fmt.Println(bytes.EqualFold(s1, s2)) // true

s1 = []byte{}
s2 = nil
fmt.Println(bytes.Equal(s1, s2)) // true

使用反射
reflect.DeepEqual 函数可以用来比较两个任意类型的变量

func DeepEqual(x, y interface{})

对map类型做比较：

m1 := map[string]int{"foo": 1, "bar": 2}
m2 := map[string]int{"foo": 1, "bar": 2}
fmt.Println(reflect.DeepEqual(m1, m2)) // true

m2 = map[string]int{"foo": 1, "bar": 3}
fmt.Println(reflect.DeepEqual(m1, m2)) // false

m3 := map[string]interface{}{"foo": [2]int{1,2}}
m4 := map[string]interface{}{"foo": [2]int{1,2}}
fmt.Println(reflect.DeepEqual(m3, m4)) // true

var m5 map[float64]string
fmt.Println(reflect.DeepEqual(m5, nil)) // false
fmt.Println(m5 == nil) // true

对slice类型做比较：

s := []string{"foo"}
fmt.Println(reflect.DeepEqual(s, []string{"foo"})) // true
fmt.Println(reflect.DeepEqual(s, []string{"bar"})) // false

var s []string
var s1 []string
fmt.Println(reflect.DeepEqual(s, s1))					// true
fmt.Println(reflect.DeepEqual(s, nil)) 					// false
fmt.Println(reflect.DeepEqual([]string{}, nil))			// false
fmt.Println(reflect.DeepEqual(s, []string{}))			// true
fmt.Println(reflect.DeepEqual([]string{}, []string{}))	// true
fmt.Println(reflect.DeepEqual(nil, nil))				// true
[]string{} 不等于 nil

var s []string
fmt.Println(s == nil)			// true
fmt.Println([]string{} == nil)	// false

对struct类型做比较：

type T struct {
    name string
    Age  int
}
func main() {
    t := T{"foo", 10}
    fmt.Println(reflect.DeepEqual(t, T{"bar", 20})) // false
    fmt.Println(reflect.DeepEqual(t, T{"bar", 10})) // false
    fmt.Println(reflect.DeepEqual(t, T{"foo", 10})) // true
}

只要变量的类型和值相同，reflect.DeepEqual 比较的结果就为 true

2，使用google的cmp包

import (
    "fmt"
    "github.com/google/go-cmp/cmp"
)

type T struct {
    Name string
    Age  int
    City string
}

func main() {
    x := T{"Michał", 99, "London"}
    y := T{"Adam", 88, "London"}
    if diff := cmp.Diff(x, y); diff != "" {
        fmt.Println(diff)
    }
}

结果为：

 main.T{
-       Name: "Michał",
+       Name: "Adam",
-       Age:  99,
+       Age:  88,
        City: "London",
  }

五，总结

复合类型，只有每个元素(成员)可比较，而且类型和值都相等时，两个复合元素才相等
slice，map不可比较，但是可以用reflect或者cmp包来比较
func作为golnag的一等公民，也是一个类型，也不能比较。
引用类型的比较是看指向的是不是同一个变量
类型再定义(type A string)不可比较，是两种不同的类型
类型别名(type A = string)可比较，是同一种类型。

附件1-类型再定义和类型别名

学习博客：https://studygolang.com/articles/29700

类型再定义的使用

类型再定义，一般用在为一个类型添加一个独有的方法使用。
再定义的类型，和原类型的方法，不再有交集。

以http包为例：

package http

type HandlerFunc func(w ResponseWriter, r *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

类型别名的使用

类型别名，和原类型完全一样，原类型的方法，别名类型也可以使用。

golang中两个内置的类型别名的例子：

type byte = uint8
type rune = int32

类型别名的设计初衷，是为了解决代码重构时，类型在包之间转移时产生的问题。
别名在代码重构中非常有用。
例如以前使用的是p.T这个类型，重构过程中需要把它移到p1.T1，
这时只需要在p包中定义type T = p1.T1，这样基本之前使用p.T的代码都不用修改

类型别名的好处：
(1) 名字可以起的通俗易懂
(2) 需要修改数据类型时，只需要改原类型定义的那个地方。使用的地方都可以不用改动。
(3) 可以很方便的添加特有方法，以实现某些接口
(4) 当原始类型为不可导出(小写)时，别名类型可以定义成导出(大写)的

type t1 struct { //不可导出
    S string
}
type T2 = t1 //可导出