How to Convert Between `int64` and `string` in Golang

Key Takeaways

1. Use strconv.FormatInt or fmt.Sprintf to convert int64 to string.
2. Use strconv.ParseInt to convert string to int64, handling errors properly.
3. strconv functions are more efficient, while fmt.Sprintf offers formatting flexibility.

How to Convert Between int64 and string in Golang

In Golang, converting between int64 and string is a common task when dealing with user input, data storage, or serialization. This article will cover various methods to convert int64 to string and vice versa.

---

Convert int64 to string

There are multiple ways to convert an int64 to a string in Go, depending on the use case.

Using strconv.FormatInt

The strconv package provides the FormatInt function to convert an int64 to a string with a specified base.

package main

import (
        "fmt"
        "strconv"
)

func main() {
        num := int64(1234567890)
        str := strconv.FormatInt(num, 10) // Convert int64 to decimal string
        fmt.Println(str) // Output: "1234567890"
}

Using fmt.Sprintf

Another approach is using fmt.Sprintf, which is more flexible and commonly used when formatting output.

package main

import (
        "fmt"
)

func main() {
        num := int64(1234567890)
        str := fmt.Sprintf("%d", num) // Format int64 as a decimal string
        fmt.Println(str) // Output: "1234567890"
}

The fmt.Sprintf function is useful when formatting numbers with additional text.

str := fmt.Sprintf("The number is %d", num)
fmt.Println(str) // Output: "The number is 1234567890"

---

Convert string to int64

To convert a string back to int64, we primarily use the strconv.ParseInt function.

Using strconv.ParseInt

package main

import (
        "fmt"
        "strconv"
)

func main() {
        str := "1234567890"
        num, err := strconv.ParseInt(str, 10, 64) // Parse as base 10 and store as int64
        if err != nil {
                fmt.Println("Error:", err)
                return
        }
        fmt.Println(num) // Output: 1234567890
}

Handling Conversion Errors

If the input string is not a valid number, strconv.ParseInt will return an error.

str := "invalid123"
num, err := strconv.ParseInt(str, 10, 64)
if err != nil {
        fmt.Println("Conversion failed:", err)
} else {
        fmt.Println(num)
}

---

Which Method Should You Use?

---

Conclusion

In Golang, you can easily convert between int64 and string using the strconv package or fmt.Sprintf. For performance-critical applications, strconv.FormatInt and strconv.ParseInt are preferred. If you need more flexibility, fmt.Sprintf works well.

By understanding these conversion methods, you can efficiently handle numeric data in your Go applications.

FAQs

What is the most efficient way to convert int64 to string?

strconv.FormatInt(num, 10) is the most efficient method.

How can I handle errors when converting a string to int64?

Use strconv.ParseInt and check the error return value.

When should I use fmt.Sprintf instead of strconv.FormatInt?

Use fmt.Sprintf when formatting numbers within a larger text string.

---

We are Leapcell, your top choice for hosting Go projects.

Leapcell is the Next-Gen Serverless Platform for Web Hosting, Async Tasks, and Redis:

Multi-Language Support

• Develop with Node.js, Python, Go, or Rust.

Deploy unlimited projects for free

• pay only for usage — no requests, no charges.

Unbeatable Cost Efficiency

• Pay-as-you-go with no idle charges.
• Example: $25 supports 6.94M requests at a 60ms average response time.

Streamlined Developer Experience

• Intuitive UI for effortless setup.
• Fully automated CI/CD pipelines and GitOps integration.
• Real-time metrics and logging for actionable insights.

Effortless Scalability and High Performance

• Auto-scaling to handle high concurrency with ease.
• Zero operational overhead — just focus on building.

Explore more in the Documentation!

Follow us on X: @LeapcellHQ