詳解Go語言各種常見類型的默認值和判空方法

Posted on by

起因（解決的問題）

由於在項目中設計到瞭類型的判空，所以突然好奇起來，每個類型如果隻是聲明，而沒有初始化，那麼默認值是多少？怎麼判斷它是不是空值？所以去整理瞭一下

基本類型的默認值

1.常見的基本數據類型有：數據類型（int，uint，float之類的），字符串（string），結構體，數組，指針。

2.那麼他們的默認值是：

數據類型

默認值

int

0

float

0.00000

string

“”

結構體

根據結構體內部的基礎數據類型進行初始化賦值，下面會有demo

數組（切片）

空數組

指針

nil

3.例子：

package main
 
import (
    "fmt"
)
 
type UserInfo struct {
    Name string
    Age  int
    Sex  string
    Flag bool
}
 
// main函數
func main() {
    PrintDefault()
}
 
// 輸出默認值的函數
func PrintDefault() {
    var a int
    var b bool
    var c float64
    var d byte
    var e string
    var f UserInfo
    var g *UserInfo
    var ip *int
    var bp *bool
    var fp *float64
    var sp *string
    var ssp *byte
    var iArray []int
 
    fmt.Println("-------默認值列表--------")
    fmt.Printf("int的默認值為：%d\n", a)
    fmt.Printf("bool的默認值為：%t\n", b)
    fmt.Printf("float64的默認值為：%f\n", c)
    fmt.Printf("byte的默認值為：%b\n", d)
    fmt.Printf("string的默認值為：%s\n", e)
    fmt.Printf("結構體UserInfo的默認值為：%v\n", f)
    fmt.Printf("結構體指針UserInfo的默認值為：%v\n", g)
    fmt.Printf("int數組的默認值為：%v\n", iArray)
    fmt.Printf("int指針的默認值為：%p\n", ip)
    fmt.Printf("byte指針的默認值為：%p\n", bp)
    fmt.Printf("string指針的默認值為：%p\n", fp)
    fmt.Printf("float64指針的默認值為：%p\n", sp)
    fmt.Printf("byte指針的默認值為：%p\n", ssp)
    if ip != nil {
        fmt.Printf("string指針的默認值為：%d\n", *ip)
    }
}

運行結果截圖：

由上可以知道兩個點：

1.各種數據類型怎麼輸出，對應的d%，v%，s%是什麼。（大傢可以看一下，後面自己本地測試輸出日志也方便）

2.瞭解各種數據的默認值，總結來說就是：數據類型是0，字符是空字符“”，結構體指針是nil，基礎數據結構指針是0x0。

值得註意的是：雖然基礎數據類型指針的輸出和結構體指針的輸出不太一樣，但是實際判空的時候，都是視為nil的。例如：

var ip *int
if ip!=nil{//不會進入該邏輯，即：ip指向瞭0x0的時候，是視為nil的
        fmt.Printf("string指針的默認值為：%d\n", *ip)
    }

好瞭，那麼瞭解瞭各個數據類型的默認值，判空就好做多瞭。

判斷是否初始化（判空）

方法1：

直接判斷它和默認值是否一樣，是的話就認為是沒有初始化的。（這部分主要是瞭解原理，實際我們開發過程用方法2好點）

package main
 
import (
    "fmt"
    "reflect"
)
 
type UserInfo struct {
    Name string
    Age  int
    Sex  string
    Flag bool
}
 
func main() {
    fmt.Println("-----------判斷類型函數實驗----------")
    var a int
    var b bool
    var c float64
    var d byte
    var e string
    var f UserInfo
    var g *UserInfo
    var ip *int
    var sp *string
    if g == nil {
        fmt.Println("nil判斷成功")
    }
    var iSlice []int
    var iArray [2]int
    CheckType(a)
    CheckType(b)
    CheckType(c)
    CheckType(d)
    CheckType(e)
    CheckType(f)
    CheckType(g)
    CheckType(ip)
    CheckType(sp)
    CheckType(iArray)
    CheckType(iSlice)
}
 
// 自己寫瞭一個判空函數，你可以直接看判空部分的邏輯就好瞭。
func CheckType(args ...interface{}) {
    for _, arg := range args {
        fmt.Printf("數據類型為：%s\n", reflect.TypeOf(arg).Kind().String()) //先利用反射獲取數據類型，再進入不同類型的判空邏輯
        switch reflect.TypeOf(arg).Kind().String() {
        case "int":
            if arg == 0 {
                fmt.Println("數據為int,是空值")
            }
        case "string":
            if arg == "" {
                fmt.Println("數據為string，為空值")
            } else {
                fmt.Println("數據為string，數值為:", arg)
            }
        case "int64":
            if arg == 0 {
                fmt.Println("數據為int64，為空值")
            }
        case "uint8":
            if arg == false {
                fmt.Println("數據為bool，為false")
            }
        case "float64":
            if arg == 0.0 {
                fmt.Println("數據為float，為空值")
            }
        case "byte":
            if arg == 0 {
                fmt.Println("數據為byte，為0")
            }
        case "ptr":
            if arg == nil { //接口狀態下，它不認為自己是nil，所以要用反射判空
                fmt.Println("數據為指針，為nil")
            } else {
                fmt.Println("數據不為空，為", arg)
            }
            //反射判空邏輯
            if reflect.ValueOf(arg).IsNil() { //利用反射直接判空
                fmt.Println("反射判斷：數據為指針，為nil")
                fmt.Println("nil:", reflect.ValueOf(nil).IsValid()) //利用反射判斷是否是有效值
            }
        case "struct":
            if arg == nil {
                fmt.Println("數據為struct，為空值")
            } else {
                fmt.Println("數據為struct，默認有數，無法判空，隻能判斷對應指針有沒有初始化，直接結構體無法判斷")
            }
        case "slice":
            s := reflect.ValueOf(arg)
            if s.Len() == 0 {
                fmt.Println("數據為數組/切片，為空值")
            }
        case "array":
            s := reflect.ValueOf(arg)
            if s.Len() == 0 {
                fmt.Println("數據為數組/切片，為空值")
            } else {
                fmt.Println("數據為數組/切片，為", s.Len())
            }
        default:
            fmt.Println("奇怪的數據類型")
        }
    }
}

運行結果截圖：

由上可知。基本還是那句話：數據類型默認0，指針類型默認nil（接口類型下，空指針==nil會不通過，要用反射判空），字符類型為空字符串“”。

方式2：

利用反射包的內置函數判空. 正如上面展示的指針判空邏輯。實際上go已經有一個反射包裡面封裝瞭判斷

package main
 
import (
    "fmt"
    "reflect"
)
 
type UserInfo struct {
    Name string
    Age  int
    Sex  string
    Flag bool
}
 
func main() {
    fmt.Println("-----------指針類型判空實驗----------")
    var g *UserInfo
    var ip *int
    var sp *string
    var iSlice []int
    CheckTypeByReflectNil(g)
    CheckTypeByReflectNil(ip)
    CheckTypeByReflectNil(sp)
    CheckTypeByReflectNil(iSlice)
    fmt.Println("-----------基礎類型判空實驗----------")
    var a int
    var b bool
    var c float64
    var d byte
    var e string
    var f UserInfo
    CheckTypeByReflectZero(a)
    CheckTypeByReflectZero(b)
    CheckTypeByReflectZero(c)
    CheckTypeByReflectZero(d)
    CheckTypeByReflectZero(e)
    CheckTypeByReflectZero(f)
}
 
func CheckTypeByReflectNil(arg interface{}) {
    if reflect.ValueOf(arg).IsNil() { //利用反射直接判空，指針用isNil
        // 函數解釋：isNil() bool    判斷值是否為 nil
        // 如果值類型不是通道（channel）、函數、接口、map、指針或 切片時發生 panic，類似於語言層的v== nil操作
        fmt.Printf("反射判斷：數據類型為%s,數據值為：%v,nil：%v \n",
            reflect.TypeOf(arg).Kind(), reflect.ValueOf(arg), reflect.ValueOf(arg).IsValid())
    }
}
 
func CheckTypeByReflectZero(arg interface{}) {
    if reflect.ValueOf(arg).IsZero() { //利用反射直接判空，基礎數據類型用isZero
        fmt.Printf("反射判斷：數據類型為%s,數據值為：%v,nil：%v \n",
            reflect.TypeOf(arg).Kind(), reflect.ValueOf(arg), reflect.ValueOf(arg).IsValid())
    }
}

運行結果截圖：

到此這篇關於詳解Go語言各種常見類型的默認值和判空方法的文章就介紹到這瞭,更多相關Go語言常見類型的默認值和判空內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：