Convert int and long types to strings using Go

This article describes how to convert data of types int and int64 (long) into strings in Go to build strings containing numeric and time information in concurrent programs. The article provides examples of Itoa and FormatInt functions using the strconv package, and highlights updates that Itoa64 was replaced by FormatInt after Go 1.
In Go language, it is often necessary to embed numeric data into strings, especially in concurrent programs, and information such as integers, timestamps, etc. may be combined into strings for passing. The Go language's standard library strconv package provides convenient functions to implement these transformations.
Use strconv.Itoa to convert int to string
The strconv.Itoa function can convert data of type int into the corresponding string representation. This is very convenient when building strings containing integers.
package main
import (
"fmt"
"strconv"
)
func main() {
number := 123
str := "The number is: " strconv.Itoa(number)
fmt.Println(str) // Output: The number is: 123
}
In the above example, strconv.Itoa(number) converts the integer 123 to the string "123", and then concatenates it with the string "The number is: ".
Convert int64 to a string using strconv.FormatInt
For int64 type data (usually used to represent timestamps, etc.), you can use the strconv.FormatInt function to convert it to a string. This function requires two parameters: the int64 value to be converted and the base. The commonly used cardinality is 10, which means decimal.
package main
import (
"fmt"
"strconv"
"time"
)
func main() {
timestamp := time.Now().UnixNano()
str := "Timestamp: " strconv.FormatInt(timestamp, 10)
fmt.Println(str) // Output: Timestamp: 1678886400000000000 (Example)
}
In this example, time.Now().UnixNano() gets the nanosecond time stamp of the current time, of type int64. strconv.FormatInt(timestamp, 10) then converts it to a decimal string.
String construction in concurrent environment
In concurrent programs, special attention should be paid to the efficiency and thread safety of string construction. Here is a simple example showing how to build a string containing numeric and time information in a concurrent goroutine and pass it through the channel:
package main
import (
"fmt"
"strconv"
"time"
)
func routine1(out chan<p> In this example, routine1 is responsible for generating a string containing a loop counter and a timestamp, and is sent via channel out. routine2 is responsible for receiving strings from the channel and printing them.</p><p> <strong>Notes:</strong></p>
- Go 1 Update: Before Go 1, the strconv.Itoa64 function might be used, but the function has been replaced by strconv.FormatInt. Make sure to use strconv.FormatInt to handle conversions of type int64.
- String splicing efficiency: Frequent splicing of strings in loops may affect performance. If you need to build a large number of strings, consider using strings.Builder to improve efficiency.
- Channel Close: When routine1 completes sending, be sure to close channel out so that routine2 can correctly end reception.
Summarize
The strconv package provides powerful conversion of numeric type to string type. strconv.Itoa is used to convert int to strings, while strconv.FormatInt is used to convert int64 to strings. In concurrent programs, using these functions reasonably and paying attention to the efficiency of string construction and the correct shutdown of channel can effectively build strings containing numeric and time information.
The above is the detailed content of Convert int and long types to strings using Go. For more information, please follow other related articles on the PHP Chinese website!
Hot AI Tools
Undress AI Tool
Undress images for free
Undresser.AI Undress
AI-powered app for creating realistic nude photos
AI Clothes Remover
Online AI tool for removing clothes from photos.
Clothoff.io
AI clothes remover
Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!
Hot Article
Hot Tools
Notepad++7.3.1
Easy-to-use and free code editor
SublimeText3 Chinese version
Chinese version, very easy to use
Zend Studio 13.0.1
Powerful PHP integrated development environment
Dreamweaver CS6
Visual web development tools
SublimeText3 Mac version
God-level code editing software (SublimeText3)
How do you work with environment variables in Golang?
Aug 19, 2025 pm 02:06 PM
Goprovidesbuilt-insupportforhandlingenvironmentvariablesviatheospackage,enablingdeveloperstoread,set,andmanageenvironmentdatasecurelyandefficiently.Toreadavariable,useos.Getenv("KEY"),whichreturnsanemptystringifthekeyisnotset,orcombineos.Lo
go by example running a subprocess
Aug 06, 2025 am 09:05 AM
Run the child process using the os/exec package, create the command through exec.Command but not execute it immediately; 2. Run the command with .Output() and catch stdout. If the exit code is non-zero, return exec.ExitError; 3. Use .Start() to start the process without blocking, combine with .StdoutPipe() to stream output in real time; 4. Enter data into the process through .StdinPipe(), and after writing, you need to close the pipeline and call .Wait() to wait for the end; 5. Exec.ExitError must be processed to get the exit code and stderr of the failed command to avoid zombie processes.
What are the alternatives to standard library logging in Golang?
Aug 05, 2025 pm 08:36 PM
FornewGo1.21 projects,useslogforofficialstructuredloggingsupport;2.Forhigh-performanceproductionservices,chooseZaporZerologduetotheirspeedandlowallocations;3.ForeaseofuseandrichintegrationslikeSlackorSentryhooks,Logrusisidealdespitelowerperformance;4
What are the best practices for API versioning in a Golang service?
Aug 04, 2025 pm 04:50 PM
UseURLpathversioninglike/api/v1forclear,routable,anddeveloper-friendlyversioning.2.Applysemanticversioningwithmajorversions(v1,v2)only,avoidingmicro-versionslikev1.1topreventroutingcomplexity.3.OptionallysupportcontentnegotiationviaAcceptheadersifalr
How to implement a generic LRU cache in Go
Aug 18, 2025 am 08:31 AM
Use Go generics and container/list to achieve thread-safe LRU cache; 2. The core components include maps, bidirectional linked lists and mutex locks; 3. Get and Add operations ensure concurrency security through locks, with a time complexity of O(1); 4. When the cache is full, the longest unused entry will be automatically eliminated; 5. In the example, the cache with capacity of 3 successfully eliminated the longest unused "b". This implementation fully supports generic, efficient and scalable.
How to create and use custom error types in Go
Aug 11, 2025 pm 11:08 PM
In Go, creating and using custom error types can improve the expressiveness and debugability of error handling. The answer is to create a custom error by defining a structure that implements the Error() method. For example, ValidationError contains Field and Message fields and returns formatted error information. The error can then be returned in the function, detecting specific error types through type assertions or errors.As to execute different logic. You can also add behavioral methods such as IsCritical to custom errors, which are suitable for scenarios that require structured data, differentiated processing, library export or API integration. In simple cases, errors.New, and predefined errors such as ErrNotFound can be used for comparable
How do you handle signals in a Go application?
Aug 11, 2025 pm 08:01 PM
The correct way to process signals in Go applications is to use the os/signal package to monitor the signal and perform elegant shutdown. 1. Use signal.Notify to send SIGINT, SIGTERM and other signals to the channel; 2. Run the main service in goroutine and block the waiting signal; 3. After receiving the signal, perform elegant shutdown with timeout through context.WithTimeout; 4. Clean up resources such as closing database connections and stopping background goroutine; 5. Use signal.Reset to restore the default signal behavior when necessary to ensure that the program can be reliably terminated in Kubernetes and other environments.
What are some best practices for logging in Go?
Aug 04, 2025 pm 04:48 PM
Using structured logging, adding context, controlling log levels, avoiding logging sensitive data, using consistent field names, correctly logging errors, taking into account performance, centrally monitoring logs and unifying configurations are best practices in Go to achieve efficient logging. First, structured logs in JSON format (such as using uber-go/zap or rs/zerolog) facilitate machine parsing and integrating ELK, Datadog and other tools; second, log traceability is enhanced by requesting context information such as ID and user ID, and can be injected through context.Context or HTTP middleware; third, use Debug, Info, Warn, Error levels reasonably, and operate through environment variables.


