go - 使用反射识别非内置类型

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 等，您还可以使用 type declarations (其中涉及 type 关键字)，例如 type MyInt int。还有一些未命名类型，它们是类型文字(应用于/包括命名或未命名类型)的结果，例如[]int， struct{i int}, *int 等

您可以使用 Type.Name() 方法获取命名类型的名称，该方法“为未命名类型返回一个空字符串”:

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() 获取命名类型的包路径，“如果该类型是预先声明的(string，error ) 或未命名(*T、struct{}、[]int)，包路径将为空字符串" :

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() 判断类型是否为命名类型，以及 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() panic ):

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() 可用于“过滤掉”预先声明和未命名的类型。如果 PkgPath() 返回非空字符串，您可以确定它是“自定义”类型。如果它返回一个空字符串，它仍然可能是一个从“自定义”类型构造的未命名类型(在这种情况下 Type.Name() 返回 "")；为此，您可以使用 Type.Elem() 来查看它是否是从“自定义”类型构建的，这可能必须 递归 应用:

// [][]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:匿名结构类型

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

特例#2: map 类型

在 map 的情况下，如果任何键或值类型为“自定义”，我们可能会将未命名的 map 类型视为“自定义”。

映射的值类型可以通过上面提到的Type.Elem()方法查询，映射的键类型可以通过Type.Key()方法查询 方法 - 我们还必须在 map 的情况下检查它。

示例实现

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