How to convert an int to a string type in Go

Using strconv.Itoa Function

The code snippet below shows how to convert an int to a string using the Itoa function.

package main

import (
  "fmt"
  "strconv"
)

func main() {

  s := strconv.Itoa(100)
  fmt.Printf("%q\n", s)
}

"100"

// conversion from untyped int to string yields a string of one rune, not a string of digits (did you mean fmt.Sprint(x)?)

s := string(100) // "d"

"d"

Using strconv.FormatInt Function

FormatInt returns the string representation of i in the given base, for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z' for digit values >= 10.

Converting int64 to string. For example,

package main

import (
  "fmt"
  "strconv"
)

func main() {

  var n int64 = 108
  // Decimal
  s := strconv.FormatInt(n, 10)
  fmt.Printf("%q\n", s)

  // Binary
  s = strconv.FormatInt(n, 2)
  fmt.Printf("%q\n", s)

  // Hexadecimal
  s = strconv.FormatInt(n, 16) // "6c"
  fmt.Printf("%q\n", s)
}

"108"
"1101100"
"6c"

Using fmt.Sprintf Function

The fmt.Sprintf function is a useful general tool for converting data to string:

package main

import (
  "fmt"
)

func main() {

  var n int64 = 14

  s := fmt.Sprintf("%03d", n)
  fmt.Printf("%q\n", s)
}

"014"

The verbs

Go offers several printing “verbs” designed to format general Go values.

The verbs:
%v
the value in a default format when printing structs, the plus flag (%+v) adds field names
%#v
a Go-syntax representation of the value
%T
a Go-syntax representation of the type of the value
%%
a literal percent sign; consumes no value
%t
the word true or false
%b
base 2
%c
the character represented by the corresponding Unicode code point
%d
base 10
%o
base 8
%O
base 8 with 0o prefix
%q
a single-quoted character literal safely escaped with Go syntax.
%x
base 16, with lower-case letters for a-f
%X
base 16, with upper-case letters for A-F
%U
Unicode format: U+1234; same as "U+%04X"
%b
decimalless scientific notation with exponent a power of two, in the manner of strconv.FormatFloat with the 'b' format, e.g. -123456p-78
%e
scientific notation, e.g. -1.234456e+78
%E
scientific notation, e.g. -1.234456E+78
%f
decimal point but no exponent, e.g. 123.456
%F
synonym for %f
%g %e 
for large exponents, %f otherwise. Precision is discussed below.
%G %E 
for large exponents, %F otherwise
%x
hexadecimal notation (with decimal power of two exponent), e.g. -0x1.23abcp+20
%X
upper-case hexadecimal notation, e.g. -0X1.23ABCP+20
%s
the uninterpreted bytes of the string or slice
%q
a double-quoted string safely escaped with Go syntax
%x
base 16, lower-case, two characters per byte
%X
base 16, upper-case, two characters per byte
%f
default width, default precision
%9f
width 9, default precision
%.2f
default width, precision 2
%9.2f
width 9, precision 2
%9.f
width 9, precision 0
+
always print a sign for numeric values; guarantee ASCII-only output for %q (%+q)
-
pad with spaces on the right rather than the left (left-justify the field)
#
alternate format: add leading 0b for binary (%#b), 0 for octal (%#o), 0x or 0X for hex (%#x or %#X); suppress 0x for %p (%#p); for %q, print a raw (backquoted) string if strconv.CanBackquote returns true; always print a decimal point for %e, %E, %f, %F, %g and %G; do not remove trailing zeros for %g and %G; write e.g. U+0078 'x' if the character is printable for %U (%#U).
' '
(space) leave a space for elided sign in numbers (% d); put spaces between bytes printing strings or slices in hex (% x, % X)
0
pad with leading zeros rather than spaces; for numbers, this moves the padding after the sign