Type Assertion for Int, Bool, and other Basic Types in Go Language

In Go, type assertions play a pivotal role in determining the underlying type of an interface and converting it to a concrete type. While interfaces are versatile, dealing with basic types requires a different approach.


Go, also known as Golang, is a statically typed, compiled language designed to be efficient and concurrent. One of its core features is the interface type, which allows for dynamic typing. However, basic types such as integers, floats, and booleans do not implement interfaces and thus cannot be directly asserted to a specific interface type. This article will cover how to perform type assertions on basic types in Go.

Basic Types and Interfaces

Basic types in Go are predeclared and include

  • booleans
  • integers
  • floating-point numbers
  • complex numbers
  • strings
  • bytes

Since basic types do not have methods, they cannot directly satisfy an interface's method set. To work with type assertions on basic types, we often use empty interfaces (interface{}) and then assert the type using either a single or double return form.

Single Return Type Assertion

The single return type assertion is straightforward but can lead to runtime panics if the assertion fails:

var i interface{} = 42
intVal := i.(int) // This will panic if i is not an int

Double Return Type Assertion

The double return type assertion is safer as it returns a boolean indicating the success of the assertion:

var i interface{} = 42
intVal, ok := i.(int)
if !ok {
    // Handle the error or type mismatch

Using Reflection for Type Assertions

Reflection in Go allows for runtime type inspection and is a powerful tool for type assertions:

var i interface{} = 42
if intValue, ok := i.(int); ok {
    fmt.Println("Value is an int:", intValue)
} else {
    fmt.Println("Value is not an int")

Reflection can also be used to get the type of an interface and perform actions based on its kind:

t := reflect.TypeOf(i)
v := reflect.ValueOf(i)
if t.Kind() == reflect.Int {
    fmt.Println("Value is an int:", v.Int())

Type Switches

Type switches provide a way to assert the type of an interface across multiple cases:

var i interface{} = 42
switch v := i.(type) {
case int:
    fmt.Println("Type is int:", v)
case float64:
    fmt.Println("Type is float64:", v)
    fmt.Println("Unknown type")

Type switches are a clean and expressive way to handle different types within an interface.


Type assertions are a fundamental part of working with interfaces in Go. While basic types cannot be directly asserted to an interface type, using a combination of double return type assertions, reflection, and type switches allows developers to safely and effectively determine and work with the underlying types. Understanding these mechanisms is crucial for writing robust and flexible Go code that leverages the language's type system to its full potential.