“nil slice” vs “nil map”

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

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var (
  7.         s []int
  8.         m map[int]bool
  9.     )
  10.     if s == nil {
  11.         fmt.Println("The value of s is nil")
  12.     }
  13.     if m == nil {
  14.         fmt.Println("The value of m is nil")
  15.     }
  16. }

The result is like this： 

  1. The value of s is nil
  2. The value of m is nil

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

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var s []int
  7.     fmt.Println("Is s a nil? ", s == nil)
  8.     s = append(s, 1)
  9.     fmt.Println("Is s a nil? ", s == nil)
  10.     fmt.Println(s)
  11. }

The result is like this： 

  1. Is s a nil?  true
  2. Is s a nil?  false
  3. [1]

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

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var s1 []int
  7.     s2 := []int{}
  8.     fmt.Println("Is s1 a nil? ", s1 == nil)
  9.     fmt.Println("Length of s1 is: ", len(s1))
  10.     fmt.Println("Is s2 a nil? ", s2 == nil)
  11.     fmt.Println("Length of s2 is: ", len(s2))
  12. }

The result is like this： 

  1. Is s1 a nil?  true
  2. Length of s1 is:  0
  3. Is s2 a nil?  false
  4. 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: 

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var m map[int]bool
  7.     fmt.Println("Is m a nil? ", m == nil)
  8.     fmt.Println("m[1] is ", m[1])
  9.     m[1] = true
  10. }

The result is like this: 

  1. Is m a nil?  true
  2. m[1] is  false
  3. panic: assignment to entry in nil map
  5. goroutine 1 [running]:
  6. panic(0x4cc0e0, 0xc082034210)
  7.     C:/Go/src/runtime/panic.go:481 +0x3f4
  8. main.main()
  9.     C:/Work/gocode/src/Hello.go:9 +0x2ee
  10. exit status 2
  12. Process finished with exit code 1

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

  1. m := make(map[int]bool)

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

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

Reference:
The Go Programming Language.