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
}

至于哪种方法更好，就见仁见智了。希望大家在实际项目中不要踩坑，即使踩了也能快速跳出来！

网友评论

对于此类问题，即多个底层实现全部通过同一个 interface 类型来提供 API 的情况，个人的习惯是，构造函数的返回类型直接写成 interface 类型而不是具体的底层实现类型。比如文中的 func OpenRedis(url string, dbindex int) *redisEntityStorage 就可以改写成 func OpenRedis(url string, dbindex int) EntityStorage。这样一来构造函数里非 nil 的返回值会被 Go 自动装箱，返回 nil 则当作 nil interface value 而不是 nil concrete-typed value 来处理。此外尽量避免 type assertion。

另外，前些天 dave cheney 的一篇文章里提到了关于 go2 typed nil 的一些设想，非常期待 Go 2 到时候可以把这个坑给填了。

我也觉得interface{}和nil进行比较的时候，应该只比较值部分就行了，类型部分不管是不是空，都应该算作nil

摘自：http://studygolang.com/articles/10635