Shulou(Shulou.com)06/02 Report--

This article mainly shows you "how to use nil in golang", the content is easy to understand, clear, hope to help you solve doubts, the following let the editor lead you to study and learn "how to use nil in golang" this article.

Many people mistakenly think that nil in golang is the same as null in programming languages such as Java and PHP. But Golang's niu is actually much more complicated, so if you don't believe it, let's move on.

Nil is a pre-declared identifier, defined in builtin/builtin.go

/ / nil is a predeclared identifier representing the zero value for a// pointer, channel, func, interface, map, or slice type.// Type must be a pointer, channel, func, interface, map, or slice typevar nil Type / / Type is here for the purposes of documentation only. Zero value of It is a stand-in// for any Go type, but represents the same type for any given function// invocation.type Type intnil

According to the Go language specification, any type corresponds to a zero value when uninitialized: the Boolean type is false, the integer is 0, the string is "", and the zeros of pointers, functions, interface, slice, channel, and map are all nil.

PS: it is not said here that the zero value of the structure struct is nil, because the zero value of struct is related to its properties

Nil does not have a default type, although it is a zero value for multiple types, and an explicit type for each nil usage must be explicitly or implicitly specified.

Package mainfunc main () {/ / is clear. _ = (* struct {}) (nil) _ = [] int (nil) _ = map [int] bool (nil) _ = chan string (nil) _ = (func ()) (nil) _ = interface {} (nil) / / implicit. Var _ * struct {} = nil var _ [] int = nil var _ map [int] bool = nil var _ chan string = nil var _ func () = nil var _ interface {} = nil}

If students who have followed the golang keyword will find that there is no nil, that is, nil is not a keyword, then you can define nil in the code, then nil will be hidden.

Package mainimport "fmt" func main () {nil: = 123 fmt.Println (nil) / / 123 var _ map [string] int = nil / / cannot use nil (type int) as type map [string] int in assignment} address and value size of type nil

The memory layout of all values of the nil type is always the same, in other words: the memory address of different types of nil is the same.

Package mainimport ("fmt") func main () {var map[ string var ptr * int var sl [] int fmt.Printf ("% p\ n", m) / / 0x0 fmt.Printf ("% p\ n", ptr) / / 0x0 fmt.Printf ("% p\ n", sl) / / 0x0}

Nil values are generally represented as exceptions in business. The size of the nil value is always the same as the size of the non-nil value whose type is the same as the Nil value. Therefore, nil identifiers that represent different zero values may have different sizes.

Package mainimport ("fmt"unsafe") func main () {var p * struct {} = nil fmt.Println (unsafe.Sizeof (p)) / / 8 var s [] int = nil fmt.Println (unsafe.Sizeof (s)) / / 24 var Mmapint] bool = nil fmt.Println (unsafe.Sizeof (m)) / / 8 var c Chan string = nil fmt.Println (unsafe.Sizeof (c)) / / 8 var f func () = nil fmt.Println (unsafe.Sizeof (f)) / / 8 var i interface {} = nil fmt.Println (unsafe.Sizeof (I)) / / 16}

Size is dependent on the compiler and architecture. The above print results are 64-bit architecture and official Go compiler. For a 32-bit architecture, the print size will be half.

For official Go compilers, two Nil values of different types of the same category are always the same size. For example, the two nil values of two different slice types ([] int and [] string) are always the same.

Nil value comparison

1. Different types of nil cannot be compared.

Package mainimport ("fmt") func main () {var map [int] string var ptr * int fmt.Printf (m = = ptr) / / invalid operation: M = = ptr (mismatched types map [int] string and * int)}

In Go, two values of two different comparable types can only be compared if one value can be implicitly converted to another type. Specifically, there are two cases in which two different values can be compared:

The type of one of the two values is the base type of the other.

The type of one of the two values implements the type of the other value (must be an interface type).

The nil value comparison does not deviate from the above rule.

Package mainimport ("fmt") func main () {type IntPtr * int fmt.Println (IntPtr (nil) = = (* int) (nil)) / / true fmt.Println ((interface {}) (nil) = = (* int) (nil)) / / false}

two。 Two Nil values of the same type may not be compared because there are map, slice, and function types in golang that are incomparable types, and they have a type that is otherwise called incomparable, so comparing their nil is also illegal.

Package mainimport ("fmt") func main () {var v1 [] int = nil var v2 [] int = nil fmt.Println (v1 = = v2) fmt.Println ((map [string] int) (nil) = (map [string] int) (nil)) fmt.Println ((func ()) (nil) = (func ()) (nil))}

The value deficiency of incomparable types can be compared with "pure nil".

Package mainimport ("fmt") func main () {fmt.Println ((map [string] int) (nil) = = nil) / / true fmt.Println ((func ()) (nil) = = nil) / / true}

3. Two nil values may not be equal

If one of the Nil values of the two comparisons is an interface value and the other is not, assuming they are comparable, the result of the comparison is always false. The reason is that the interface value is converted to the type of the interface value before making a comparison. The converted interface value has a specific dynamic type, but other interface values do not. That's why comparisons are always wrong.

Package mainimport ("fmt") func main () {fmt.Println ((interface {}) (nil) = (* int) (nil)) / / false} FAQ

1. Function return

Func nilReturn () (string,error) {return nil,nil / / cannot use nil as type string in return argument}

Because error is an interface type, the error type does not report an error.

If the key of the nil key map of 2.map is pointer, function, interface, slice, channel, and map, then key can be nil.

Package mainimport ("fmt") func main () {mmap: = make (map [* string] int,4) a fmt.Println = "a" mmap [& a] = 1 mmap [nil] = 99 fmt.Println (mmap) / / map [0xc042008220:1: 99]} these are all the contents of the article "how to use nil in golang". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.