Golang strconv.Itoa
last modified April 20, 2025
This tutorial explains how to use the strconv.Itoa function in Go.
We'll cover integer-to-string conversion basics with practical examples.
The strconv.Itoa function converts an integer to its string representation. It's a simple and efficient way to format numbers as strings.
Itoa stands for "integer to ASCII". The function takes an integer and returns
its base 10 string representation. It's the inverse of strconv.Atoi.
Basic strconv.Itoa Example
The simplest use of strconv.Itoa converts an integer to a string.
Here we demonstrate basic conversion with different integer values.
package main
import (
"fmt"
"strconv"
)
func main() {
num := 42
str := strconv.Itoa(num)
fmt.Printf("Integer %d converted to string '%s'\n", num, str)
// Negative number
negNum := -123
negStr := strconv.Itoa(negNum)
fmt.Printf("Integer %d converted to string '%s'\n", negNum, negStr)
}
We convert both positive and negative integers to their string representations. The function handles all valid integer values without error checking needed.
Formatting Different Integer Types
While Itoa works with int, other integer types need
conversion first. This example shows handling of various integer types.
package main
import (
"fmt"
"strconv"
)
func main() {
// int8
var num8 int8 = 127
str8 := strconv.Itoa(int(num8))
fmt.Println("int8:", str8)
// int64
var num64 int64 = 9223372036854775807
str64 := strconv.Itoa(int(num64))
fmt.Println("int64:", str64)
// uint
var numUint uint = 42
strUint := strconv.Itoa(int(numUint))
fmt.Println("uint:", strUint)
}
We convert different integer types by first casting them to int.
This ensures compatibility with Itoa which only accepts int.
Concatenating Numbers with Strings
A common use case is building strings that include numbers. This example shows how to concatenate integers with other strings.
package main
import (
"fmt"
"strconv"
)
func main() {
age := 30
name := "Alice"
// Using fmt.Sprintf
msg1 := fmt.Sprintf("%s is %d years old", name, age)
fmt.Println(msg1)
// Using strconv.Itoa and string concatenation
msg2 := name + " is " + strconv.Itoa(age) + " years old"
fmt.Println(msg2)
// Building a filename
fileNum := 5
filename := "data_" + strconv.Itoa(fileNum) + ".txt"
fmt.Println("Filename:", filename)
}
Itoa enables direct string concatenation with numbers. This is
useful for building dynamic strings like filenames or messages.
Performance Comparison with fmt.Sprintf
For converting integers to strings, Itoa is faster than
fmt.Sprintf. This example benchmarks both approaches.
package main
import (
"fmt"
"strconv"
"time"
)
func main() {
const iterations = 1000000
num := 12345
// Benchmark Itoa
start := time.Now()
for i := 0; i < iterations; i++ {
strconv.Itoa(num)
}
fmt.Println("Itoa duration:", time.Since(start))
// Benchmark Sprintf
start = time.Now()
for i := 0; i < iterations; i++ {
fmt.Sprintf("%d", num)
}
fmt.Println("Sprintf duration:", time.Since(start))
}
Itoa is significantly faster than fmt.Sprintf for
simple integer-to-string conversion. Use Itoa when performance matters.
Alternative: strconv.FormatInt
For more control over formatting, strconv.FormatInt can be used.
This example compares Itoa with FormatInt.
package main
import (
"fmt"
"strconv"
)
func main() {
num := 42
// Using Itoa
str1 := strconv.Itoa(num)
fmt.Println("Itoa:", str1)
// Using FormatInt
str2 := strconv.FormatInt(int64(num), 10)
fmt.Println("FormatInt:", str2)
// FormatInt with different bases
hexStr := strconv.FormatInt(int64(num), 16)
fmt.Println("Hexadecimal:", hexStr)
binStr := strconv.FormatInt(int64(num), 2)
fmt.Println("Binary:", binStr)
}
Itoa is simpler for base 10 conversion, while FormatInt
offers more flexibility with different bases. Choose based on your needs.
Practical Example: Building a CSV Line
This example demonstrates using Itoa to format data for CSV output.
We convert multiple numeric fields to strings.
package main
import (
"fmt"
"strconv"
)
type Product struct {
ID int
Price int
Stock int
}
func main() {
p := Product{ID: 1001, Price: 2499, Stock: 42}
csvLine := strconv.Itoa(p.ID) + "," +
strconv.Itoa(p.Price) + "," +
strconv.Itoa(p.Stock)
fmt.Println("CSV line:", csvLine)
// Alternative with fmt.Sprintf
csvLine2 := fmt.Sprintf("%d,%d,%d", p.ID, p.Price, p.Stock)
fmt.Println("CSV line (fmt):", csvLine2)
}
We build a CSV line by converting each numeric field to a string.
Itoa provides a lightweight way to format numbers without the
overhead of fmt.
Error Handling Edge Cases
While Itoa doesn't return errors, there are some edge cases to
consider. This example explores potential issues with large numbers.
package main
import (
"fmt"
"math"
"strconv"
)
func main() {
// Maximum int value
maxInt := math.MaxInt
strMax := strconv.Itoa(maxInt)
fmt.Println("Max int:", strMax)
// Minimum int value
minInt := math.MinInt
strMin := strconv.Itoa(minInt)
fmt.Println("Min int:", strMin)
// Very large int64 converted to int
var bigNum int64 = math.MaxInt64
strBig := strconv.Itoa(int(bigNum)) // Potential overflow
fmt.Println("Big number:", strBig)
}
Itoa handles all valid int values correctly. However,
converting larger types to int first may cause overflow issues.
Source
Go strconv package documentation
This tutorial covered the strconv.Itoa function in Go with
practical examples of integer-to-string conversion in various scenarios.
Author
List all Go tutorials.