使用反射识别非内置类型

偷偷努力，悄无声息地变强，然后惊艳所有人！哈哈，小伙伴们又来学习啦~今天我将给大家介绍《使用反射识别非内置类型》，这篇文章主要会讲到golang等等知识点，不知道大家对其都有多少了解，下面我们就一起来看一吧！当然，非常希望大家能多多评论，给出合理的建议，我们一起学习，一起进步！

问题内容

我需要区分这样的类型

type A []byte

从一个[]byte。使用reflect,reflect.TypeOf(A{}).Kind告诉我它是一个Sliceof byte。如果没有要检查的类型的有界列表，我如何区分[]byte{}？A{}

在较新版本的 Go 中是否有新的方法来做到这一点？

正确答案

一些背景

首先让我们弄清楚一些与类型有关的事情。引用规范：类型：

类型确定特定于该类型值的一组值和操作。类型可以 命名 或未 命名 。命名类型由（可能是限定的）类型名称指定；未命名类型使用 类型文字 指定，该类型文字由现有类型组成新类型。

因此有（预先声明的） 命名类型 ，例如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()来获取类型的元素类型：KindArray``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：地图类型

在地图的情况下，如果它的任何键或值类型是“自定义”，我们可能会考虑一个未命名的地图类型“自定义”。

map 的 value 类型可以用上面提到Type.Elem()的方法查询，map 的 key 类型可以用上面的Type.Key()方法查询 - 如果是 maps，我们也必须检查这一点。

示例实现

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

终于介绍完啦！小伙伴们，这篇关于《使用反射识别非内置类型》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！