Golang Int to String, String to Int, and Type Conversion

Go never converts types implicitly. You convert between compatible types with T(v), and between numbers and text with the strconv package. The two most searched conversions:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// int to string
	n := 42
	s := strconv.Itoa(n)
	fmt.Println(s, len(s))

	// string to int
	parsed, err := strconv.Atoi("1234")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(parsed + 1)
}

strconv.Itoa ("integer to ASCII") formats an int as decimal text. strconv.Atoi ("ASCII to integer") parses text into an int and returns an error when the text is not a valid number. Always check that error.

The T(v) Conversion

Go's conversion syntax looks like a function call named after the target type. It works in three situations:

1. between numeric types (int, int64, float64, uint8, ...),
2. between string and []byte or []rune,
3. between types that share an underlying type (Celsius and float64).

package main

import (
	"fmt"
	"math"
)

type Celsius float64

func main() {
	count := 7
	total := 2.5

	// numeric conversions
	avg := total / float64(count)
	fmt.Printf("%.3f\n", avg)

	// float to int truncates toward zero
	up, down := 3.9, -3.9
	fmt.Println(int(up), int(down))
	fmt.Println(int(math.Round(up)), int(math.Round(-3.5)))

	// narrowing an integer keeps the low bits
	big, mid := 300, 200
	fmt.Println(uint8(big), int8(mid))

	// named type to underlying type and back
	t := Celsius(21.5)
	f := float64(t)
	fmt.Println(t, f)
}

Read the results closely:

• int(3.9) is 3 and int(-3.9) is -3. Conversion truncates toward zero; it does not round. Use math.Round, math.Floor or math.Ceil first to choose the behavior. math.Round rounds half away from zero, so -3.5 becomes -4.
• uint8(300) is 44, because only the low 8 bits survive (300 minus 256), and int8(200) is -56 for the same reason. No error, no panic.
• Celsius and float64 share an underlying type, so they convert freely, but only explicitly.

The values are in variables on purpose. With constants, the same conversions do not compile.

Constants Are Checked, Variables Are Not

Converting a constant that does not fit is a compile error. Converting a variable with the same value silently wraps:

fmt.Println(uint8(300)) // compile error
x := 300
fmt.Println(uint8(x)) // 44

./main.go:6:20: constant 300 overflows uint8

Converting a non-integer constant to an integer type is also rejected, while the same value in a variable is truncated:

./main.go:7:18: cannot convert -3.9 (untyped float constant) to type int

If the float value is outside the range of the target integer type (say int64(1e20)), the result is implementation-dependent: amd64 and arm64, for example, give different answers. Check the range before converting untrusted values.

Converting Numbers to Strings

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var id int64 = 9007199254740993
	fmt.Println(strconv.FormatInt(id, 10))
	fmt.Println(strconv.FormatInt(255, 2), strconv.FormatInt(255, 16))

	f := 1234.5678
	fmt.Println(strconv.FormatFloat(f, 'f', 2, 64))  // fixed, 2 decimals
	fmt.Println(strconv.FormatFloat(f, 'e', 3, 64))  // scientific
	fmt.Println(strconv.FormatFloat(f, 'f', -1, 64)) // shortest exact form
	fmt.Println(strconv.FormatFloat(0.1, 'f', -1, 64))

	fmt.Println(fmt.Sprintf("%.1f%%", 45.67))
	fmt.Println("item-" + strconv.Itoa(7))
}

FormatFloat takes a format byte ('f' for fixed, 'e' for exponent, 'g' for whichever is shorter), a precision (-1 means "the fewest digits that round-trip exactly"), and the bit size of the original float (64 or 32).

strconv is faster than fmt.Sprint, which boxes the value in an interface and goes through fmt's general formatting path. In a hot loop that difference shows up; for occasional conversions, pick whichever reads better.

Converting Strings to Numbers

ParseInt always returns an int64. The bitSize argument (0, 8, 16, 32, 64) sets the range it accepts, so the result is guaranteed to fit when you convert it down. base 0 means "infer from the prefix", so 0x1f, 0o17, 0b101 and 1_000 all parse.

package main

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

func main() {
	inputs := []string{"42", " 42", "4.2", "abc", "99999999999999999999"}
	for _, in := range inputs {
		n, err := strconv.Atoi(in)
		fmt.Printf("%-24q -> %d, %v\n", in, n, err)
	}

	// trim first when the input may have spaces or a newline
	n, err := strconv.Atoi(strings.TrimSpace(" 42\n"))
	fmt.Println(n, err)

	// ParseInt with a size limit
	v, err := strconv.ParseInt("300", 10, 8)
	fmt.Println(v, err)

	// base 0 reads the prefix
	h, _ := strconv.ParseInt("0xff", 0, 64)
	fmt.Println(h)

	// inspect the error kind
	_, err = strconv.Atoi("12a")
	if errors.Is(err, strconv.ErrSyntax) {
		fmt.Println("not a number")
	}
	_, err = strconv.ParseInt("300", 10, 8)
	if errors.Is(err, strconv.ErrRange) {
		fmt.Println("too big for int8")
	}

	price, err := strconv.ParseFloat("19.99", 64)
	fmt.Println(price*2, err)

	ok, err := strconv.ParseBool("true")
	fmt.Println(ok, err)
}

Things the output shows:

• " 42" fails. Atoi accepts an optional sign and digits, nothing else. Input from bufio usually ends in \n, so trim it.
• "4.2" is invalid for Atoi. Use ParseFloat for decimals.
• On an out-of-range error, ParseInt returns the largest value that fits (127 for int8) together with the error. Do not use the value when the error is not nil.
• The errors are *strconv.NumError values wrapping strconv.ErrSyntax or strconv.ErrRange, so errors.Is can tell them apart.

ParseBool accepts 1, t, T, TRUE, true, True and the matching false forms. "yes" and "on" are errors.

The string(65) Trap

Converting an integer to string does not produce digits. It produces the character with that Unicode code point:

n := 65
s := string(n) // "A", not "65"

The compiler accepts it, but go vet reports it:

./main.go:10:7: conversion from int to string yields a string of one rune, not a string of digits

If you really want the character, say so with a rune: string(rune(n)). If you want the number as text, use strconv.Itoa(n). Converting a rune or byte to string is fine and common:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n := 65
	fmt.Println(strconv.Itoa(n)) // "65"
	fmt.Println(string(rune(n))) // "A"

	letter := 'é'
	fmt.Println(string(letter))

	word := "go"
	fmt.Println(string(word[0])) // a byte converted to a one-character string
}

Strings, Bytes and Runes

string, []byte and []rune convert into each other with T(v). Each conversion copies the data, because strings are immutable and slices are not:

package main

import "fmt"

func main() {
	s := "héllo"

	b := []byte(s) // UTF-8 bytes
	r := []rune(s) // Unicode code points

	fmt.Println(len(b), b)
	fmt.Println(len(r), r)

	r[1] = 'e'
	fmt.Println(string(r))

	b[0] = 'H'
	fmt.Println(string(b), s) // s is unchanged
}

Convert to []rune when you need to index or modify by character; convert to []byte for I/O, hashing and byte-level edits. Runes and bytes covers UTF-8 in detail.

Conversion vs Type Assertion

A conversion changes a value from one concrete type to another. Getting the concrete value out of an interface (any, error, io.Reader) is a different operation, the type assertion:

var v any = 42

n := v.(int)       // type assertion: v holds an int, give it to me
f := float64(n)    // conversion: int to float64
// f := float64(v) // compile error: cannot convert v (variable of interface type any)
//                  // to type float64: need type assertion

Assert first, then convert. The comma-ok form n, ok := v.(int) avoids a panic when the type is wrong.

Quick Reference

n, err := strconv.Atoi("42")
if err != nil {
	// not a valid integer
}