深入理解Go语言的Type-Value Pair(类型-值对)的使用

// 普通变量：Static Type=int，Value=10
var a int = 10
// 普通变量：Static Type=string，Value="Go Pair"
var b string = "Go Pair"

package main

import "fmt"

func main() {
    // 普通变量：Pair=(int, 20)
    var num int = 20
    // 空接口变量：Static Type=interface{}，Concrete Type=int，Value=20
    var emptyIface interface{} = num

    // 类型断言：从空接口中提取Concrete Type=int的Value
    if v, ok := emptyIface.(int); ok {
        fmt.Printf("类型：%T，值：%d\n", v, v) // 输出：类型：int，值：20
    }
}

package main

import "fmt"

// 定义两个接口
type Reader interface {
    Read() string
}

type Writer interface {
    Write() string
}

// 定义结构体，实现两个接口
type Book struct {
    Name string
}

func (b Book) Read() string {
    return "阅读：" + b.Name
}

func (b Book) Write() string {
    return "记录：" + b.Name
}

func main() {
    // 结构体实例：Pair=(Book, Book{Name:"Go实战"})
    book := Book{Name: "Go实战"}
    
    // 赋值给Reader接口：Pair=(Reader, Book, Book{Name:"Go实战"})
    var r Reader = book
    // 赋值给Writer接口：Pair=(Writer, Book, Book{Name:"Go实战"})
    var w Writer = book

    // 类型断言：Reader -> Book（成功，因为Concrete Type是Book）
    if b, ok := r.(Book); ok {
        fmt.Println(b.Read()) // 输出：阅读：Go实战
    }

    // 类型断言：Writer -> Reader（成功，因为底层Concrete Type都是Book）
    if r2, ok := w.(Reader); ok {
        fmt.Println(r2.Read()) // 输出：阅读：Go实战
    }
}

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var str = "Hello Pair"
    // 获取Type
    t := reflect.TypeOf(str)
    // 获取Value
    v := reflect.ValueOf(str)

    fmt.Printf("Type：%s，Kind：%s，Value：%v\n", t.Name(), t.Kind(), v)
    // 输出：Type：string，Kind：string，Value：Hello Pair

    // 空接口的反射
    var iface interface{} = str
    t2 := reflect.TypeOf(iface)
    v2 := reflect.ValueOf(iface)
    fmt.Printf("接口Type：%s，接口Value：%v\n", t2.Name(), v2)
    // 输出：接口Type：string，接口Value：Hello Pair
}