How to determine an interface{} value's "real" type?

Question

I have not found a good resource for using interface{} types. For example

package main

import "fmt"

func weirdFunc(i int) interface{} {
    if i == 0 {
        return "zero"
    }
    return i
}
func main() {
    var i = 5
    var w = weirdFunc(5)

    // this example works!
    if tmp, ok := w.(int); ok {
        i += tmp
    }

    fmt.Println("i =", i)
}

Do you know of a good introduction to using Go's interface{}?

specific questions:

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?

themue · Accepted Answer · 2014-04-14 10:43:55Z

175

You also can do type switches:

switch v := myInterface.(type) {
case int:
    // v is an int here, so e.g. v + 1 is possible.
    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.")
}

edited Apr 14, 2014 at 10:43

answered Jun 16, 2011 at 14:26

themue

7,9002 gold badges28 silver badges28 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

cc young Over a year ago

thank you for that. but still not quite there. in the example, how to I coerce var w into an int?

jimt Over a year ago

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.

cc young Over a year ago

right. had forgotten syntax var.(type), which is sneaky and cool

tuxErrante Over a year ago

When working with maps of maps, given myMap as map[string]map[string]string, myMap.(type) seems to never be matched as map[string]string but always as map[string]interface{} goplay.tools/snippet/SW9BARA_-Fy

peterSO · Accepted Answer · 2011-06-16 14:33:39Z

123

Your example does work. Here's a simplified version.

package main

import "fmt"

func weird(i int) interface{} {
    if i < 0 {
        return "negative"
    }
    return i
}

func main() {
    var i = 42
    if w, ok := weird(7).(int); ok {
        i += w
    }
    if w, ok := weird(-100).(int); ok {
        i += w
    }
    fmt.Println("i =", i)
}

Output:
i = 49

It uses Type assertions.

edited Jun 16, 2011 at 14:33

answered Jun 16, 2011 at 14:19

peterSO

168k32 gold badges303 silver badges293 bronze badges

3 Comments

cc young Over a year ago

you're absolutely right! thanks! do you have any insight on types string representations of types?

Dmitri Goldring Over a year ago

Check out reflect.TypeOf.

C4d Over a year ago

@DmitriGoldring That at least answers the question in the topics title. This answer not. Thank you very much.

newacct · Accepted Answer · 2011-06-17 06:05:17Z

66

You can use reflection (reflect.TypeOf()) to get the type of something, and the value it gives (Type) has a string representation (String method) that you can print.

answered Jun 17, 2011 at 6:05

newacct

123k29 gold badges168 silver badges227 bronze badges

1 Comment

Dave C Over a year ago

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.

h4ck3rm1k3 · Accepted Answer · 2015-03-26 11:15:35Z

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

Eugene Kulabuhov · Accepted Answer · 2019-09-30 17:24:26Z

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

Nikolai Koudelia · Accepted Answer · 2014-07-14 19:34:15Z

8

Type switches can also be used with reflection stuff:

var str = "hello!"
var obj = reflect.ValueOf(&str)

switch obj.Elem().Interface().(type) {
case string:
    log.Println("obj contains a pointer to a string")
default:
    log.Println("obj contains something else")
}

answered Jul 14, 2014 at 19:34

Nikolai Koudelia

2,6392 gold badges27 silver badges31 bronze badges

Comments

daino3 · Accepted Answer · 2016-04-24 00:42:28Z

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

Ayush · Accepted Answer · 2022-07-07 05:44:46Z

You can use

Printf("%T", interface{})
reflect.TypeOf
reflect.ValueOf(x).Kind()

-> reflect:

 func typeofobject(x interface{}){
        fmt.Println(reflect.TypeOf(x))
 }

-> Printf()

 // Golang program to find the variable type
    package main
    
    // importing required packages
    import (
      "fmt"
    )
    
    // main function
    func main() {
      f := true
      st := ""
      a := 1
      d := 1.0
      arr := []string{"Go", "Is", "Fun"}
    
      fmt.Printf("%T\n", f)
      fmt.Printf("%T\n", st)
      fmt.Printf("%T\n", a)
      fmt.Printf("%T\n", d)
      fmt.Printf("%T\n", arr)
    }

OUTPUT:

bool
string
int
float64
[]string

-> reflect.ValueOf(x).Kind())

func typeofobject(x interface{}){
    fmt.Println(reflect.ValueOf(x).Kind())
}

source: geeks-for-geeks

Collectives™ on Stack Overflow

How to determine an interface{} value's "real" type?

8 Answers 8

4 Comments

3 Comments

1 Comment

Comments

Comments

Comments

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

8 Answers 8

4 Comments

3 Comments

1 Comment

Comments

Comments

Comments

Comments

Comments

Linked

Related