using reflection in Go to get the name of a struct

I found this question with this great answers:

https://stackoverflow.com/questions/20170275/how-to-find-a-type-of-a-object-in-golang

I played around with the answer and tried to get the name of a struct in the same way:

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))

}

Go playground: http://play.golang.org/p/tD8mygvETH

But the output is:

Hello, playground
string
int
float64


Program exited.

Expected output would be:

Hello, playground
string
int
float64
Ab

Program exited.

I tried to figure out by reading the documentation but didn't find the issue about that. So, sorry for the very general question, but:

What's the reason, reflect.TypeOf().Name() does not work with (this) struct(s)?

In your example you pass a value of pointer type (*Ab), not a struct type.

Sticking to Type.Name()

If it is not a pointer, Type.Name() will properly return Ab. In case of pointer if you still want the struct's name, you can use Type.Elem() to get the element's type:

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

Testing it:

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

Output (try your modified example on the Go Playground):

Ab
*Ab

Note:

Note that as Type.Name() does not resolve pointers, it would not work if the value passed is a pointer to pointer, e.g. **Ab, while as Type.String() automatically resolves pointers, would work in this case too.

We can easily make our getType() function to work with **Ab too (or with any depth of pointers):

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

Calling it with values:

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

Output (try it on the Go Playground):

Ab
*Ab
**Ab
***Ab

Using Type.String()

A simpler and better approach would be to use Type.String() instead of Type.Name() which automatically handles pointers and also includes package name. E.g.:

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

For the modified example it outputs:

string
int
float64
main.Ab
*main.Ab

Try this variant on the Go Playground.

fmt has a cool %T tag as well

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{})
}

outputs I have a main.Potato, an int and a *http.Response
https://play.golang.org/p/6z7_0BSitm

The problem is new returns pointer, following should get the desired result.

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)

}

Output is

Hello, playground
string
int
float64
Ab