A type assertion in Golang is “used to provide access to an interface value’s underlying concrete value”.
A type assertion does not convert an interface to another data type. Instead, it provides access to the underlying concrete value of the interface. This is normally what you want, as it allows you to work with the interface’s value as if it were of the concrete type.
Syntax
t := variable.(T)
Parameters
- variable: It is a variable to be asserted.
- T: It is the type that is expected.
This statement asserts that the interface value variable holds the concrete type T and assigns the underlying T value to the variable t.
Return value
The type assertion returns a value of the specified type or nil if the variable is not of that type.
Example 1: How to use type assertion
Here is an example of how to use a type assertion:
package main
import "fmt"
func main() {
var x interface{} = "Krunal, Lathiya!"
// Assert that x is a string.
s, ok := x.(string)
if ok {
fmt.Println("The value of x is", s)
} else {
fmt.Println("The value of x is not a string")
}
}
Output
The value of x is Krunal, Lathiya!
Example 2: panic: interface conversion: interface {} is string, not float64
The error message panic: interface conversion: interface {} is string, not float64 occurs when you attempt a type assertion where you assumed an interface{} value was of type float64, but in reality, it was of type string.
package main
import "fmt"
func main() {
var x interface{} = "Krunal, Lathiya!"
f, ok := x.(float64)
fmt.Println(f, ok)
f = x.(float64)
fmt.Println(f)
}
Output
panic: interface conversion: interface {} is string, not float64
To handle this panic, you can use the “num, ok” idiom for type assertions, which allows you to safely check whether the interface value is of a certain type:
package main
import "fmt"
func main() {
var x interface{} = "Krunal, Lathiya!"
num, ok := x.(float64)
if ok {
fmt.Println("Conversion successful, x is a float64:", num)
} else {
fmt.Println("Conversion failed, x is not a float64")
}
}
Output
Conversion failed, x is not a float64
Type Switches in Golang
A type switch in Golang is “used to perform several type assertions in series and runs the first case with a matching type”. This is helpful when you need to check the variable type and execute different codes depending on the variable type.
Syntax
switch variable {
case type1:
// Code to be executed if the variable is of type1.
case type2:
// Code to be executed if the variable is of type2.
default:
// Code to be executed if the variable is of no known type.
}
Where:
- variable: It is a variable to be switched on.
- type1, type2, etc: They are the types that are expected.
Example
package main
import "fmt"
func main() {
var data interface{} = 21.19
switch data.(type) {
case string:
fmt.Println("The value of data is a string")
case int:
fmt.Println("The value of data is an integer")
case float64:
fmt.Println("The value of data is an float64")
default:
fmt.Println("The value of data is of an unknown type")
}
}
Output
The value of data is an float64
The type switch can correctly identify the variable type and print the appropriate message.
That’s it!

Krunal Lathiya is a seasoned Computer Science expert with over eight years in the tech industry. He boasts deep knowledge in Data Science and Machine Learning. Versed in Python, JavaScript, PHP, R, and Golang. Skilled in frameworks like Angular and React and platforms such as Node.js. His expertise spans both front-end and back-end development. His proficiency in the Python language stands as a testament to his versatility and commitment to the craft.