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)
}
任何类型只要它提供了read和write的绑定函数实现，go就认为这个类型实现了这个interface（duck-type），而不像java需要开发者使用implements标明。
然而go语言的interface在使用过程中却有一个特别坑的特性，当你比较一个interface类型的值是否是nil的时候，这是需要特别注意避免的问题。
一次真实的踩坑
这是我们在goworld分布式游戏服务器的开发中，碰到的一个实际的bug。由于goworld支持多种不同的数据库（包括mongodb，redis等）来保存服务端对象，因此goworld在上层提供了一个统一的对象存储接口定义，而不同的对象数据库实现只需要实现entitystorage接口所提供的函数即可。
// entitystorage defines the interface of entity storage backends
type entitystorage interface {
list(typename string) ([]common.entityid, error)
write(typename string, entityid common.entityid, data interface{}) error
read(typename string, entityid common.entityid) (interface{}, error)
exists(typename string, entityid common.entityid) (bool, error)
close()
iseof(err error) bool
}
以一个使用redis作为对象数据库的实现为例，函数openredis连接redis数据库并最终返回一个redisentitystorage对象的指针。
// openredis opens redis as entity storage
func openredis(url string, dbindex int) *redisentitystorage {
c, err := redis.dialurl(url)
if err != nil {
return nil
}
if dbindex >= 0 {
if _, err := c.do("select", dbindex); err != nil {
return nil
}
}
es := &redisentitystorage{
c: c,
}
return es
}
在上层逻辑中，我们使用openredis函数连接redis数据库，并将返回的redisentitystorage指针赋值个一个entitystorage接口变量，因为redisentitystorage对象实现了entitystorage接口所定义的所有函数。
var storageengine storageengine // 这是一个全局变量
storageengine = openredis(cfg.url, dbindex)
if storageengine != nil {
// 连接成功
...
} else {
// 连接失败
...
}
上面的代码看起来都很正常，openredis在连接redis数据库失败的时候会返回nil，然后调用者将返回值和nil进行比较，来判断是否连接成功。这个就是go语言少有的几个深坑之一，因为不管openredis函数是否连接redis成功，都会运行连接成功的逻辑。
寻找问题所在
想要理解这个问题，首先需要理解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 testinterfacestructure(t *testing.t) {
var i1, i2 interface{}
var v1 int = 0x0aaaaaaaaaaaaaaa
var v2 int = 0x0bbbbbbbbbbbbbbb
i1 = v1
i2 = v2
fmt.printf("sizeof interface{} = %d\n", unsafe.sizeof(i1))
fmt.printf("i1 %x %+v\n", i1, asinterfacestructure(i1))
fmt.printf("i2 %x %+v\n", i2, asinterfacestructure(i2))
var nilinterface interface{}
fmt.printf("nil interface = %+v\n", asinterfacestructure(nilinterface))
}
这段代码的输出如下：
sizeof interface{} = 16
i1 aaaaaaaaaaaaaaa {pt:5328736 pv:825741282816}
i2 bbbbbbbbbbbbbbb {pt:5328736 pv:825741282824}
nil interface = {pt:0 pv:0}
所以对于一个interface{}类型的nil变量来说，它的两个指针都是0。这是符合go语言对nil的标准定义的。在go语言中，nil是零值（zero value），而在java之类的语言里，null实际上是空指针。关于零值和空指针有什么区别，这里就不再展开了。
当我们将一个具体类型的值赋值给一个interface类型的变量的时候，就同时把类型和值都赋值给了interface里的两个指针。如果这个具体类型的值是nil的话，interface变量依然会存储对应的类型指针和值指针。
func testassigninterfacenil(t *testing.t) {
var p *int = nil
var i interface{} = p
fmt.printf("%v %+v is nil %v\n", i, asinterfacestructure(i), i == nil)
}
输入如下：
<nil> {pt:5300576 pv:0} is nil false
可见，在这种情况下，虽然我们把一个nil值赋值给interface{}，但是实际上interface里依然存了指向类型的指针，所以拿这个interface变量去和nil常量进行比较的话就会返回false。
如何解决这个问题
想要避开这个go语言的坑，我们要做的就是避免将一个有可能为nil的具体类型的值赋值给interface变量。以上述的openredis为例，一种方法是先对openredis返回的结果进行非-nil检查，然后再赋值给interface变量，如下所示。
var storageengine storageengine // 这是一个全局变量
redis := openredis(cfg.url, dbindex)
if redis != nil {
// 连接成功
storageengine = redis // 确定redis不是nil之后再赋值给interface变量
} else {
// 连接失败
...
}
另外一种方法是让openredis函数直接返回entitystorage接口类型的值，这样就可以把openredis的返回值直接正确赋值给entitystorage接口变量。
// openredis opens redis as entity storage
func openredis(url string, dbindex int) entitystorage {
c, err := redis.dialurl(url)
if err != nil {
return nil
}
if dbindex >= 0 {
if _, err := c.do("select", dbindex); err != nil {
return nil
}
}
es := &redisentitystorage{
c: c,
}
return es
}
至于那种方法更好，就见仁见智了。希望大家在实际项目中不要踩坑，即使踩了也能快速跳出来！