How to convert an int to a string in Go

1strconv.ItoaRecommended

strconv.Itoa(n) ("integer to ASCII", C heritage again) takes an int and returns its base-10 decimal text. One argument, one return value, no error — an integer always has a decimal spelling, so there is nothing to go wrong. This is the call to reach for unless you specifically need another base or a formatted layout.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n := 42
	s := strconv.Itoa(n)

	fmt.Println(s + "!") // concatenation compiles: it really is a string
	fmt.Println(len(s))  // 2 characters, not the number 42

	// The sign comes along for free
	fmt.Println(strconv.Itoa(-17))

	// And back the other way
	back, _ := strconv.Atoi(s)
	fmt.Println(back + 1)
}

Prints 42!, then 2 (the string is two characters long), -17, and 43. The concatenation on the first line is the proof: n + "!" would not compile, because Go never converts between int and string implicitly. Itoa is a thin wrapper over FormatInt(int64(n), 10) with a fast path for small values.

2FormatInt: any base, and int64

strconv.FormatInt(n, base) is the general form. base is anything from 2 to 36 — digits then lowercase letters — and the argument is an int64, so it is also the answer to "how do I convert an int64 to a string". Its unsigned twin FormatUint takes a uint64 and reaches values an int64 cannot hold at all.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var n int64 = 255

	// base 10 is what Itoa does under the hood
	fmt.Println(strconv.FormatInt(n, 10))

	// any base from 2 to 36
	fmt.Println(strconv.FormatInt(n, 2))
	fmt.Println(strconv.FormatInt(n, 16))
	fmt.Println(strconv.FormatInt(n, 36))

	// negatives keep the sign, whatever the base
	fmt.Println(strconv.FormatInt(-255, 16))

	// FormatUint is the unsigned twin -- it reaches values int64 can't hold
	var u uint64 = 18446744073709551615
	fmt.Println(strconv.FormatUint(u, 10))

	// an int has to be widened first: FormatInt only takes int64
	i := 42
	fmt.Println(strconv.FormatInt(int64(i), 10))
}

Prints 255, 11111111, ff, 73, then -ff, 18446744073709551615 and 42. Note the hex comes out lowercase and unprefixed — no 0x. If you want the prefix or uppercase digits, that is a formatting decision, and fmt.Sprintf("%#X", n) is the shorter road to it.

3fmt.Sprintf when you need formatting

fmt.Sprintf("%d", n) also produces "42", and for a bare conversion it is the slower, wordier choice — it goes through reflection to work out the type. But the moment you want padding, a forced sign, a different base, or other text around the number, it stops being a conversion and starts being formatting, and that is exactly Sprintf's job.

package main

import "fmt"

type point struct {
	X, Y int
}

func main() {
	n := 42

	plain := fmt.Sprintf("%d", n)
	fmt.Println(plain)

	// Where Sprintf earns its keep: width, padding and signs
	padded := fmt.Sprintf("%05d", n)
	signed := fmt.Sprintf("%+d", n)
	fmt.Println(padded, signed)

	// Other bases, without strconv
	fmt.Printf("%b %o %x %X\n", 255, 255, 255, 255)

	// ...and building a whole sentence in one call
	line := fmt.Sprintf("order #%d: %d items, %d%% off", 1042, 3, 15)
	fmt.Println(line)

	// %v formats any value, including a struct
	fmt.Println(fmt.Sprint(n), fmt.Sprintf("%v", point{1, 2}))
}

Prints 42, then 00042 +42, then 11111111 377 ff FF, then order #1042: 3 items, 15% off, then 42 {1 2}. Two things worth stealing: %05d is how you get leading zeros (order numbers, invoice IDs), and a literal percent sign is %%. fmt.Sprint(n) with no verb works too and is handy in generic code, but for a plain int prefer Itoa.

4The string(i) trap

string(n) is legal Go and it is almost never what you want. Go's conversion syntax reinterprets a value; it does not parse or format one. Converting an integer to a string means "the character at this code point", so string(65) is "A" and small numbers land on invisible control characters. go vet catches it: conversion from int to string yields a string of one rune, not a string of digits.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	n := 65

	// THE TRAP: string(n) is a type conversion, not formatting. It reads n
	// as a Unicode code point, so 65 becomes "A", not "65". go vet says:
	//   conversion from int to string yields a string of one rune,
	//   not a string of digits
	fmt.Printf("%q\n", string(n))

	// What you actually meant:
	fmt.Printf("%q\n", strconv.Itoa(n))

	// When a code point IS what you mean, say rune() out loud -- same
	// result, and vet stays quiet
	fmt.Println(string(rune(9731)))

	// string() of a byte or rune slice is the conversion the syntax is for
	fmt.Println(string([]byte{71, 111}))
	fmt.Println(string([]rune{'G', 'o'}))

	// Small numbers are the worst case: they land on control characters
	fmt.Printf("%q vs %q\n", string(rune(7)), strconv.Itoa(7))
}

Prints "A" where you expected "65", then "65" from Itoa, then ☃, then Go twice, and finally "\a" vs "7" — code point 7 is the BEL control character, which would have vanished silently in normal output. string() of a []byte or []rune is genuinely useful and not a trap; only the single-integer form is. Run go vet ./... in CI and this class of bug never reaches you.

5Which should you use?

6Building a string from many ints

There is no strings.Join for []int, so joining numbers means converting first. Strings are immutable, so out += strconv.Itoa(n) in a loop copies the whole accumulated string every iteration — O(n²) work and O(n) garbage. strings.Builder keeps one growing buffer, and strconv.AppendInt goes one step further by writing the digits directly into a []byte you own, with no intermediate string at all.

package main

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

func main() {
	nums := []int{1, 1, 2, 3, 5, 8, 13}

	// strings.Builder: one growing buffer, one string at the end
	var b strings.Builder
	for i, n := range nums {
		if i > 0 {
			b.WriteString(", ")
		}
		b.WriteString(strconv.Itoa(n))
	}
	fmt.Println(b.String())

	// AppendInt writes the digits straight into a []byte -- no
	// intermediate string is created at all
	buf := make([]byte, 0, 32)
	for i, n := range nums {
		if i > 0 {
			buf = append(buf, '-')
		}
		buf = strconv.AppendInt(buf, int64(n), 10)
	}
	fmt.Println(string(buf))

	// Convert then Join: the version that reads best
	parts := make([]string, len(nums))
	for i, n := range nums {
		parts[i] = strconv.Itoa(n)
	}
	fmt.Println(strings.Join(parts, " "))

	// The version to avoid: a fresh string allocated every iteration
	out := ""
	for _, n := range nums {
		out += strconv.Itoa(n)
	}
	fmt.Println(out)
}

Prints 1, 1, 2, 3, 5, 8, 13, then 1-1-2-3-5-8-13, then 1 1 2 3 5 8 13, then 11235813 — same digits, four different costs. For a handful of values any of them is fine and the Itoa-then-Join version reads best; inside a hot loop or a serializer, AppendInt into a reused buffer is the one that stops showing up in your allocation profile.