Go语言各种常见类型的默认值和判空方法

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)
}