确定使用反映非内建类型确定使用反映非内建类型(Identify non builtin-types

我需要区分这些类型的

type A []byte

从[]byte 。使用reflect ， reflect.TypeOf(A{}).Kind告诉我，这是一个Slice的byte 。我怎样才能区分[]byte{}从A{}而无需类型检查有界列表？

是否有新的方式来做到这一点围棋的新版本？

一些背景知识

首先让我们明确相关类型的一些事情。从报价规格：类型：

A型确定设定特定于该类型的值的值和操作。类型可有名或无名的 。命名的类型是由一个（可能指定合格）类型名称 ; 无名类型是使用一种类型的文字 ，这构成一种新型的从现有类型指定。

所以有（预声明的） 命名的类型 ，如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())

尝试在所有的例子去游乐场。

特殊情况＃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
}

测试它（尝试在转到操场）：

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