Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Learn more about Collectives

Teams

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Learn more about Teams

how do I get the "real" Type of w?

is there any way to get the string representation of a type?

is there any way to use the string representation of a type to convert a value?

fmt.Printf("Integer: %v", v) case float64: // v is a float64 here, so e.g. v + 1.0 is possible. fmt.Printf("Float64: %v", v) case string: // v is a string here, so e.g. v + " Yeah!" is possible. fmt.Printf("String: %v", v) default: // And here I'm feeling dumb. ;) fmt.Printf("I don't know, ask stackoverflow.") thank you for that. but still not quite there. in the example, how to I coerce var w into an int? – cc young Jun 16, 2011 at 15:11 Mue's example does the same thing, but in a type switch instead of an if statement. In the 'case int', 'v' will be an integer. in 'case float64', 'v' will be a float64, etc. – jimt Jun 16, 2011 at 16:48 you're absolutely right! thanks! do you have any insight on types string representations of types? – cc young Jun 16, 2011 at 15:17 @DmitriGoldring That at least answers the question in the topics title. This answer not. Thank you very much. – C4d Mar 6, 2019 at 16:37 And if you just want to get a string or a type (e.g. for printing in the default block of a type switch link in Mue's answer you can just use fmt 's "%T" format instead of directly using reflect . – Dave C Mar 10, 2015 at 16:49

Here is an example of decoding a generic map using both switch and reflection, so if you don't match the type, use reflection to figure it out and then add the type in next time.

var data map[string]interface {}
for k, v := range data {
    fmt.Printf("pair:%s\t%s\n", k, v)   
    switch t := v.(type) {
    case int:
        fmt.Printf("Integer: %v\n", t)
    case float64:
        fmt.Printf("Float64: %v\n", t)
    case string:
        fmt.Printf("String: %v\n", t)
    case bool:
        fmt.Printf("Bool: %v\n", t)
    case []interface {}:
        for i,n := range t {
            fmt.Printf("Item: %v= %v\n", i, n)
    default:
        var r = reflect.TypeOf(t)
        fmt.Printf("Other:%v\n", r)             
There are multiple ways to get a string representation of a type. Switches can also be used with user types:
var user interface{}
user = User{name: "Eugene"}
// .(type) can only be used inside a switch
switch v := user.(type) {
case int:
    // Built-in types are possible (int, float64, string, etc.)
    fmt.Printf("Integer: %v", v)
case User:
    // User defined types work as well  
    fmt.Printf("It's a user: %s\n", user.(User).name)
// You can use reflection to get *reflect.rtype
userType := reflect.TypeOf(user)
fmt.Printf("%+v\n", userType)
// You can also use %T to get a string value
fmt.Printf("%T", user)
// You can even get it into a string
userTypeAsString := fmt.Sprintf("%T", user)
if userTypeAsString == "main.User" {
    fmt.Printf("\nIt's definitely a user")
Link to a playground: https://play.golang.org/p/VDeNDUd9uK6
switch obj.Elem().Interface().(type) {
case string:
    log.Println("obj contains a pointer to a string")
default:
    log.Println("obj contains something else")
I'm going to offer up a way to return a boolean based on passing an argument of a reflection Kinds to a local type receiver (because I couldn't find anything like this).
First, we declare our anonymous type of type reflect.Value:
type AnonymousType reflect.Value
Then we add a builder for our local type AnonymousType which can take in any potential type (as an interface):
func ToAnonymousType(obj interface{}) AnonymousType {
    return AnonymousType(reflect.ValueOf(obj))
Then we add a function for our AnonymousType struct which asserts against a reflect.Kind:
func (a AnonymousType) IsA(typeToAssert reflect.Kind) bool {
    return typeToAssert == reflect.Value(a).Kind()
This allows us to call the following:
var f float64 = 3.4
anon := ToAnonymousType(f)
if anon.IsA(reflect.String) {
    fmt.Println("Its A String!")
} else if anon.IsA(reflect.Float32) {
    fmt.Println("Its A Float32!")
} else if anon.IsA(reflect.Float64) {
    fmt.Println("Its A Float64!")
} else {
    fmt.Println("Failed")
Can see a longer, working version here:https://play.golang.org/p/EIAp0z62B7
-> reflect.ValueOf(x).Kind())
func typeofobject(x interface{}){
    fmt.Println(reflect.ValueOf(x).Kind())
source: geeks-for-geeks
        
Thanks for contributing an answer to Stack Overflow!
Please be sure to answer the question. Provide details and share your research!
But avoid …
Asking for help, clarification, or responding to other answers.
Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.