// 声明一个未知类型的 a，表明不知道是什么类型
    var a interface{}
    a = 2
    fmt.Printf("%T,%v\n", a, a)

然后给变量赋值一个整数： a=2 ，这时 a 仍然是未知类型，使用占位符 %T 可以打印变量的真实类型，占位符 %v 打印值，这时 fmt.Printf 在内部会进行类型判断。

我们也可以将函数的参数也定为 interface ，和变量的定义一样：

func print(i interface{}) {
    fmt.Println(i)
}

使用时：

    // 传入函数
    print(a)
    print(3)
    print("i love you")

我们传入 print 函数的参数可以是任何类型，如整数 3 或字符串 i love you 等。进入函数后，函数内变量 i 丢失了类型，是一个未知类型，这种特征使得我们如果想处理不同类型的数据，不需要写多个函数。

当然，结构体里面的字段也可以是 interface{} ：

type H struct {
    A interface{}
    B interface{}
}

使用断言：

    // 使用断言，判断是否是 int 数据类型
    v, ok := a.(int)
    if ok {
        fmt.Printf("a is int type,value is %d\n", v)
    }

直接在变量后面使用 .(int) ，有两个返回值 v, ok 会返回。 ok 如果是 true 表明确实是整数类型，这个整数会被赋予 v ，然后我们可以拿 v 愉快地玩耍了。否则， ok 为 false ， v 为空值，也就是默认值 0。

如果我们每次都这样使用，会很难受，因为一个 interface{} 类型的变量，数据类型可能是 .(int) ，可能是 .(string) ，可以使用 switch 来简化：

    // 使用断言，判断变量类型
    switch a.(type) {
    case int:
        fmt.Println("a is type int")
    case string:
        fmt.Println("a is type string")
    default:
        fmt.Println("a not type found type")
    




    
}

在 swicth 中，断言不再使用 .(具体类型) ，而是 a.(type) 。

最后，还有一种方式，使用的是反射包 reflect 来确定数据类型：

    // 使用反射找出变量类型
    t := reflect.TypeOf(a)
    fmt.Printf("a is type: %s", t.Name())

这个包会直接使用非安全指针来获取真实的数据类型：

func TypeOf(i interface{}) Type {
    eface := *(*emptyInterface)(unsafe.Pointer(&i))
    return toType(eface.typ)
}

一般日常开发，很少使用反射包。

package main
import (
    "fmt"
    "reflect"
)
// 定义一个接口，有一个方法
type A interface {
    Println()
}
// 定义一个接口，有两个方法
type B interface {
    Println()
    Printf() int
}
// 定义一个结构体
type A1Instance struct {
    Data string
}
// 结构体实现了Println()方法，现在它是一个 A 接口
func (a1 *A1Instance) Println() {
    fmt.Println("a1:", a1.Data)
}
// 定义一个结构体
type A2Instance struct {
    Data string
}
// 结构体实现了Println()方法，现在它是一个 A 接口
func (a2 *A2Instance) Println() {
    fmt.Println("a2:", a2.Data)
}
// 结构体实现了Printf()方法，现在它是一个 B 接口，它既是 A 又是 B 接口
func (a2 *A2Instance) Printf() int {
    fmt.Println("a2:", a2.Data)
    return 0
}
func main() {
    // 定义一个A接口类型的变量
    var a A
    // 将具体的结构体赋予该变量
    a = &A1Instance{Data: "i love you"}
    // 调用接口的方法
    a.Println()
    // 断言类型
    if v, ok := a.(*A1Instance); ok {
        fmt.Println(v)
    } else {
        fmt.Println("not a A1")
    }
    fmt.Println(reflect.TypeOf(a).String())
    // 将具体的结构体赋予该变量
    a = &A2Instance{Data: "i love you"}
    // 调用接口的方法
    a.Println()
    // 断言类型
    if v, ok := a.(*A1Instance); ok {
        fmt.Println(v)
    } else {
        fmt.Println("not a A1")
    }
    fmt.Println(reflect.TypeOf(a).String())
    // 定义一个B接口类型的变量
    var b B
    //b = &A1Instance{Data: "i love you"} // 不是 B 类型
    b = &A2Instance{Data: "i love you"}
    fmt.Println(b.Printf())
}

输出：

a1: i love you
&{i love you}
*main.A1Instance
a2: i love you
not a A1
*main.A2Instance
a2: i love you
0

// 定义一个接口，有一个方法
type A interface {
    Println()
}
// 定义一个接口，有两个方法
type B interface {
    Println()
    Printf() int
}

// 定义一个结构体
type A1Instance struct {
    Data string
}
// 结构体实现了Println()方法，现在它是一个 A 接口
func (a1 *A1Instance) Println() {
    fmt.Println("a1:", a1.Data)
}
// 定义一个结构体
type A2Instance struct {
    Data string
}
// 结构体实现了Println()方法，现在它是一个 A 接口
func (a2 *A2Instance) Println() {
    fmt.Println("a2:", a2.Data)
}
// 结构体实现了Printf()方法，现在它是一个 B 接口，它既是 A 又是 B 接口
func (a2 *A2Instance) Printf() int {
    fmt.Println("a2:", a2.Data)
    return 0
}

    // 定义一个A接口类型的变量
    var a A
    // 将具体的结构体赋予该变量
    a = &A1Instance{Data: "i love you"}
    // 调用接口的方法
    a.Println()

    // 断言类型
    if v, ok := a.(*A1Instance); ok {
        fmt.Println(v)
    } else {
        fmt.Println("not a A1")
    }
    fmt.Println(reflect.TypeOf(a).String())