Type Conversion

Introduction

Many languages will quietly convert an integer to a float, or a number to a string, whenever it seems convenient. Go refuses to do this. Every type conversion in Go must be written explicitly, which trades a little extra typing for a lot fewer subtle bugs.

This lesson explains why Go takes this approach, how to convert between numeric types, and how the `strconv` package handles conversions between strings and numbers.

Why Go Has No Implicit Conversion

In many languages, mixing an `int` and a `float` in an expression silently "just works," with the language deciding how to combine them behind the scenes. Go's designers considered this a hidden source of bugs and confusion, so Go requires you to convert types explicitly every time — even between two closely related numeric types like `int` and `int64`.

package main

import "fmt"

func main() {
	var a int = 10
	var b float64 = 3.5

	// This line would NOT compile:
	// result := a + b   // mismatched types int and float64

	result := float64(a) + b // explicit conversion required
	fmt.Println(result)
}

Converting Between Numeric Types

To convert between numeric types, call the target type as if it were a function, passing in the value you want to convert.

package main

import "fmt"

func main() {
	var i int = 42
	var f float64 = float64(i)
	var u uint = uint(f)
	var i8 int8 = int8(i)

	fmt.Println(i, f, u, i8)
}

Converting Numbers to Strings

You might expect `string(65)` to convert the number to the text "65" — but in Go, converting an integer directly to `string` instead interprets it as a Unicode code point (producing "A" for 65), which is rarely what you want for everyday number-to-text conversion. Instead, use the `strconv` package.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	score := 95
	text := strconv.Itoa(score) // "Integer to ASCII"

	fmt.Println("Score: " + text)
	fmt.Println(len(text))
}

Converting Strings to Numbers

To go the other direction — parsing a string into a number — use `strconv.Atoi` for integers, or `strconv.ParseFloat` for floating-point numbers.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	input := "128"
	number, err := strconv.Atoi(input)
	if err != nil {
		fmt.Println("Conversion failed:", err)
		return
	}
	fmt.Println(number + 2)
}

Handling Conversion Errors

Unlike a simple type conversion (which always succeeds), parsing user-provided or external text into a number can fail — the string might not actually be a valid number. That's why `strconv.Atoi` and similar functions return two values: the parsed result, and an `error` that is `nil` on success.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	input := "not-a-number"
	_, err := strconv.Atoi(input)
	if err != nil {
		fmt.Println("Error:", err)
	}
}

Converting Between string, []byte, and []rune

Converting a string to a byte slice or rune slice (and back) is also done through explicit conversion syntax, and is common when you need to modify text, since Go strings themselves are immutable.

package main

import "fmt"

func main() {
	original := "Go"
	bytes := []byte(original)
	runes := []rune(original)

	bytes[0] = 'N' // modify the byte slice
	fmt.Println(string(bytes))
	fmt.Println(len(runes))
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You now understand why Go requires explicit conversions, how to convert between numeric types, and how to safely convert strings and numbers using strconv. Next, you'll cover Go's arithmetic, comparison, logical, and bitwise operators.