回顾一下前面的内容，iface 包含两个字段：tab 是接口表指针，指向类型信息；data 是数据指针，则指向具体的数据，它们分别被称为动态类型和动态值，而接口值则包括动态类型和动态值。

我们来看一个接口类型和 nil 做比较的例子，当仅且当动态类型和动态值这两部分的值都为 nil 的情况下，接口值 == nil 为 true：

package main

import "fmt"

type Coder interface {
	code()
}

type Gopher struct {
	name string
}

func (g Gopher) code() {
	fmt.Printf("%s is coding\n", g.name)
}

func main() {
	var c Coder
	fmt.Println(c == nil)
	fmt.Printf("c: %T, %v\n", c, c)
	var g *Gopher
	fmt.Println(g == nil)
	c = g
	fmt.Println(c == nil)
	fmt.Printf("c: %T, %v\n", c, c)

}

输出如下：

true
c: <nil>, <nil>
true
false
c: *main.Gopher, <nil>

例子中，c 是一个接口，g 则是一个指针。一开始，c 的动态类型和动态值都为 nil，g 的值也为 nil，当把 g 赋值给 c 后，c 的动态类型变成了 *main.Gopher 尽管 c 的动态值仍为 nil，但是当 c 和 nil 做比较的时候，结果就是 false 了。

来看一个隐含的类型转换的例子：

package main
import "fmt"
type MyError struct {}

func (i MyError) Error() string {
  return "MyError"
}

func main() {
  err := Process()
  fmt.Println(err)
  fmt.Println(err == nil)
}

func Process() error {
  var err *MyError = nil
  return err
}

函数运行结果：

<nil>
false

这里先定义了一个 MyError 结构体，实现了 Error 函数，也就实现了 error 接口。Process 函数返回了一个 error 接口，这里隐含了类型转换，即 MyError 类型转换成 error 接口。所以，虽然它的动态值是 nil，但是它的动态类型是 *MyError，最后和 nil 比较的时候，结果为 false。

如何打印出接口的动态类型和值？下面的代码给出了一个例子：

package main

import (
  "unsafe"
  "fmt"
)

type iface struct {
  itab, data uintptr
}

func main() {
  var a interface{} = nil
  var b interface{} = (*int)(nil)
  x := 5
  var c interface{} = (*int)(&x)
  ia := *(*iface)(unsafe.Pointer(&a))
  ib := *(*iface)(unsafe.Pointer(&b))
  ic := *(*iface)(unsafe.Pointer(&c))
  fmt.Println(ia, ib, ic)
  fmt.Println(*(*int)(unsafe.Pointer(ic.data)))
}

代码里直接定义了一个 iface 结构体，用两个指针来描述 itab 和 data，之后将 a, b, c 在内存中的内容强制解释成自定义的 iface。最后就可以打印出动态类型和动态值的地址。

运行结果如下：

{0 0} {17426912 0} {17426912 842350714568}
5

可见，a 的动态类型和动态值的地址均为 0，也就是 nil；b 的动态类型和 c 的动态类型一致，都是 *int；最后，c 的动态值为 5。