使用反射识别非内置类型

Question

我需要区分以下类型

type A []byte

从[]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: ""

因此，您有两种可用的工具：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：匿名结构类型

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

特例2：地图类型

对于地图，如果其键或值类型中的任何一个为“ custom”，则可以考虑使用未命名的地图类型“ custom”。

可以使用上述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