为什么 nil != nil? Go “==“ 机制详解

最新推荐文章于 2024-01-15 16:55:02 发布

CV大使

最新推荐文章于 2024-01-15 16:55:02 发布

阅读量640

点赞数

分类专栏： Golang 文章标签：指针 go

本文链接：https://blog.csdn.net/timczm/article/details/119244013

版权

Golang 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文深入探讨了Go语言中nil比较的微妙之处，通过代码示例解释了为什么在某些情况下，即使是nil的指针在比较时也可能不相等。文章详细解析了类型、值以及==操作符在判断中的作用，并提供了如何正确检查nil的方法。

摘要由CSDN通过智能技术生成

这篇文章源于代码中关于 nil 判断的一个问题，我将从这里例子开始慢慢讲解。

先从一段代码看起，下面这个代码是将传入的对象转换成 JSON string并返回回去，其中，如果判断 i==nil 时，会返回""。

func ToJSONString(i interface{}) string {
   if i == nil {
      return ""
   }
   bytes, _ := json.Marshal(i)
   return string(bytes)
}

这段代码初看并没有太大的问题，但实际上这里隐含了一个不容易被发现的问题，在说明这个问题之前，我们先看下这段代码在什么情况下会出现问题

type Data struct {
   V int `json:"v"`
}

func TestToJSONString(t *testing.T) {
   a := assert.New(t)

   a.Equal("", ToJSONString(nil))

   var data *Data
   a.Equal("", ToJSONString(data))

   var k *int
   a.Equal("", ToJSONString(k))
}

这段测试代码中三个断言分别返回：

Success
Expect: "", Actual: "null"
Expect: "", Actual: "null"

这里很让人疑惑，data应该是nil，似乎data==nil的结论是false，为了确认这个问题，我们引入一段代码。

var a *int = nil
var b interface{} = nil

fmt.Println("a == nil:", a == nil)
fmt.Println("b == nil:", b == nil)
fmt.Println("a == b:", a == b)

你认为这里的结果是什么？

a == nil: true
b == nil: true
a == b: false

这太简单了，让我们看一个很相似，但稍微复杂些的例子

var a *int = nil
var b interface{} = a

fmt.Println("a == nil:", a == nil)
fmt.Println("b == nil:", b == nil)
fmt.Println("a == b:", a == b)

同样的，你认为这段代码的答案是什么？

a == nil: true
b == nil: false // 这是怎么回事？
a == b: true

到底发生了什么？

首先我们要了解的是：在Go中，每个指针都有2个基本信息，指针的类型和指针的值，后续我将会使用(type, value)这样的形式来体现。也就是说，a := nil这样的代码无法通过编译，因为它缺失了type，所以需要这样var a *int = nil。
我们可以在fmt中输出这些指针的 type：

var a *int = nil
var b interface{} = nil

fmt.Printf("a.type:%T\n", a) // a.type:*int
fmt.Printf("b.type:%T\n", b) // b.type:<nil>

我们现在已经了解了 interace{} 的默认 type 为 nil，下面我们不使用硬编码的方式，而是将 a 传递给 b ，然后再来看下结果：

var a *int = nil
var b interface{} = a

fmt.Printf("a.type:%T\n", a) // a.type:*int
fmt.Printf("b.type:%T\n", b) // b.type:*int

也就是说，b 现在有了一个新的类型 *int。目前你已经了解了关于类型的一些基本机制，但还有一些问题还没有被解答

当执行 `==` 时，发生了什么？

在前面，我们已经了解了变量的类型是如何确定的，接下来，我们来了解 == 的内部原理。

var a *int = nil
var b interface{} = nil

fmt.Printf("a=(%T, %v)\n", a, a)
fmt.Printf("b=(%T, %v)\n", b, b)
fmt.Println("a == nil:", a == nil)
fmt.Println("b == nil:", b == nil)
fmt.Println("a == b:", a == b)

在下面这段代码中，我同时打印了变量的类型和值，其结果如下：

a=(*int, <nil>)
b=(<nil>, <nil>)
a == nil: true
b == nil: true
a == b: false

这段代码乍一看似乎不可能，像是在说：anil、bnil，但a!=b。实际情况是，类型判断不仅仅只判断二者的值，还会判断其类型。

a == nil // 等价于：(*int, nil) == (*int, nil)
b == nil // 等价于：(nil, nil) == (nil, nil)
a == b   // 等价于：(*int, nil) == (nil, nil)

当我们用这样的方式写出来时，我们可以很轻易的明白，a!=b是成立的，但这些信息并不会在代码中体现出来，这也正是容易出现误解的地方。在这里，如果你想要判断二者是否都是nil，你可以这样写

if a == nil && b == nil {
  // do something
}

接下来我们再来看看前面那个令人困惑的例子，相关结果直接跟在了代码后面

var a *int = nil
var b interface{} = a

fmt.Printf("a=(%T, %v)\n", a, a)   // a=(*int, <nil>)
fmt.Printf("b=(%T, %v)\n", b, b)   // b=(*int, <nil>)
fmt.Println("a == nil:", a == nil) // a == nil: true
fmt.Println("b == nil:", b == nil) // b == nil: false
fmt.Println("a == b:", a == b)     // a == b: true

现在我们再来看b==nil这段代码会发现明朗许多：

b == nil // 等价于：(*int, nil) == (nil, nil)

这里可能会疑惑，为什么等式右侧的 nil，其 type 为 nil 呢？这是因为当 b 指定为 interface{} 类型的时候，无法确定其真实的类型，随着程序的运行，其类型可能会不断改变，所以其类型默认为 nil。
更进一步，我们可以看一个硬编码的数字是如何进行比较判断的。数字会根据上下文来推断自己的类型，一个具体的例子如下：

var a int = 12
var b float64 = 12
var c interface{} = a

fmt.Println("a==12:", a == 12) // true  => (int, 12) == (int, 12)
fmt.Println("b==12:", b == 12) // true  => (float64, 12) == (float64, 12)
fmt.Println("c==12:", c == 12) // true  => (int, 12) == (int, 12)
fmt.Println("a==c:", a == c)   // true  => (int, 12) == (int, 12)
fmt.Println("b==c:", b == c)   // false => (float64, 12) == (int, 12)

一个需要注意的点是，当 12 与一个 interface{} 进行比较时，会默认转换为 (int, 12)，类似的，interface{} 也会被强制转换为 (nil, nil)，如下代码展示了这个过程

var b float64 = 12
var c interface{} = b

fmt.Println("c==12:", c == 12) // c==12: false
fmt.Printf("c=(%T,%v)\n", c, c) // c=(float64,12)
fmt.Printf("hard-coded=(%T,%v)\n", 12, 12) // hard-coded=(int,12)

回到最开始的 nil 判断

让我们回到最开始出现问题的代码，现在再来看会清晰许多

func ToJSONString(i interface{}) string {
   if i == nil {
      return ""
   }
   bytes, _ := json.Marshal(i)
   return string(bytes)
}

func TestToJSONString() {
  // ...
  var data *Data
  a.Equal("", ToJSONString(data))
}

第2行中，i==nil 的判断相当于 (*Data, nil) == (nil, nil) ，显而易见，这样的等式并不会成立。当然，我们有其他的办法来出现这样的等式判断，这需要用到 reflect 包，如下：

func ToJSONString(i interface{}) string {
   if i == nil || (reflect.ValueOf(i).Kind() == reflect.Ptr && reflect.ValueOf(i).IsNil()) {
      return ""
   }
   bytes, _ := json.Marshal(i)
   return string(bytes)
}