在Go中使用反射获取结构的名称

我发现这个问题的答案很好：

我仔细考虑了答案，并尝试以相同的方式获取结构的名称：

package main

import (
        "fmt"
        "reflect"
)

type Ab struct {

}

func getType(myvar interface{}) string {
        return reflect.TypeOf(myvar).Name()
}

func main() {
        fmt.Println("Hello, playground")

        tst := "string"
        tst2 := 10
        tst3 := 1.2
        tst4 := new(Ab)

        fmt.Println(getType(tst))
        fmt.Println(getType(tst2))
        fmt.Println(getType(tst3))
        fmt.Println(getType(tst4))

}

前往游乐场：

但结果是：

Hello, playground
string
int
float64


Program exited.

预期产出将是：

Hello, playground
string
int
float64
Ab

Program exited.

我试图通过阅读文档来找出问题所在，但没有找到问题所在。因此，很抱歉提出了一个非常笼统的问题，但是：

---

原因是什么，

reflect.TypeOf（）.Name（）

不适用于（此）结构？

在您的示例中，您传递的值是指针类型（

*Ab

），而不是结构类型

坚持使用

Type.Name（）

如果它不是指针，

Type.Name（）

将正确返回

Ab

。对于指针，如果仍然需要结构的名称，可以使用

Type.Elem（）

获取元素的类型：

func getType(myvar interface{}) string {
    if t := reflect.TypeOf(myvar); t.Kind() == reflect.Ptr {
        return "*" + t.Elem().Name()
    } else {
        return t.Name()
    }
}

测试它：

tst4 := Ab{}
tst5 := new(Ab)
fmt.Println(getType(tst4))
fmt.Println(getType(tst5))

输出（请在上尝试修改后的示例）：

注意：

请注意，as

Type.Name（）

不会解析指针，如果传递的值是指向指针的指针，则它将不起作用，例如，

**Ab

，而as

Type.String（）

会自动解析指针，在这种情况下也会起作用

我们可以很容易地使我们的

getType（）

函数也可以与

**Ab

一起工作（或与任何深度的指针一起工作）：

用值调用它：

tst4 := Ab{}
tst5 := new(Ab)
tst6 := &tst5 // type of **Ab
tst7 := &tst6 // type of ***Ab

输出（在上尝试）：

使用

Type.String（）

一种更简单更好的方法是使用

Type.String（）

而不是

Type.Name（）

，后者会自动处理指针并包括包名。例如：

func getType(myvar interface{}) string {
    return reflect.TypeOf(myvar).String()
}

对于修改后的示例，它输出：

string
int
float64
main.Ab
*main.Ab

---

在上尝试此变体。

问题是

新建

返回指针，下面应该会得到所需的结果

package main

import (
    "fmt"
    "reflect"
)

type Ab struct {
}

func getType(myvar interface{}) {
    valueOf := reflect.ValueOf(myvar)

    if valueOf.Type().Kind() == reflect.Ptr {
        fmt.Println(reflect.Indirect(valueOf).Type().Name())
    } else {
        fmt.Println(valueOf.Type().Name())
    }
}

func main() {
    fmt.Println("Hello, playground")

    tst := "string"
    tst2 := 10
    tst3 := 1.2
    tst4 := new(Ab)

    getType(tst)
    getType(tst2)
    getType(tst3)
    getType(tst4)

}

输出为

Hello, playground
string
int
float64
Ab

---

fmt还有一个很酷的

%T

标记

package main

import (
    "fmt"
    "net/http"
)

type Potato struct {
}

func main() {
    fmt.Printf("I have a %T, an %T and a %T\n", Potato{}, http.StatusMultipleChoices, &http.Response{})
}

输出

我有一个main.Potato、一个int和一个*http.Response

---

似乎如果你做Ab{}，而不是新的（Ab），你会得到预期的结果谢谢。这个答案很简单。第二个选项也适用于，例如，

**Ab

，第一个不适用。@danield将其添加到了答案中，并展示了它如何仍然可以用于支持

**Ab

（或任何深度的指针）。

package main

import (
    "fmt"
    "reflect"
)

type Ab struct {
}

func getType(myvar interface{}) {
    valueOf := reflect.ValueOf(myvar)

    if valueOf.Type().Kind() == reflect.Ptr {
        fmt.Println(reflect.Indirect(valueOf).Type().Name())
    } else {
        fmt.Println(valueOf.Type().Name())
    }
}

func main() {
    fmt.Println("Hello, playground")

    tst := "string"
    tst2 := 10
    tst3 := 1.2
    tst4 := new(Ab)

    getType(tst)
    getType(tst2)
    getType(tst3)
    getType(tst4)

}

Hello, playground
string
int
float64
Ab

package main

import (
    "fmt"
    "net/http"
)

type Potato struct {
}

func main() {
    fmt.Printf("I have a %T, an %T and a %T\n", Potato{}, http.StatusMultipleChoices, &http.Response{})
}