How to Find the Type of an Object in Go

By the end of this page, you will understand how Go represents types at runtime, how to inspect a value's type using reflect.TypeOf, when fmt.Printf("%T", value) is simpler, and how to work with interface values such as e.Value from a container. You will also learn the difference between arrays and slices, plus common mistakes beginners make when checking types in Go.

In Go, the type of a variable is usually known at compile time. Most of the time, you do not need to ask for a value's type because Go's static type system already enforces it.

However, sometimes you work with values stored in an interface{} value, such as:

• container elements
• decoded JSON data
• generic helper functions
• logging and debugging tools

In those situations, the concrete type is hidden behind the interface, and you may want to inspect it at runtime.

Go provides two common ways to do this:

• fmt.Printf("%T", value) to print the type
• reflect.TypeOf(value) to get a reflect.Type

For example:

fmt.Printf("%T\n", value)

or:

t := reflect.TypeOf(value)
fmt.Println(t)

This matters because many Go APIs store values as any or interface{}. When you pull a value back out, you often need to:

• inspect its type
• convert it with a type assertion
• branch with a type switch

A very important detail here is that Go distinguishes between arrays and slices:

Think of an interface{} value in Go like a sealed box with two labels inside:

• the real value
• the real type

When you store something in interface{}, you can no longer see the exact type directly from the variable name alone. You need a tool to peek at the label.

• fmt.Printf("%T", value) is like asking, "What type label is on this box?"
• reflect.TypeOf(value) is like opening a small inspection window to read the type label programmatically
• a type assertion like value.([]string) is like saying, "I believe this box contains a []string; give it to me as that type"

So when you iterate over e.Value, you are handling boxes. The actual type is still there, but you must inspect or assert it.

Print a value's type

The easiest way to print a type in Go is:

fmt.Printf("%T\n", value)

Example:

package main

import "fmt"

func main() {
    x := []string{"a", "b", "c"}
    fmt.Printf("%T\n", x)
}

Output:

[]string

Use reflect.TypeOf

If you want the type as a value, use reflect.TypeOf:

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := []string{"a", "b", "c"}
    t := reflect.TypeOf(x)
    fmt.Println(t)
}

Consider this example:

package main

import "fmt"

func main() {
    var value any = []string{"go", "is", "fun"}

    fmt.Printf("%T\n", value)
}

Step by step:

1. []string{"go", "is", "fun"} creates a slice of strings.
2. var value any = ... stores that slice inside an interface value.
3. The interface still remembers the concrete type: []string.
4. fmt.Printf("%T\n", value) asks Go to print the concrete type stored in the interface.
5. The result is:

[]string

Now with reflection:

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var value any = []{, , }

    t := reflect.TypeOf(value)
    fmt.Println(t)
}

Runtime type inspection is useful in several practical situations:

Working with containers

Packages like container/list store element values as any or interface{}. When reading them back, you may need to inspect or assert the real type.

value := e.Value
fmt.Printf("%T\n", value)

Debugging unknown data

When debugging, printing %T helps you confirm what kind of value you are actually receiving.

fmt.Printf("received type: %T\n", payload)

Handling decoded JSON

When JSON is decoded into map[string]any, fields may contain different runtime types.

var data map[string]any
// after decoding JSON
fmt.Printf("type of age: %T\n", data["age"])

Generic utilities and libraries

Reusable helpers sometimes accept any and branch based on type.

In real Go codebases, developers usually do more than just print a type.

1. Prefer type assertions when you expect a specific type

If a value should be []string, assert that directly:

lines, ok := e.Value.([]string)
if !ok {
    return fmt.Errorf("expected []string, got %T", e.Value)
}

This is common in validation and parsing code.

2. Use %T for logging and debugging

For quick diagnostics, %T is often simpler than reflect.TypeOf:

log.Printf("unexpected type: %T", value)

3. Use type switches for multiple possible types

When several input types are valid, a type switch is clearer:

switch v := value.(type) {
case string:
    fmt.Println("single string", v)
case []string:
    fmt.Println("many strings", v)
default:
    fmt.Printf("unsupported type: %T\n", v)
}

Mistake 1: Passing reflect.TypeOf(...) directly to fmt.Printf

Broken code:

fmt.Printf(reflect.TypeOf(lines))

Why it fails:

• fmt.Printf expects the first argument to be a format string
• reflect.TypeOf(lines) returns a reflect.Type, not a format string

Correct code:

fmt.Println(reflect.TypeOf(lines))

or:

fmt.Printf("%T\n", lines)

Mistake 2: Confusing arrays and slices

Broken assumption:

// expecting array, but actual value is a slice
lines, ok := e.Value.([3]string)

If the stored value is []string, this will fail.

Correct idea:

lines, ok := e.Value.([]string)

// Print the type of a value
fmt.Printf("%T\n", value)

// Get the type as a reflect.Type
import "reflect"
t := reflect.TypeOf(value)
fmt.Println(t)

// Safe type assertion
lines, ok := value.([]string)
if !ok {
    fmt.Printf("unexpected type: %T\n", value)
}

// Type switch
switch v := value.(type) {
case string:
    fmt.Println("string", v)
case []string:
    fmt.Println("slice of strings", v)
default:
    fmt.Printf("unknown type: %T\n", v)
}

Key rules:

• Use %T when you just want to print a type.
• Use reflect.TypeOf when you need the type programmatically.
• Use type assertions when you expect a specific concrete type.
• Use a type switch when multiple types are valid.
• fmt.Printf needs a format string first.
• Arrays and slices are different types.
• []string is a slice, [3]string is an array.
• Values from container/list are stored as any/ and often need assertion.

How do I print the type of a variable in Go?

Use:

fmt.Printf("%T\n", value)

This prints the concrete runtime type.

What is the Go equivalent of Python type inspection?

The closest common options are:

• fmt.Printf("%T", value) for printing
• reflect.TypeOf(value) for getting a type value

Why does fmt.Printf(reflect.TypeOf(x)) not work?

Because fmt.Printf expects a format string as the first argument. Use:

fmt.Println(reflect.TypeOf(x))

or:

fmt.Printf("%T\n", x)

How do I know if a value is a []string in Go?

Use a type assertion:

lines, ok := value.([]string)

If ok is true, the value is a []string.

• Interfaces in Go — type inspection usually happens when values are stored in an interface.
• Type assertions — the standard way to extract a concrete type from an interface value.
• Type switches — useful when a value may be one of several types.
• Reflection in Go — provides runtime type information beyond simple printing.
• Slices in Go — important because []string is a slice, not an array.
• Arrays in Go — helps clarify the difference between fixed-size arrays and slices.
• Formatting with fmt.Printf — needed to understand %T and correct printing.
• container/list package — relevant because list element values are stored as interface values.