interface{} 与nil

golang 的interface{}大体可以描述为两个元素（type+data），只有当type和data都为nil的时候
interface才会与nil相等。

var v *T
var i interface{}
i = v

v 为空指针，所以必定等于nil
interface{}，type和data都是nil，所以也为nil
但是 i=v后，i的type不为nil了，所以此时不为nil

var a interface{}
    fmt.Println(a == nil) //true
    a = "1" //data="1" type=string
    fmt.Println(a == nil) //false
    var b *int
    a = b //data=nil type=int
    fmt.Println(a == nil) //false
    fmt.Println(b == nil) //true
    fmt.Println(b == a) //true

为什么a、b与nil之间的等价不具有传递性。
1. b==nil是正确的，在a=b的时候做了个封箱的操作，在a==b的时候做了拆箱的操作
2. golang在type和interface之间的转换不明显，容易让人误解。

error

error 其实就是一种特殊的interface{}

type error interface { Error() string }

example:

package main

import (
    "fmt"
)

type MyError struct {
    errCode uint8
}
func (e *MyError) Error() string {
    switch e.errCode {
    case 1:
        return "file not found"
    case 2:
        return "time out"
    case 3:
        return "permission denied"
    default:
        return "unknown error"
    }
}

// 相当于使用interface进行封箱操作
func GetError1() error {
    var err *MyError = nil
    return err
}

// 没有使用interface进行封箱操作
func GetError2() *MyError {
    var err *MyError = nil
    return err
}

func main() {
    ret1 := GetError1() //封箱，所以不为nil
    fmt.Println(ret1 == nil) //false
    e,_ := ret1.(*MyError) //显式拆箱，所以为nil
    fmt.Println(e == nil) //true

    ret2 := GetError2() // 不用转换，所以为nil
    fmt.Println(ret2 == nil) //true
}