reflect.TypeOf 的反转

Question

我想取回我保存过一次的值类型。我使用 reflect.Typeof() 并保存了类型。然后尝试使用开关类型。类型将始终为“*reflect.rtype”。我无法通过类型断言检索任何一个。

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var alltypes []interface{}

    alltypes = append(alltypes, reflect.TypeOf(true))
    alltypes = append(alltypes, reflect.TypeOf(0.0))
    alltypes = append(alltypes, reflect.TypeOf(0))
    fmt.Printf("%T\t%q\n", alltypes, alltypes)

    for _, v := range alltypes {
        fmt.Printf("%T\t%q\n", v, v)
        res, ok := v.(bool)
        fmt.Println("res: ", res, " ok: ", ok)
        switch v.(type) {
        default:
            fmt.Printf("unexpected type %T\n", v)
        case bool:
            fmt.Println("bool type!")
        case int:
            fmt.Println("int type!")
        case float64:
            fmt.Println("float64 type!")
        }
    }

}

游乐场：https://play.golang.org/p/kqDo4DPYjra

Answer 1

A reflect.Type holds no value you could type assert（实际上你可以，但那只能是 reflect.Type，而不是你想要的）。 reflect.Type 只是一个类型描述符（您从值中获得）。

但是，您可以创建一个由 reflect.Type 表示的类型的值，并且您可以对您最初想要的值进行类型断言。

要创建新的指针值，请使用 reflect.New(). To obtain the pointed value, use Value.Elem(). These are all wrapped in a reflect.Value. To unwrap it, use Value.Interface()。

例如：

for _, v := range alltypes {
    fmt.Printf("%T\t%q\n", v, v)
    value := reflect.New(v.(reflect.Type)).Elem().Interface()
    switch value.(type) {
    default:
        fmt.Printf("unexpected type %T\n", v)
    case bool:
        fmt.Println("bool type!")
    case int:
        fmt.Println("int type!")
    case float64:
        fmt.Println("float64 type!")
    }
}

这将输出（在 Go Playground 上尝试）：

[]interface {}  ["bool" "float64" "int"]
*reflect.rtype  "bool"
bool type!
*reflect.rtype  "float64"
float64 type!
*reflect.rtype  "int"
int type!

此外，如果您不想创建新值，只需测试类型，"save" 您感兴趣的类型的 reflect.Type 描述符，并使用正常的 switch 关于类型：

var (
    TypeBool    = reflect.TypeOf(true)
    TypeFloat64 = reflect.TypeOf(0.0)
    TypeInt     = reflect.TypeOf(0)
)

func main() {
    var alltypes []interface{}

    alltypes = append(alltypes, reflect.TypeOf(true))
    alltypes = append(alltypes, reflect.TypeOf(0.0))
    alltypes = append(alltypes, reflect.TypeOf(0))
    fmt.Printf("%T\t%q\n", alltypes, alltypes)

    for _, v := range alltypes {
        fmt.Printf("%T\t%q\n", v, v)
        switch v {
        default:
            fmt.Printf("unexpected type %T\n", v)
        case TypeBool:
            fmt.Println("bool type!")
        case TypeInt:
            fmt.Println("int type!")
        case TypeFloat64:
            fmt.Println("float64 type!")
        }
    }
}

这将输出（在 Go Playground 上尝试）：

[]interface {}  ["bool" "float64" "int"]
*reflect.rtype  "bool"
bool type!
*reflect.rtype  "float64"
float64 type!
*reflect.rtype  "int"
int type!

推荐阅读：The Go Blog: The Laws of Reflection

Answer 2

根据您想要执行的操作，您不一定需要使用类型断言来执行此操作。 v.(reflect.Type).Kind() 会告诉您它是哪种类型（例如，reflect.Bool、reflect.Float64、reflect.Int 等）。

reflect.TypeOf 的反转

Reverse of reflect.TypeOf

go

reflection

types

type-assertion