Golang type comparison

Basic types

Variable types must be equal in basic type comparison （ Even if it's int、int32 This is also incomparable ）

	var a int
	b := 0
	fmt.Println(a==b) //true

	var c int32
	fmt.Println(a==c) //  Can't compare int And int32 Errors will be reported in the compilation 

	type INT int
	var d INT
	fmt.Println(a==d) //  Can't compare int And INT（ Even if it is int）, Errors will be reported in the compilation 

	type aliasInt = int
	var e aliasInt
	fmt.Println(a==e) //  Type the alias , Can compare . true

That is to say

• Variable types must be equal to compare
  • Types cannot be compared again
  • int、int32 Similar types cannot be compared
• Type aliases can be compared

An array type

For arrays , All data in the array must be comparable , And the array length should also be consistent

	var a [1]string
	var b [2]string
	fmt.Println(a == b) //  Inconsistent array length , Can't compare 

	var c [1]int
	fmt.Println(a == c) //  Array element types are inconsistent , It can't be compared 

	var d [1]string
	fmt.Println(a == d) // Only the array element types are consistent , And the same length can be compared , but 

	var e [1][]string
	var f [1][]string
	fmt.Println(e == f) //  If array elements are of the non comparable type , Then arrays cannot be compared 

In short, arrays that can be compared must meet

• The array length is the same
• The array element types are consistent , And can compare

Type of structure

Structure type as long as the structure members are comparable , Then the structure can be compared

	type cmp struct {
    
		x int
		y string
	}
	a := cmp{
    
		x: 0,
		y: "",
	}

	b := cmp{
    
		x: 0,
		y: "",
	}
	fmt.Println(a == b) //  here cmp All members of the structure can be compared , Therefore, the structures can also be compared 

	type notCmp struct {
    
		x int
		y []string
	}
	c := notCmp{
    
		x: 0,
		y: nil,
	}
	d := notCmp{
    
		x: 0,
		y: nil,
	}
	fmt.Println(c == d) //  here nocmp The structure contains incomparable slice type , Then the structure cannot be compared 

Pointer types

Pointer types are basic type pointers and slice、map. For basic types, the pointer compares whether the pointer points to the same address

and slice、map There is no comparison

	var o int
	a := &o
	b := &o
	fmt.Println(a == b) // true

	var o1 int
	c := &o1
	fmt.Println(a == c) // false

	type simple struct {
    
		x int
		y string
	}

	d := &simple{
    }
	f := &simple{
    }
	g := d
	fmt.Println(d == f) // false
	fmt.Println(d == g) // true

interface{} type

Interfaces compare dynamic types and dynamic values , Only when both are equal , Comparison is equal .

Dynamic types are the structural types that actually implement interfaces , Dynamic value is the structure that actually implements the interface

//  here w Declare as io.Writer Interface , But there is no dynamic type 、 Dynamic values 
var w io.Writer
//  here w With dynamic types *os.File, But because of f It is just a declaration, so there is no dynamic value 
var f *os.File
w = f
//  here w Only then really had the dynamic value 
w = &os.File{
     }

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
}

const name = "xiaoming"

func comparePerson(p1, p2 Person) bool {
    
	return p1 == p2
}

// student and teacher Although inherit the same interface , Have the same properties 、 Methods and values , But they are different , So it is still unequal 
s1 := student{
    Name: name}
s2 := student{
    Name: name}
fmt.Println(comparePerson(s1, s2)) // true

t1 := teacher{
    Name: name}
fmt.Println(comparePerson(s1, t1)) // false

If dynamic types cannot be compared , Then it will not be equal

type mapStudent map[string]string
type mapTeacher map[string]string

func (m mapStudent) getName() string {
    
	return m["key"]
}

func (m mapTeacher) getName() string {
    
	return m["key"]
}

ms1 := mapStudent{
    
  "key": name,
}
ms2 := mapTeacher{
    
  "key": name,
}
fmt.Println(comparePerson(ms1, ms2)) // false

Function type

Functions are not comparable .

For the use of reflect.DeepEqual Go hard and compare , As long as it's two, it's not all nil, The returned results are not equal

Insist on comparison ——slice、map

• about byte slice type , Can pass bytes.Equal Compare
• reflect.DeepEqual You can compare variables of any type
• Of course, third-party libraries can also be introduced for comparison

Ref

1. https://www.jianshu.com/p/a982807819fa