Go Type Casting – Convert Between Data Types Safely in Go (2025 Guide)

Introduction – What Is Type Casting in Go?

In Go, type casting (also known as type conversion) is the explicit process of converting a value from one data type to another. Go does not support implicit type conversion, making type safety a cornerstone of its design.

In this section, you’ll learn:

• How to convert between integers, floats, strings, and booleans
• Syntax and rules for safe type casting
• Common pitfalls and how to avoid them
• Real-world examples with outputs

Basic Type Conversion Syntax in Go

Go uses a function-style syntax for casting:

var a int = 42
var b float64 = float64(a) // Convert int to float64

You specify the target type and wrap the value inside it.

Numeric Type Conversions

Integer to Float

var i int = 10
var f float64 = float64(i)
fmt.Println(f)  // Output: 10.0

Float to Integer (Truncates)

var f float64 = 9.81
var i int = int(f)
fmt.Println(i)  // Output: 9

The fractional part is discarded, not rounded.

Integer to Byte

var i int = 65
b := byte(i)
fmt.Println(b)         // Output: 65
fmt.Println(string(b)) // Output: A

String Conversions

Go does not allow direct string ↔ numeric conversions without helper functions.

This is invalid:

var s string = string(123)  // Not "123"

This will output the Unicode character for code point 123 ({).

Use strconv package for safe conversions:

import (
    "fmt"
    "strconv"
)

func main() {
    num := 100
    str := strconv.Itoa(num)       // int to string
    fmt.Println(str)               // Output: "100"

    s := "42"
    i, _ := strconv.Atoi(s)        // string to int
    fmt.Println(i)                 // Output: 42
}

Boolean Conversions

Go does not support automatic boolean-to-integer or vice versa conversions.

// Invalid: var i int = int(true) 

Instead, use control logic:

var b bool = true
var i int
if b {
    i = 1
} else {
    i = 0
}

Real-World Example – Type Casting Combo

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var score int = 87
    var percent float64 = float64(score) / 100
    str := strconv.Itoa(score)

    fmt.Printf("Score: %d\n", score)
    fmt.Printf("Percentage: %.2f\n", percent)
    fmt.Printf("Score (as string): %s\n", str)
}

Output:

Score: 87
Percentage: 0.87
Score (as string): 87

Pitfalls of Type Casting in Go

Summary – Recap & Next Steps

Type casting in Go is explicit, strict, and safe. This prevents many bugs common in loosely typed languages and ensures your data stays valid throughout your program.

Key Takeaways:

• Go requires explicit type conversion between types
• Use function-style casts for numeric types
• Use strconv package to convert strings ↔ numbers
• No boolean ↔ numeric casting allowed
• Watch out for truncation and data loss

Next: Learn about Go Operators, including arithmetic, relational, logical, and bitwise operators.

FAQs – Go Type Casting

Does Go support implicit type conversion?
No. Go requires explicit type conversion for safety and clarity.

How do I convert string to int or float in Go?
Use strconv.Atoi() for string to int, and strconv.ParseFloat() for string to float.

Can I convert boolean to integer in Go?
No direct conversion. Use if statements to assign 1 for true, 0 for false.

What happens when I convert a float to int?
The decimal part is discarded (truncated), not rounded.

Why does string(65) return "A" instead of "65"?
Because string(65) converts 65 to its Unicode character, not its string digits. Use strconv.Itoa() instead.