使用反射识别非内置类型

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: ""

因此，您可以使用 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, or Slice(else Type.Elem()panics):

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