Golang不同类型比较

在日常开发过程中难免会遇到各个类型的变量的比较以及运算操作，这里我们做了一些简单的汇总，希望能给各位同学在开发中带来帮助。

这里先上一波关系运算符==，!=，<，<=，> 和 >=。

float浮点数比较

golang 支持两种浮点float32和float64，众所众知，涉及浮点数比较或运算是会遇到精度问题，具体要根据golang实现IEEE 754的情况定。

默认情况下，float32精度是小数后7位，float64精度是小数点后15位。

如例1：

	var a float32 = 1.00000001
	var b float32 = 1.000000000001
	var c float32 = 1.0000001
	var d float32 = 1.000000000001

	fmt.Println(a == b) //true
	fmt.Println(a > b)  //false
	fmt.Println(c == d) //false
	fmt.Println(c > d)  //true

float64

	var a float64 = 1.0000000000000001
	var b float64 = 1.000000000000000001
	var c float64 = 1.000000000000001
	var d float64 = 1.0000000000000000001

	fmt.Println(a == b) //true
	fmt.Println(a > b)  //false
	fmt.Println(c == d) //false
	fmt.Println(c > d)  //true

这里写了一个根据精度进行float比较的简单的类，注意最大精度为小数点后15位，超出会丢失精度。

示例：

package main

import (
	"fmt"
	"math"
)

type Floater struct {
	Accuracy float64   //精度,最大为小数点后15位
}
//是否相等
func (f Floater) IsEqual(a, b float64) bool {
	return math.Abs(a-b) < f.Accuracy
}
//0为相等 1为a大于b -1为a小于b
func (f Floater) Bccomp(a, b float64) int8 {
	if math.Abs(a-b) < f.Accuracy {
		return 0
	}
	if math.Max(a, b) == a {
		return 1
	} else {
		return -1
	}
}

func main() {

	f := Floater{Accuracy: 0.000000000001}
	var a float64 = 1.0000000002
	var b float64 = 1.0000000001

	fmt.Println(f.Bccomp(a, b)) //1
	fmt.Println(f.Bccomp(b, a)) //-1
	fmt.Println(f.Bccomp(a, a)) //0
}

顺便讲一下如何实现保留小数点后2位如何实现

    //方法1
	a := 2.556
	v, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", a), 64)
	fmt.Println(v)   //2.56
    //方法2   
	v = math.Trunc(a*1e2+0.5) * 1e-2
	fmt.Println(v)   //2.56
	
	//方法3
	n10 := math.Pow10(2)
	v = math.Trunc((a+0.5/n10)*n10) / n10
	fmt.Println(v)

指针类型比较

	a := "hello"
	b := &a
	c := &a
	fmt.Println(b == c)

当变量是相同或者都为nil时，指针值相等。

interface类型比较

type I1 interface {
	f()
}
type I2 interface {
	f()
}

type S1 struct {
	name string
}

func (s S1) f() {
}

type S2 struct {
	name string
}

func (s S2) f() {   
}

func main() {
	var a, b, c, d I1
	var e I2
	a = S1{"hello"}
	b = S1{"hello"}
	c = S1{"world"}
	d = S2{"hello"}
	fmt.Println(a == b) //true
	fmt.Println(a == c) //false
	fmt.Println(a == d) //false
	fmt.Println(a == e) //false
}

比较 slice/struct/map

这三个都可以用reflect.DeepEqual来判断是否相等

package main

import (
	"fmt"
	"reflect"
)

type S struct {
	s string
}

func main() {
	s1 := S{s: "hello"}
	s2 := S{s: "hello"}
	if reflect.DeepEqual(s1, s2) {
		fmt.Println(s1, "==", s2)
	}

	a1 := []int{1, 2}
	a2 := []int{1, 2}
	if reflect.DeepEqual(a1, a2) {
		fmt.Println(a1, "==", a2)
	}

	m1 := map[int]string{1: "a", 2: "b"}
	m2 := map[int]string{1: "a", 2: "b"}
	if reflect.DeepEqual(m1, m2) {
		fmt.Println(m1, "==", m2)
	}
}

links

• 目录