使用反射识别非内置类型

Question

我需要区分

等类型

type A []byte

来自 []byte。使用 reflect、reflect.TypeOf(A{}).Kind 告诉我它是 byte 的 Slice。我如何区分 []byte{} 和 A{}，而没有要检查的有界类型列表？

在较新版本的 Go 中有新的方法吗？

Answer 1

一些背景

首先让我们弄清楚一些与类型相关的东西。引用自 Spec: Types:

A type determines the set of values and operations specific to values of that type. Types may be named or unnamed. Named types are specified by a (possibly qualified) type name; unnamed types are specified using a type literal, which composes a new type from existing types.

因此有（预先声明的）命名类型，例如string、int等，您还可以使用[=54创建新的命名类型=]（涉及type关键字）如type MyInt int。还有 未命名类型 是 类型文字 （应用于/包括命名或未命名类型）的结果，例如 []int , struct{i int}, *int 等等

您可以使用 Type.Name() 方法获取命名类型的名称，其中 "returns an empty string for unnamed types":

var i int = 2
fmt.Printf("%q\n", reflect.TypeOf("abc").Name())              // Named: "string"
fmt.Printf("%q\n", reflect.TypeOf(int(2)).Name())             // Named: "int"
fmt.Printf("%q\n", reflect.TypeOf([]int{}).Name())            // Unnamed: ""
fmt.Printf("%q\n", reflect.TypeOf(struct{ i int }{}).Name())  // Unnamed: ""
fmt.Printf("%q\n", reflect.TypeOf(&struct{ i int }{}).Name()) // Unnamed: ""
fmt.Printf("%q\n", reflect.TypeOf(&i).Name())                 // Unnamed: ""

有些类型是预先声明的，可以供您使用（原样，或字面量）：

Named instances of the boolean, numeric, and string types are predeclared. Composite types—array, struct, pointer, function, interface, slice, map, and channel types—may be constructed using type literals.

预先声明的类型是：

bool byte complex64 complex128 error float32 float64
int int8 int16 int32 int64 rune string
uint uint8 uint16 uint32 uint64 uintptr

您可以使用Type.PkgPath()获取named类型的包路径，其中"if the type was predeclared (string, error) or unnamed (*T, struct{}, []int), the package path will be the empty string":

fmt.Printf("%q\n", reflect.TypeOf("abc").PkgPath())    // Predeclared: ""
fmt.Printf("%q\n", reflect.TypeOf(A{}).PkgPath())      // Named: "main"
fmt.Printf("%q\n", reflect.TypeOf([]byte{}).PkgPath()) // Unnamed: ""

所以你有 2 个工具可用：Type.Name() 判断类型是否为 named 类型，Type.PkgPath() 判断类型是否未预先声明并且是命名类型。

但必须小心。如果你在类型字面量中使用你自己的命名类型来构造一个新类型（例如 []A），那将是一个未命名类型（如果你不使用 type 关键字来构造一个新类型, 命名类型):

type ASlice []A

fmt.Printf("%q\n", reflect.TypeOf([]A{}).PkgPath())    // Also unnamed: ""
fmt.Printf("%q\n", reflect.TypeOf(ASlice{}).PkgPath()) // Named: "main"

在这种情况下你能做什么？您可以使用 Type.Elem() 来获取类型的元素类型，如果类型的 Kind 是 Array、Chan、Map、Ptr 或 Slice（否则 Type.Elem() 恐慌）：

fmt.Printf("%q\n", reflect.TypeOf([]A{}).Elem().Name())    // Element type: "A"
fmt.Printf("%q\n", reflect.TypeOf([]A{}).Elem().PkgPath()) // Which is named, so: "main"

总结

Type.PkgPath() 可用于 "filter out" 预先声明和未命名的类型。如果 PkgPath() returns 为非空字符串，则可以确定它是 "custom" 类型。如果它 returns 是一个空字符串，它仍然可能是从 "custom" 类型构造的未命名类型（在这种情况下 Type.Name() returns ""）；为此，您可以使用 Type.Elem() 来查看它是否由 "custom" 类型构造，可能必须递归地应用 :

// [][]A -> Elem() -> []A which is still unnamed: ""
fmt.Printf("%q\n", reflect.TypeOf([][]A{}).Elem().PkgPath())

// [][]A -> Elem() -> []A -> Elem() -> A which is named: "main"
fmt.Printf("%q\n", reflect.TypeOf([][]A{}).Elem().Elem().PkgPath())

尝试 Go Playground 上的所有示例。

特例 #1：匿名结构类型

还有一种情况是匿名结构类型是未命名的，但它可能有一个"custom"类型的字段。这种情况可以通过迭代结构类型的字段并对每个字段执行相同的检查来处理，如果发现其中任何一个是 "custom" 类型，我们可以声明整个结构类型是 "custom".

特例 #2：地图类型

在映射的情况下，我们可以考虑未命名的映射类型 "custom" 如果它的任何键或值类型是 "custom".

map的value类型可以用上面提到的Type.Elem()方法查询，map的key类型可以用Type.Key()方法查询——我们还要检查这个如果是地图。

示例实现

func isCustom(t reflect.Type) bool {
    if t.PkgPath() != "" {
        return true
    }

    if k := t.Kind(); k == reflect.Array || k == reflect.Chan || k == reflect.Map ||
        k == reflect.Ptr || k == reflect.Slice {
        return isCustom(t.Elem()) || k == reflect.Map && isCustom(t.Key())
    } else if k == reflect.Struct {
        for i := t.NumField() - 1; i >= 0; i-- {
            if isCustom(t.Field(i).Type) {
                return true
            }
        }
    }

    return false
}

正在测试（在 Go Playground 上试用）：

type K int
var i int = 2
fmt.Println(isCustom(reflect.TypeOf("")))                // false
fmt.Println(isCustom(reflect.TypeOf(int(2))))            // false
fmt.Println(isCustom(reflect.TypeOf([]int{})))           // false
fmt.Println(isCustom(reflect.TypeOf(struct{ i int }{}))) // false
fmt.Println(isCustom(reflect.TypeOf(&i)))                // false
fmt.Println(isCustom(reflect.TypeOf(map[string]int{})))  // false
fmt.Println(isCustom(reflect.TypeOf(A{})))               // true
fmt.Println(isCustom(reflect.TypeOf(&A{})))              // true
fmt.Println(isCustom(reflect.TypeOf([]A{})))             // true
fmt.Println(isCustom(reflect.TypeOf([][]A{})))           // true
fmt.Println(isCustom(reflect.TypeOf(struct{ a A }{})))   // true
fmt.Println(isCustom(reflect.TypeOf(map[K]int{})))       // true
fmt.Println(isCustom(reflect.TypeOf(map[string]K{})))    // true

使用反射识别非内置类型

Identify non builtin-types using reflect

reflection

go

go-reflect

一些背景

总结

特例 #1：匿名结构类型

特例 #2：地图类型

示例实现