Different Ways to Find the Type of an Object in Golang

Go does not have the concept of a class type, therefore, you do not have objects in Go. You can refer any data type in Go as an object. There are several data types provided by Go such as int8, int16, int32, int64, float64, string, bool etc. There are three different ways by which you can find the type of a variable in Go at runtime.

1. Using fmt for a string type description

%T in fmt package is a Go-syntax representation of the type of the value. You can use %T to find the variable type.

Syntax:

func typeofobject(x interface{}) {
    fmt.Sprintf("%T", x)
}

Example 1:

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

Example 2:

// Golang program to show how to find
// the type of an object
package main

// importing required packages
import (
    "fmt"
)

func main() {
    types := []interface{}{"Code", 10, true, 10.55}
    for _, x := range types {
        fmt.Printf("%T\n", x)
    }
}

Output:

string
int
bool
float64

Note: An empty interface is denoted by interface{} can be used to hold values of any type.

2. Using reflect Package

You can also use the reflect package which implements run-time reflection, thus allowing a program to manipulate objects with arbitrary types. reflect.TypeOf and reflect.ValueOf(x).Kind() functions help us to find the required variable type.

Syntax:

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

Or

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

Example 1:

// Golang program to demonstrate
// the use of reflect.TypeOf function
package main

//importing reflect package
import (
    "fmt"
    "reflect"
)

func main() {
    f := true
    st := ""
    a := 1
    d := 1.0
    arr := []string{"Go", "Is", "Fun"}

    fmt.Println(reflect.TypeOf(f))
    fmt.Println(reflect.TypeOf(st))
    fmt.Println(reflect.TypeOf(a))
    fmt.Println(reflect.TypeOf(d))
    fmt.Println(reflect.TypeOf(arr))
}

Output:

bool
string
int
float64
[]string

We can do it similarly using ValueOf().Kind() function.

Example 2:

// Golang program to demonstrate
// the use of reflect.ValueOf(x).Kind() function
package main

import (
    "fmt"
    "reflect"
)

func main() {
    f := true
    st := ""
    a := 1
    d := 1.0
    arr := []string{"Coding", "In", "Go"}

    fmt.Println(reflect.ValueOf(f).Kind())
    fmt.Println(reflect.ValueOf(st).Kind())
    fmt.Println(reflect.ValueOf(a).Kind())
    fmt.Println(reflect.ValueOf(d).Kind())
    fmt.Println(reflect.ValueOf(arr).Kind())
}

Output:

bool
string
int
float64
slice

Example 3:

package main

// importing required packages
import (
    "fmt"
    "reflect"
)

func main() {
    types := []interface{}{"Code", true, 5, 3.14, []int{1, 2, 3, 4}}
    for _, x := range types {
        fmt.Println(reflect.ValueOf(x).Kind())
    }
}

Output:

string
bool
int
float64
slice

3. Using type assertions

You can use a type switch to do several type assertions. A type switch uses several type assertions in series and runs the first matching type. In this switch, the case contains the type which is going to compare with the type present in the switch expression, and if none of the cases matches, then the default case is evaluated.

Syntax:

switch optstatement; typeswitchexpression{
case typelist 1: Statement..
case typelist 2: Statement..
...
default: Statement..
}

Example:

// Golang program to check the object type
// using type switch
package main

//importing required packages
import (
    "fmt"
)

func main() {
    types := []interface{}{"Code", true, 5, 3.14, []int{1, 2, 3}}

    for _, x := range types {
        // type switch with multiple cases
        switch x.(type) {
        case int:
            fmt.Println("int:", x)
        case float64:
            fmt.Println("float64:", x)
        case string:
            fmt.Println("string:", x)
        case bool:
            fmt.Println("bool:", x)
        default:
            fmt.Printf("data type: %T", x)
        }
    }
}

Output:

string: Code
bool: true
int: 5
float64: 3.14
data type: []int