Go ofrece varios métodos eficientes para convertir enteros a sus representaciones de cadena. Esta es una tarea común al mostrar números, registrar datos o construir cadenas para diversos propósitos. Este artículo explora tres enfoques principales: el uso de la función strconv.Itoa, la función strconv.FormatInt y el método fmt.Sprint.
Tabla de contenido
Función strconv.Itoa
Para convertir enteros con signo (int) a cadenas, strconv.Itoa proporciona la solución más simple y eficiente. Toma directamente un entero y devuelve su equivalente en cadena. Si bien es muy confiable, un posible error (aunque poco frecuente) resultará en un pánico.
package main
import (
"fmt"
"strconv"
)
func main() {
num := 12345
str := strconv.Itoa(num)
fmt.Println(str) // Salida: 12345
negativeNum := -9876
negativeStr := strconv.Itoa(negativeNum)
fmt.Println(negativeStr) // Salida: -9876
}
Su concisión y velocidad lo hacen ideal para conversiones directas de enteros con signo.
Función strconv.FormatInt
strconv.FormatInt ofrece mayor flexibilidad, admite varios tamaños de enteros (int64, int32, etc.) y permite especificar la base (radix) para la cadena de salida. Esta característica es particularmente útil para representar números en formatos binario, octal o hexadecimal.
package main
import (
"fmt"
"strconv"
)
func main() {
num := int64(12345)
str := strconv.FormatInt(num, 10) // Base 10 (decimal)
fmt.Println(str) // Salida: 12345
hexStr := strconv.FormatInt(num, 16) // Base 16 (hexadecimal)
fmt.Println(hexStr) // Salida: 3039
binStr := strconv.FormatInt(num, 2) // Base 2 (binario)
fmt.Println(binStr) // Salida: 11000000111001
unsignedNum := uint64(12345)
unsignedStr := strconv.FormatUint(unsignedNum, 10)
fmt.Println(unsignedStr) //Salida: 12345
}
El segundo argumento establece la base (10 para decimal, 16 para hexadecimal, 2 para binario, 8 para octal). Para enteros sin signo, use strconv.FormatUint.
Método fmt.Sprint
La función fmt.Sprint proporciona una solución de propósito general para convertir varios tipos de datos, incluidos los enteros, a cadenas. Si bien es menos eficiente que strconv.Itoa para conversiones simples de enteros, su versatilidad brilla al formatear varios valores simultáneamente.
package main
import (
"fmt"
)
func main() {
num := 12345
str := fmt.Sprint(num)
fmt.Println(str) // Salida: 12345
str2 := fmt.Sprintf("El número es: %d", num) //Más control sobre el formato
fmt.Println(str2) // Salida: El número es: 12345
multipleValues := fmt.Sprint("Valor1: ", 10, ", Valor2: ", 20)
fmt.Println(multipleValues) // Salida: Valor1: 10, Valor2: 20
}
fmt.Sprint es particularmente útil para incrustar enteros dentro de cadenas más grandes. fmt.Sprintf ofrece un control más preciso sobre el formato utilizando especificadores de formato (como %d para enteros decimales).
En resumen, strconv.Itoa es mejor para conversiones simples de enteros con signo; strconv.FormatInt (y strconv.FormatUint) proporciona control de base y maneja varios tamaños de enteros; y fmt.Sprint y fmt.Sprintf ofrecen mayor flexibilidad pero pueden ser menos eficientes para conversiones básicas de entero a cadena. Seleccione el método que se alinee óptimamente con sus necesidades y estilo de codificación.