使用reflect识别非内置类型

Question

我需要区分这样的类型

type A []byte

来自a []byte.用reflect,reflect.TypeOf(A{}).Kind告诉我,这是一个Slice的byte.如何[]byte{}在A{}没有要检查的有界类型列表的情况下区分？

有没有新方法在较新版本的Go中执行此操作？

Answer 1

一些背景

首先让我们清楚一些与类型相关的事情.引用规范:类型:

类型确定特定于该类型值的值集和操作集.类型可以是命名的或未命名的.命名类型由(可能合格的)类型名称指定 ; 使用类型文字指定未命名的类型,类型文字从现有类型组成新类型.

所以有(预先声明的)命名类型,如string,int等,你也可以使用类型声明(涉及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: ""

有些类型是预先声明的并且可供您使用(无论是原样还是类型文字):

预先声明了布尔,数字和字符串类型的命名实例.可以使用类型文字构造复合类型 - 数组,结构,指针,函数,接口,切片,映射和通道类型.

预先申请的类型是:

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()恐慌):

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:地图类型

在地图的情况下,如果其任何键或值类型是"自定义",我们可以考虑未命名的地图类型"自定义".

可以使用上述Type.Elem()方法查询映射的值类型,并且可以使用该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