Type Casting in Golang (Type Cast)

Type conversion, commonly known as type casting, plays a very important role in determining how we can convert the various types of data type into others.

In Go, type casting allows us to ensure the data compatibility or to perform specific operations that require different data types to work together.

In this tutorial, will walk you through the basics of type casting in Go and cover the examples of various type conversion operations in the language.

What Is Type Casting?

Type casting, also known as type conversion, refers to the process of converting a value from one data type to another.

In Go, we can perform the type casting using either the type assertions or type conversion operators.

Since Go is a statically typed language, the compiler requires us to define the explicit data type of a given value.

Luckily, with the use of casting, we can change the type of a variable, when necessary, without violating Go’s strong type system.

Golang Type Casting

Type Conversion Operators

One of the common ways of converting the data types in Go is using the type conversion operators.

These operators allow us to explicitly change the type of a value as demonstrated in the following syntax example:


Here, the “targetType” is the target data type and “variable” is the value that we wish to convert.

We have access to several built-in type conversion functions in Go as follows:

Integer to Float

To convert a given integer value into a float, we can use the “float64” function as demonstrated in the following example:

var intVar int = 314
floatVar := float64(intVar)

This should convert the input integer into a floating point value.

Float to Integer

We can also convert a given floating point value into an integer using the int() function as shown in the following example:

var floatVar float64 = 3.141
intVar := int(floatVar)

The “int” function automatically truncates the floating part of the value, leaving only the integer.

String to Byte Slice

We can also use the type casting to convert a string into a byte slice and vice versa. This is especially useful when dealing with encoding and decoding operations.

An example is as follows:

package main
import "fmt"
func main() {
    str := "https://linuxhint.com"
    byteSlice := []byte(str)
    str2 := string(byteSlice)
    fmt.Println("byte slice:", byteSlice)
    fmt.Println("string:", str2)

This allows us to convert a string into a byte slice and a byte slice into a string.

Numeric to String

We can also convert a given numeric value into a string using the “Sprintf” function from the “fmt” package as follows:

package main
import "fmt"
func main() {
    num := 314
    str := fmt.Sprintf("%d", num)
    fmt.Printf("num: %d, string: %s\n", num, str)

String to Numeric

The reverse is also true. To convert a string into a numeric representation, we can use the Atoi() function from the “strconv” package.

An example is as follows:

package main
import (
func main() {
    str := "314"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("error:", err)
    fmt.Printf("string: %s, num: %d\n", str, num)

The function returns both the numeric value and an error in case of conversion failure.

Type Assertion Operators

Type assertion is a feature that allows us to extract the underlying value from an interface type when we know for sure that it is a concrete type.

Type assertions are very useful when working with interfaces.

The basic syntax is as follows:

value, ok := interfaceValue.(TargetType)

Here, the parameters are described as follows:

  • value – The extracted value.
  • ok – A Boolean that indicates whether the assertion is successful.
  • interfaceValue -The value of an interface type.
  • TargetType – The desired type.

Consider an example as shown in the following:

package main

import "fmt"

func main() {
    var val interface{} = 314
    num, ok := val.(int)
    if ok {
        fmt.Printf("value: %d, type: %T\n", num, num)
    } else {
        fmt.Println("assertion failed")

In this example, we create a “val” interface that contains an integer. We then use a type assertion to extract the integer value along with a Boolean that indicates whether the assertion is successful.


In this tutorial, we learned everything there is to know about type conversion when it comes to the Go programming language.

About the author

John Otieno

My name is John and am a fellow geek like you. I am passionate about all things computers from Hardware, Operating systems to Programming. My dream is to share my knowledge with the world and help out fellow geeks. Follow my content by subscribing to LinuxHint mailing list