Interviewer: why is the value nil not equal to nil?

Xiaoming went to the interview and was asked such an interview question , Please look at the code. ：

var f func()
var a *struct{}

list := []interface{}{f, a}
for _, item := range list {
 if item == nil {
  fmt.Println("nil")
 }
}

What is the output result ？

Maybe a lot of students , You will think that the result is to output two nil.

Why? ？

because f and a Not initialized , All are nil, So it must be the same after loop traversal nil.

If your answer is the same , Then fall into the pit .

The answer is , Nothing will be output ！

Let me analyze it for you ：

One 、 The value and type of the variable

Let's print these two values first ：

var f func()
var a *struct{}
fmt.Println(f, a)

//  Output results 
<nil> <nil>

We actually print like this What is printed is his value , yes nil That's right, .

But the type is not nil.

We can print his type like this ：

var f func()
var a *struct{}
fmt.Printf("%T,%T \n", f, a)

//  Output results 
func(),*struct {}

Two 、if sentence nil Contains the judgment of type

When we are from interface Take out the object inside , Use if Judge , He doesn't just compare values , There are also types .

Take a look at this code ：

var f func()
var a *struct{}

list := []interface{}{f, a, nil}
 for _, item := range list {
  fmt.Println("item=", item)
  fmt.Printf("item type: %T \n", item)
  if item == nil {
   fmt.Println("item == nil")
  }
  fmt.Println("----")
 }
}

Now look at the running results :

$ go run main.go 
item= <nil>
item type: func() 
----
item= <nil>
item type: *struct {} 
----
item= <nil>
item type: <nil> 
item == nil
----

You will find that at last nil Your judgment is passed , Neither of the first two judgments passed .

3、 ... and 、 How to judge whether the value is nil

When we're writing code , It's best to try to avoid this kind of code , If you insist on writing like this , Then we can judge by the following two common ways nil.

1、 Assertion

list := []interface{}{f, a}
for _, item := range list {
 if v, ok := item.(func()); ok && v == nil {
  fmt.Println("item is nil")
 }
 if v, ok := item.(*struct{}); ok && v == nil {
  fmt.Println("item is nil")
 }
}

2、 Reflection

list := []interface{}{f, a}
for _, item := range list {
 if reflect.ValueOf(item).IsNil() {
  fmt.Println("item is nil")
 }
}