Go oferece diversos métodos eficientes para converter inteiros em suas representações de string. Esta é uma tarefa comum ao exibir números, registrar dados ou construir strings para diversos propósitos. Este artigo explora três abordagens principais: usando a função strconv.Itoa, a função strconv.FormatInt e o método fmt.Sprint.
Sumário
Função strconv.Itoa
Para converter inteiros com sinal (int) em strings, strconv.Itoa fornece a solução mais simples e eficiente. Ela recebe diretamente um inteiro e retorna seu equivalente em string. Embora altamente confiável, um erro potencial (embora raro) resultará em um pânico.
package main
import (
"fmt"
"strconv"
)
func main() {
num := 12345
str := strconv.Itoa(num)
fmt.Println(str) // Saída: 12345
negativeNum := -9876
negativeStr := strconv.Itoa(negativeNum)
fmt.Println(negativeStr) // Saída: -9876
}
Sua concisão e velocidade a tornam ideal para conversões diretas de inteiros com sinal.
Função strconv.FormatInt
strconv.FormatInt oferece maior flexibilidade, suportando diversos tamanhos de inteiros (int64, int32, etc.) e permitindo especificar a base (radix) para a string de saída. Este recurso é particularmente útil para representar números em formatos binário, octal ou hexadecimal.
package main
import (
"fmt"
"strconv"
)
func main() {
num := int64(12345)
str := strconv.FormatInt(num, 10) // Base 10 (decimal)
fmt.Println(str) // Saída: 12345
hexStr := strconv.FormatInt(num, 16) // Base 16 (hexadecimal)
fmt.Println(hexStr) // Saída: 3039
binStr := strconv.FormatInt(num, 2) // Base 2 (binário)
fmt.Println(binStr) // Saída: 11000000111001
unsignedNum := uint64(12345)
unsignedStr := strconv.FormatUint(unsignedNum, 10)
fmt.Println(unsignedStr) //Saída: 12345
}
O segundo argumento define a base (10 para decimal, 16 para hexadecimal, 2 para binário, 8 para octal). Para inteiros sem sinal, use strconv.FormatUint.
Método fmt.Sprint
A função fmt.Sprint fornece uma solução de propósito geral para converter diversos tipos de dados, incluindo inteiros, em strings. Embora menos eficiente que strconv.Itoa para conversões simples de inteiros, sua versatilidade se destaca ao formatar múltiplos valores concorrentemente.
package main
import (
"fmt"
)
func main() {
num := 12345
str := fmt.Sprint(num)
fmt.Println(str) // Saída: 12345
str2 := fmt.Sprintf("O número é: %d", num) //Mais controle sobre a formatação
fmt.Println(str2) // Saída: O número é: 12345
multipleValues := fmt.Sprint("Valor1: ", 10, ", Valor2: ", 20)
fmt.Println(multipleValues) // Saída: Valor1: 10, Valor2: 20
}
fmt.Sprint é particularmente útil para incorporar inteiros em strings maiores. fmt.Sprintf oferece controle mais refinado sobre a formatação usando especificadores de formato (como %d para inteiros decimais).
Em resumo, strconv.Itoa é melhor para conversões simples de inteiros com sinal; strconv.FormatInt (e strconv.FormatUint) fornece controle de base e lida com diversos tamanhos de inteiros; e fmt.Sprint e fmt.Sprintf oferecem maior flexibilidade, mas podem ser menos eficientes para conversões básicas de inteiro para string. Selecione o método que se alinha melhor às suas necessidades e estilo de codificação.