Go语言各种常见类型的默认值和判空方法
字符串类型默认值为空字符串 ""
指针类型(*string、*int、*struct 等)默认值为 nil
type Person struct {
Name string
}
var p *Person // *Person 类型的指针变量
fmt.Println(“值是:”, p) // 输出 nil
-对于指针类型,如果为 nil,则表示指向一个不存在的对象或变量
由于没有为 p 分配任何内存地址,它的初始值是 nil
var p2 *Person = new(Person) // 此时输出:值是: &{ }
分配了默认值" "接口类型默认值为 nil。需要使用反射来判空
-不能直接用 == 判断是否为空,需要使用反射库中的 IsNil 方法进行判断
var i interface{}
reflect.ValueOf(i).IsNil()数字类型(int、float、complex 等)默认值为 0
-整数类型包括 int、int8、int16、int32 和 int64,默认值都是 0
-无符号整型 uint、uint8、uint16、uint32 和 uint64 也是默认值为 0
-其中 byte 类型是 uint8 的别名,也是默认值为 0
-rune 类型是 int32 的别名,也是默认值为 0
-浮点类型包括 float32 和 float64,默认值都是 0
通常情况下,应该使用 float64,因为它比 float32 更精确。在开发中,推荐使用 float64
price := 0.01
请问price的类型
是float32还是float64?实测为float64
类型 | 长度(字节) | 默认值 | 说明 | 判断空值的例子 |
---|---|---|---|---|
bool | 1 | false | 默认值为false | var b bool if !b { // do something } if b == false { // do something } |
byte | 1 | 0 | uint8的别名 | var b byte if b == 0 { // do something } if b == '\x00' { // do something } |
rune | 4 | 0 | Unicode码点,int32的别名 | var r rune if r == 0 { // do something } if r == '\u0000' { // do something } |
int, uint | 4或8 | 0 | 32 或 64 位 | var i int if i == 0 { // do something } if i == int(0) { // do something } |
int8, uint8 | 1 | 0 | -128 ~ 127, 0 ~ 255,byte是uint8的别名 | var i int8 if i == 0 { // do something } if i == int8(0) { // do something } |
int16, uint16 | 2 | 0 | -32768 ~ 32767, 0 ~ 65535 | var i int16 if i == 0 { // do something } if i == int16(0) { // do something } |
int32, uint32 | 4 | 0 | -21亿 ~ 21亿, 0 ~ 42亿,rune是int32的别名 | var i int32 if i == 0 { // do something } if i == int32(0) { // do something } |
int64, uint64 | 8 | 0 | -2^63 ~ 2^63-1, 0 ~ 2^64-1 | var i int64 if i == 0 { // do something } if i == int64(0) { // do something } |
float32 | 4 | 0.0 | 单精度浮点数 | var f float32 if f == 0.0 { // do something } if f == float32(0.0) { // do something } |
float64 | 8 | 0.0 | 默认浮点数类型,双精度浮点数 | var f float64 if f == 0.0 { // do something } if f == float64(0.0) { // do something } |
complex64 | 8 | (0+0i) | 由两个float32组成的复数 | var c complex64 if c == (0+0i) { // do something } if c == complex64(0+0i) { // do something } |
complex128 | 16 | (0+0i) | 由两个float64组成的复数 | var c complex128 if c == (0+0i) { // do something } if c == complex128(0+0i) { // do something } |
uintptr | 4或8 | 存储指针的 uint32 或 uint64 整数 | var u uintptr if u == uintptr(0) { // do something } if u == 0 { // do something } | |
string | " " | 字符串类型 | var str string if len(str) == 0 { // do something } | |
array | 值类型的零值 | - | var arr [3]int | if arr == [3]int{} { // do something } if len(arr) == 0 { // do something } |
slice | 引用类型的 nil | nil | var s []int | if s == nil { // do something } if len(s) == 0 { // do something } |
interface | nil | 引用类型(接口) | var i interface{} if i == nil { // do something } if _, ok := i.(interface{}); !ok { // do something } | |
map | 引用类型 | m := make(map[string]int) if len(m) == 0 { // do something } |
比较两个结构体、切片或映射是否相等
例如,如果你正在检查一个字符串是否为空,你可以使用内置len函数来检查字符串的长度
检查一个字符串是否为空,你可以使用内置len函数来检查字符串的长度
if len(str) == 0 {
// The string is empty
}
使用==运算符将字符串与空字符串进行比较
if str == "" {
// The string is empty
}
如果要检查整数、浮点数或布尔值是否为零,则可以使用==运算符将值与零进行比较
if i == 0 {
// The integer is zero
}
if f == 0.0 {
// The float is zero
}
if b == false {
// The boolean is false
}
如果要检查切片、映射或通道是否为空,则可以使用该len函数来检查值的长度
if len(slice) == 0 {
// The slice is empty
}
if len(map) == 0 {
// The map is empty
}
if len(channel) == 0 {
// The channel is empty
}
nil 一般是判断结构体的指针是否为空
type Demo struct {
Name string
Password string
}
func main() {
//例一:
var d *Demo
if d == nil {
fmt.Println("是nil") // 是nil
}
//例二:
var p *int
if p == nil {
fmt.Printf("是nil") // 是nil
}
//例三:
var i *int
fmt.Println(i) // "<nil>"
}
在 Go 中,没有像其他一些语言中那样的"null"值的概念。
如果你想在 Go 中表示一个"null"值,你可以使用指针类型并将其设置为nil. 例如nil
var i *int
fmt.Println(i) // prints "nil"
当比较结构体、切片和映射时,可以使用以下示例演示:
1、比较结构体:
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
p1 := Person{Name: "A", Age: 25}
p2 := Person{Name: "A", Age: 25}
// 比较 p1 和 p2 的全部字段
if reflect.DeepEqual(p1, p2) {
fmt.Println("p1 和 p2 相等") //p1 和 p2 相等
}
}
2、比较切片:
package main
import (
"fmt"
"reflect"
)
func main() {
s1 := []int{1, 2, 3}
s2 := []int{1, 2, 3}
// 使用 reflect.DeepEqual() 函数比较切片
if reflect.DeepEqual(s1, s2) {
fmt.Println("s1 = s2") // s1 = s2
}
}
3、比较映射:
package main
import (
"fmt"
"reflect"
)
func main() {
map1 := map[string]int{"a": 1, "b": 2}
map2 := map[string]int{"b": 2, "a": 1}
// 使用 reflect.DeepEqual() 函数比较映射
if reflect.DeepEqual(map1, map2) {
fmt.Println("map1 = map2") // map1 = map2
}
}
Go struct 设置默认值
package main
import "fmt"
type User struct {
Name string
Age int
}
func (t *Thing) Info(name string, age int) {
t.Name = name
t.Age = age
}
func main() {
u := new(User)
u.Info("张飞", 20)
fmt.Printf("%s: %d\n", u.Name, u.Age)
}
float32/64与[]byte互转
import (
"encoding/binary"
"math"
)
func Float32ToByte(float float32) []byte {
bits := math.Float32bits(float)
bytes := make([]byte, 4)
binary.LittleEndian.PutUint32(bytes, bits)
return bytes
}
func ByteToFloat32(bytes []byte) float32 {
bits := binary.LittleEndian.Uint32(bytes)
return math.Float32frombits(bits)
}
func Float64ToByte(float float64) []byte {
bits := math.Float64bits(float)
bytes := make([]byte, 8)
binary.LittleEndian.PutUint64(bytes, bits)
return bytes
}
func ByteToFloat64(bytes []byte) float64 {
bits := binary.LittleEndian.Uint64(bytes)
return math.Float64frombits(bits)
}