Go语言中获取对象类型的实践指南：深入理解 reflect.TypeOf()

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var strVar string = "Hello Go"
    var intVar int = 100
    var floatVar float64 = 3.14159

    fmt.Println("字符串类型:", reflect.TypeOf(strVar))
    fmt.Println("整型类型:", reflect.TypeOf(intVar))
    fmt.Println("浮点型类型:", reflect.TypeOf(floatVar))
}

字符串类型: string
整型类型: int
浮点型类型: float64

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 假设 `lines` 是一个字符串切片
    lines := []string{"line1", "line2", "line3"}
    fmt.Println("字符串切片类型:", reflect.TypeOf(lines))

    // 如果是在迭代器中，例如 `container/list`，`e.Value` 的类型是 `interface{}`
    // `reflect.TypeOf()` 会揭示其底层具体类型
    var eValue interface{} = []string{"itemA", "itemB"}
    fmt.Println("迭代器中的值类型:", reflect.TypeOf(eValue))
}

字符串切片类型: []string
迭代器中的值类型: []string

package main

import (
    "fmt"
    "reflect"
)

func main() {
    mySlice := []int{1, 2, 3}
    typeOfSlice := reflect.TypeOf(mySlice)

    fmt.Println("--- 切片类型信息 ---")
    fmt.Printf("类型名称 (Name()): %q\n", typeOfSlice.Name()) // 切片是匿名类型，Name()为空
    fmt.Println("类型种类 (Kind()):", typeOfSlice.Kind())     // 输出 slice
    if typeOfSlice.Kind() == reflect.Slice {
        fmt.Println("切片元素类型 (Elem()):", typeOfSlice.Elem()) // 输出 int
    }

    myMap := map[string]int{"a": 1, "b": 2}
    typeOfMap := reflect.TypeOf(myMap)

    fmt.Println("\n--- 映射类型信息 ---")
    fmt.Println("类型种类 (Kind()):", typeOfMap.Kind()) // 输出 map
    if typeOfMap.Kind() == reflect.Map {
        fmt.Println("映射键类型 (Key()):", typeOfMap.Key())   // 输出 string
        fmt.Println("映射值类型 (Elem()):", typeOfMap.Elem()) // 输出 int
    }

    type MyStruct struct {
        Field1 string
        Field2 int
    }
    myStruct := MyStruct{}
    typeOfStruct := reflect.TypeOf(myStruct)
    fmt.Println("\n--- 结构体类型信息 ---")
    fmt.Println("类型名称 (Name()):", typeOfStruct.Name())     // 输出 MyStruct
    fmt.Println("类型种类 (Kind()):", typeOfStruct.Kind())     // 输出 struct
    fmt.Println("包路径 (PkgPath()):", typeOfStruct.PkgPath()) // 输出 main
}

package main

import "fmt"

// process 函数接收一个 interface{} 类型，并根据其具体类型进行处理
func process(data interface{}) {
    switch v := data.(type) {
    case int:
        fmt.Printf("处理一个整型值: %d\n", v)
    case string:
        fmt.Printf("处理一个字符串值: %s\n", v)
    case []string:
        fmt.Printf("处理一个字符串切片: %v\n", v)
    default:
        // 对于未知类型，%T 格式化动词可以方便地打印其类型名称
        fmt.Printf("未知类型: %T, 值: %v\n", v, v)
    }
}

func main() {
    process(123)
    process("hello world")
    process([]string{"apple", "banana"})
    process(3.14) // 浮点型
    process(true) // 布尔型
}

处理一个整型值: 123
处理一个字符串值: hello world
处理一个字符串切片: [apple banana]
未知类型: float64, 值: 3.14
未知类型: bool, 值: true