nil-slice-vs-nil-map.md

“nil slice” vs “nil map”

---

Slice and map are all reference types in Go, and their default values are nil:

package main

import "fmt"

func main() {
	var (
		s []int
		m map[int]bool
	)
	if s == nil {
		fmt.Println("The value of s is nil")
	}
	if m == nil {
		fmt.Println("The value of m is nil")
	}
}  

The result is like this：

The value of s is nil
The value of m is nil

When a slice's value is nil, you could also do operations on it, such as append:

package main

import "fmt"

func main() {
	var s []int
	fmt.Println("Is s a nil? ", s == nil)
	s = append(s, 1)
	fmt.Println("Is s a nil? ", s == nil)
	fmt.Println(s)
}

The result is like this：

Is s a nil?  true
Is s a nil?  false
[1]

A caveat you should notice is the length of both nil and empty slice is 0:

package main

import "fmt"

func main() {
	var s1 []int
	s2 := []int{}
	fmt.Println("Is s1 a nil? ", s1 == nil)
	fmt.Println("Length of s1 is: ", len(s1))
	fmt.Println("Is s2 a nil? ", s2 == nil)
	fmt.Println("Length of s2 is: ", len(s2))
}

The result is like this：

Is s1 a nil?  true
Length of s1 is:  0
Is s2 a nil?  false
Length of s2 is:  0

So you should compare the slice's value with nil to check whether it is a nil.

Accessing a nil map is OK, but storing a nil map cause program panic:

package main

import "fmt"

func main() {
	var m map[int]bool
	fmt.Println("Is m a nil? ", m == nil)
	fmt.Println("m[1] is ", m[1])
	m[1] = true
}

The result is like this:

Is m a nil?  true
m[1] is  false
panic: assignment to entry in nil map

goroutine 1 [running]:
panic(0x4cc0e0, 0xc082034210)
	C:/Go/src/runtime/panic.go:481 +0x3f4
main.main()
	C:/Work/gocode/src/Hello.go:9 +0x2ee
exit status 2

Process finished with exit code 1

So the best practice is to initialize a map before using it, like this:

m := make(map[int]bool)

BTW, you should use the following pattern to check whether there is an element in map or not:

if v, ok := m[1]; !ok {
	.....
}

Reference:
The Go Programming Language.