基于go interface{}==nil 的几种坑及原理分析

本文是Go比较有名的一个坑,在以前面试的时候也被问过,为什么想起来写这个?

因为我们线上就真实出现过这个坑,写给不了解的人在使用 if err != nil 的时候提高警惕。

Go语言的interface{}在使用过程中有一个特别坑的特性,当你比较一个interface{}类型的值是否是nil的时候,这是需要特别注意避免的问题。

先来看看一个demo:

package main
import "fmt"
type ErrorImpl struct{}
func (e *ErrorImpl) Error() string {
   return ""
}
var ei *ErrorImpl
var e error
func ErrorImplFun() error {
   return ei
}
func main() {
   f := ErrorImplFun()
   fmt.Println(f == nil)
}

输出:

false

为什么不是true?

想要理解这个问题,首先需要理解interface{}变量的本质。在Go语言中,一个interface{}类型的变量包含了2个指针,一个指针指向值的在编译时确定的类型,另外一个指针指向实际的值。

// InterfaceStructure 定义了一个interface{}的内部结构
type InterfaceStructure struct {
  pt uintptr // 到值类型的指针
  pv uintptr // 到值内容的指针
}
// asInterfaceStructure 将一个interface{}转换为InterfaceStructure
func asInterfaceStructure(i interface{}) InterfaceStructure {
  return *(*InterfaceStructure)(unsafe.Pointer(&i))
}
func main() {
  var i1, i2 interface{}
  var v1 int = 23
  var v2 int = 23
  i1 = v1
  i2 = v2
  fmt.Printf("sizeof interface{} = %d\n", unsafe.Sizeof(i1))
  fmt.Printf("i1 %v %+v\n", i1, asInterfaceStructure(i1))
  fmt.Printf("i2 %v %+v\n", i2, asInterfaceStructure(i2))
  var nilInterface interface{}
  var str *string
  fmt.Printf("nil interface = %+v\n", asInterfaceStructure(nilInterface))
  fmt.Printf("nil string = %+v\n", asInterfaceStructure(str))
  fmt.Printf("nil = %+v\n", asInterfaceStructure(nil))
}

输出:

sizeof interface{} = 16

i1 23 {pt:4812032 pv:825741246928}

i2 23 {pt:4812032 pv:825741246936}

nil interface = {pt:0 pv:0}

nil string = {pt:4802400 pv:0}

nil = {pt:0 pv:0}

当我们将一个具体类型的值赋值给一个interface{}类型的变量的时候,就同时把类型和值都赋值给了interface{}里的两个指针。如果这个具体类型的值是nil的话,interface{}变量依然会存储对应的类型指针和值指针。

如何解决?

方法一

返回的结果进行非nil检查,然后再赋值给interface{}变量

type ErrorImpl struct{}
func (e *ErrorImpl) Error() string {
   return ""
}
var ei *ErrorImpl
var e error
func ErrorImplFun() error {
   if ei == nil {
      return nil
   }
   return ei
}
func main() {
   f := ErrorImplFun()
   fmt.Println(f == nil)
}

输出:

true

方法二

返回具体实现的类型而不是interface{}

package main
import "fmt"
type ErrorImpl struct{}
func (e *ErrorImpl) Error() string {
   return ""
}
var ei *ErrorImpl
var e error
func ErrorImplFun() *ErrorImpl {
   return ei
}
func main() {
   f := ErrorImplFun()
   fmt.Println(f == nil)
}

输出:

true

解决由于第三方包带来的坑

由于有的error是第三方包返回的,又自己不想改第三方包,只好接收处理的时候想办法。

方法一

利用interface{}原理

 is:=*(*InterfaceStructure)(unsafe.Pointer(&i))
 if is.pt==0 && is.pv==0 {
     //is nil do something
 }

将底层指向值和指向值的类型的指针打印出来如果都是0,表示是nil

方法二

利用断言,断言出来具体类型再判断非空

type ErrorImpl struct{}
func (e ErrorImpl) Error() string {
   return "demo"
}
var ei *ErrorImpl
var e error
func ErrorImplFun() error {
   //ei = &ErrorImpl{}
   return ei
}
func main() {
   f := ErrorImplFun()
   //当然error实现类型较多的话使用
 //switch case方式断言更清晰
   res, ok := f.(*ErrorImpl)
   fmt.Printf("ok:%v,f:%v,res:%v",
   ok, f == nil, res == nil)
}

输出:

ok:true,f:false,res:true

方法三

利用反射

type ErrorImpl struct{}
func (e ErrorImpl) Error() string {
   return "demo"
}
var ei *ErrorImpl
var e error
func ErrorImplFun() error {
   //ei = &ErrorImpl{}
   return ei
}
func main() {
   f := ErrorImplFun()
   rv := reflect.ValueOf(f)
   fmt.Printf("%v", rv.IsNil())
}

输出:

true

注意⚠:

断言和反射性能不是特别好,如果不得已再使用,控制使用有助于提升程序性能。

由于函数接收类型导致的panic:

type ErrorImpl struct{}
func (e ErrorImpl) Error() string {
   return "demo"
}
var ei *ErrorImpl
var e error
func ErrorImplFun() error {
   return ei
}
func main() {
   f := ErrorImplFun()
   fmt.Printf(f.Error())
}

输出:

panic: value method main.ErrorImpl.Error called using nil *ErrorImpl pointer

解决:

func (e *ErrorImpl) Error() string {
   return "demo"
}

输出:

demo

可以发现将接收类型变成指针类型就可以了。

以上就是 nil 相关的坑,希望大家可以牢记,如果 ”幸运“ 的遇到了,可以想到这些可能性。

补充:go 语言 interface{} 的易错点

如果说 goroutine 和 channel 是 go 语言并发的两大基石,那 interface 就是 go 语言类型抽象的关键。

在实际项目中,几乎所有的数据结构最底层都是接口类型。

说起 C++ 语言,我们立即能想到是三个名词:封装、继承、多态。go 语言虽然没有严格意义上的对象,但通过 interface,可以说是实现了多态性。(由以组合结构体实现了封装、继承的特性)

package main
type animal interface {
    Move()
}
type bird struct{}
func (self *bird) Move() {
    println("bird move")
}
type beast struct{}
func (self *beast) Move() {
    println("beast move")
}
func animalMove(v animal) {
    v.Move()
}
func main() {
    var a *bird
    var b *beast
    animalMove(a) // bird move
    animalMove(b) // beast move
}

go 语言中支持将 method、struct、struct 中成员定义为 interface 类型,使用 struct 举一个简单的栗子

使用 go 语言的 interface 特性,就能实现多态性,进行泛型编程。

二,interface 原理

如果没有充分了解 interface 的本质,就直接使用,那最终肯定会踩到很深的坑,要用就先要了解,先来看看 interface 源码

 type eface struct {
     _type *_type
     data  unsafe.Pointer
 }
 type _type struct {
     size       uintptr // type size
     ptrdata    uintptr // size of memory prefix holding all pointers
     hash       uint32  // hash of type; avoids computation in hash tables
     tflag      tflag   // extra type information flags
     align      uint8   // alignment of variable with this type
     fieldalign uint8   // alignment of struct field with this type
     kind       uint8   // enumeration for C
     alg        *typeAlg  // algorithm table
     gcdata    *byte    // garbage collection data
     str       nameOff  // string form
     ptrToThis typeOff  // type for pointer to this type, may be zero
 }

可以看到 interface 变量之所以可以接收任何类型变量,是因为其本质是一个对象,并记录其类型和数据块的指针。(其实 interface 的源码还包含函数结构和内存分布,由于不是本文重点,有兴趣的同学可以自行了解)

三,interface 判空的坑

对于一个空对象,我们往往通过 if v == nil 的条件语句判断其是否为空,但在代码中充斥着 interface 类型的情况下,很多时候判空都并不是我们想要的结果(其实了解或聪明的同学从上述 interface 的本质是对象已经知道我想要说的是什么)

package main
 type animal interface {
     Move()
 }
 type bird struct{}
 func (self *bird) Move() {
     println("bird move")
 }
 type beast struct{}
 func (self *beast) Move() {
     println("beast move")
 }
 func animalMove(v animal) {
     if v == nil {
         println("nil animal")
     }
     v.Move()
 }
 func main() {
     var a *bird   // nil
     var b *beast  // nil
     animalMove(a) // bird move
     animalMove(b) // beast move
 }

还是刚才的栗子,其实在 go 语言中 var a *bird 这种写法,a 只是声明了其类型,但并没有申请一块空间,所以这时候 a 本质还是指向空指针,但我们在 aminalMove 函数进行判空是失败的,并且下面的 v.Move() 的调用也是成功的,本质的原因就是因为 interface 是一个对象,在进行函数调用的时候,就会将 bird 类型的空指针进行隐式转换,转换成实例的 interface animal 对象,所以这时候 v 其实并不是空,而是其 data 变量指向了空。

这时候看着执行都正常,那什么情况下坑才会绊倒我们呢?只需要加一段代码

package main
 type animal interface {
     Move()
 }
 type bird struct {
    name string
 }
 func (self *bird) Move() {
     println("bird move %s", self.name) // panic
 }
 type beast struct {
     name string
 }
 func (self *beast) Move() {
     println("beast move %s", self.name) // panic
 }
 func animalMove(v animal) {
     if v == nil {
         println("nil animal")
     }
     v.Move()
 }
 func main() {
     var a *bird   // nil
     var b *beast  // nil
     animalMove(a) // panic
     animalMove(b) // panic
 }

在代码中,我们给派生类添加 name 变量,并在函数的实现中进行调用,就会发生 panic,这时候的 self 其实是 nil 指针。所以这里坑就出来了。

有些人觉得这类错误谨慎一些还是可以避免的,那是因为我们是正向思维去代入接口,但如果反向编程就容易造成很难发现的 bug

package main
 type animal interface {
     Move()
 }
 type bird struct {
     name string
 }
 func (self *bird) Move() {
     println("bird move %s", self.name)
 }
 type beast struct {
     name string
 }
 func (self *beast) Move() {
     println("beast move %s", self.name)
 }
 func animalMove(v animal) {
     if v == nil {
         println("nil animal")
     }
     v.Move()
 }
 func getBirdAnimal(name string) *bird {
     if name != "" {
         return &bird{name: name}
     }
     return nil
 }
 func main() {
     var a animal
     var b animal
     a = getBirdAnimal("big bird")
     b = getBirdAnimal("") // return interface{data:nil}
     animalMove(a) // bird move big bird
     animalMove(b) // panic
 }

这里我们看到通过函数返回实例类型指针,当返回 nil 时,因为接收的变量为接口类型,所以进行了隐性转换再次导致了 panic(这类反向转换很难发现)。

那我们如何处理上述这类问题呢。我这边整理了三个点

1,充分了解 interface 原理,使用过程中需要谨慎小心

2,谨慎使用泛型编程,接收变量使用接口类型,也需要保证接口返回为接口类型,而不应该是实例类型

3,判空是使用反射 typeOf 和 valueOf 转换成实例对象后再进行判空

时间: 2021-04-24

详解Golang语言中的interface

interface是一组method签名的组合,interface可以被任意对象实现,一个对象也可以实现多个interface.任意类型都实现了空interface(也就是包含0个method的interface),空interface可以存储任意类型的值.interface定义了一组方法,如果某个对象实现了某个接口的所有方法,则此对象就实现了此接口. go version go1.12 package main import ( "fmt" ) // 定义struct type Hu

使用go的interface案例实现多态范式操作

看程序: package main import "fmt" type BaseIntf interface { Process() } type Msg1 struct { req int rsp int } func (p *Msg1) Process() { fmt.Println("process 1") } type Msg2 struct { req int rsp int } func (p *Msg2) Process() { fmt.Println

Go语言interface 与 nil 的比较

interface简介 Go语言以简单易上手而著称,它的语法非常简单,熟悉C++,Java的开发者只需要很短的时间就可以掌握Go语言的基本用法. interface是Go语言里所提供的非常重要的特性.一个interface里可以定义一个或者多个函数,例如系统自带的io.ReadWriter的定义如下所示: type ReadWriter interface { Read(b []byte) (n int, err error) Write(b []byte) (n int, err error)

golang interface判断为空nil的实现代码

要判断interface 空的问题,首先看下其底层实现. interface 底层结构 根据 interface 是否包含有 method,底层实现上用两种 struct 来表示:iface 和 eface.eface表示不含 method 的 interface 结构,或者叫 empty interface. 对于 Golang 中的大部分数据类型都可以抽象出来 _type 结构,同时针对不同的类型还会有一些其他信息. 1.eface type eface struct { _type *_t

golang 实现interface{}转其他类型操作

golang中的string是可以转换为byte数组或者rune数组 但是其实byte对应的类型是uint8,而rune对应的数据类型就是int32 所以string可以转换为四种类型 //interface转其他类型----返回值是interface,直接赋值是无法转化的 //interface 转string var a interface{} var str5 string a = "3432423" str5 = a.(string) fmt.Println(str5) //i

golang语言如何将interface转为int, string,slice,struct等类型

在golang中,interface{}允许接纳任意值,int,string,struct,slice等,因此我可以很简单的将值传递到interface{},例如: package main import ( "fmt" ) type User struct{ Name string } func main() { any := User{ Name: "fidding", } test(any) any2 := "fidding" test(a

Go语言string,int,int64 ,float之间类型转换方法

(1)int转string s := strconv.Itoa(i) 等价于s := strconv.FormatInt(int64(i), 10) (2)int64转string i := int64(123) s := strconv.FormatInt(i, 10) 第二个参数为基数,可选2~36 注:对于无符号整形,可以使用FormatUint(i uint64, base int) (3)string转int i, err := strconv.Atoi(s) (4)string转in

Go语言中你不知道的Interface详解

前言 最近在看Go语言的面向对象的知识点时,发现它的面向对象能力全靠 interface 撑着,而且它的 interface 还与我们以前知道的 interface 完全不同.故而整个过程不断的思考为什么要如此设计?这样设计给我们带来了什么影响? interface 我不懂你 Rob Pike 曾说: 如果只能选择一个Go语言的特 性移植到其他语言中,他会选择接口 被Go语言设计者如此看重,想来 interface 一定是资质不凡,颜值爆表.但是说实话,当我第一次读这部分内容的时候,我产生了以下

golang语言编码规范的实现

本规范旨在为日常Go项目开发提供一个代码的规范指导,方便团队形成一个统一的代码风格,提高代码的可读性,规范性和统一性.本规范将从命名规范,注释规范,代码风格和 Go 语言提供的常用的工具这几个方面做一个说明.该规范参考了 go 语言官方代码的风格制定. 一. 命名规范 命名是代码规范中很重要的一部分,统一的命名规则有利于提高的代码的可读性,好的命名仅仅通过命名就可以获取到足够多的信息. Go在命名时以字母a到Z或a到Z或下划线开头,后面跟着零或更多的字母.下划线和数字(0到9).Go不允许在命名

Go语言基础知识总结(语法、变量、数值类型、表达式、控制结构等)

一.语法结构 golang源码采用UTF-8编码.空格包括:空白,tab,换行,回车. - 标识符由字母和数字组成(外加'_'),字母和数字都是Unicode编码. - 注释: 复制代码 代码如下: /* This is a comment; no nesting */ // So is this. 二.字面值(literals)类似C语言中的字面值,但数值不需要符号以及大小标志: 复制代码 代码如下: 23 0x0FF 1.234e7类似C中的字符串,但字符串是Unicode/UTF-8编码的

C#判断一个String是否为数字类型

方案一:Try...Catch(执行效率不高) 复制代码 代码如下: private bool IsNumberic(string oText) {     try     {         int var1=Convert.ToInt32 (oText);         return true;     }     catch     {         return false;     } } 方案二:正则表达式(推荐) a) 复制代码 代码如下: public static bool

Android多国语言转换Excel及Excel转换为string详解

前言 在实际的开发中,当我们完成了一个apk,一般都是英语和中文简体这两种语语言,如果发布了,则需要把字符转换给翻译公司,让他们帮忙翻译,一般提供一个 Excel 表格,如下: 当翻译完成之后,我们希望能把它快速转换成 value-xx 文件下对应的 string 或者 arrays ,如: 我只要复制粘贴即可.当然网上也有很多大神用 Python 或者其他语言写了,但是我们用 Android 的,所以肯定用 Java 了.于是我写了个 EasyTransLib 用来方便翻译.因为 studio

golang语言实现的文件上传与文件下载功能示例

本文实例讲述了golang实现的文件上传与文件下载功能.分享给大家供大家参考,具体如下: upload.go 复制代码 代码如下: package common import (  "io/ioutil"  "os"  "path"  "github.com/gin-gonic/gin"  "googo.co/goo"  "googo.co/utils" ) const (  UPLOA

Redis String 类型和 Hash 类型学习笔记与总结

Linux 版本信息: 复制代码 代码如下: cat /etc/issue  或cat /etc/redhat-release(Linux查看版本当前操作系统发行版信息) CentOS release 6.6 (Final) (一)String 类型 [定义]string 是最简单的类型,你可以理解成与 Memcached 是一模一样的类型,一个 key 对应一个 value,其上支持的操作与 Memcached 的操作类似.但它的功能更丰富. string 类型是二进制安全的.意思是 redi

C#、.Net中把字符串(String)格式转换为DateTime类型的三种方法

方式一:Convert.ToDateTime(string) 复制代码 代码如下: Convert.ToDateTime(string) 注意:string格式有要求,必须是yyyy-MM-dd hh:mm:ss 方式二:Convert.ToDateTime(string, IFormatProvider) 复制代码 代码如下: DateTimeFormatInfo dtFormat = new System.GlobalizationDateTimeFormatInfo(); dtFormat

易语言设置在驱动器框中显示指定的驱动器类型

类型属性 所属对象:驱动器框   操作系统支持:Windows ,数据类型:整数型: 将整数型数据赋值到指定对象的类型属性中 语法:对象.类型 = 整数型 应用对象:驱动器框 可供选择的属性值: 0.全部驱动器 1.可抽取式驱动器 2.固定驱动器 3.光盘驱动器 4.网络驱动器 5.内存虚拟驱动器 例程 说明: 本属性设置在驱动器框中所显示的驱动器类型.类型1为软盘驱动器,类型2为硬盘驱动器,类型3为光盘驱动器,类型4为网络驱动器,即主机带若干子机的形式,类型5为内存虚拟驱动器,即在内存中建立的