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

• 目录