Tipos Numéricos, Cadenas, Runas y Segmentos de Bytes

Los tipos integrados de Go separan números de ancho fijo, texto UTF-8, puntos de código Unicode (runas) y bytes crudos.

Mezclarlos sin conversión es una fuente común de errores de desajuste y codificación.

Resumen

Los enteros y los flotantes tienen tamaños explícitos; las constantes sin tipo se adaptan al contexto.

Las cadenas son secuencias de bytes UTF-8 inmutables.

Una runa es un alias de int32 que representa un punto de código Unicode.

Usa []byte para datos binarios y []rune cuando necesites operaciones de texto indexadas por caracteres.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

package main
 
import (
    "fmt"
    "strconv"
    "unicode/utf8"
)
 
func main() {
    s := "café"
    fmt.Println(utf8.RuneCountInString(s)) // conteo de runas: 4
 
    n, err := strconv.Atoi("42")
    if err != nil {
        panic(err)
    }
    fmt.Println(n + 1)
}

Cuándo usar esto:

• Cuenta caracteres con utf8.RuneCountInString, no con len(string).
• Analiza la entrada del usuario con strconv, no con fmt.Sscanf, para obtener errores claros.
• Convierte números explícitamente con int64(x) al ampliar o reducir.
• Trata string y []byte como distintos a menos que copies para APIs.

Ejemplo de Trabajo

package main
 
import (
    "fmt"
    "strconv"
    "unicode/utf8"
)
 
func main() {
    price := "19.99"
    amount, err := strconv.ParseFloat(price, 64)
    if err != nil {
        fmt.Println("error de análisis:", err)
        return
    }
 
    title := "Hello, 世界"
    fmt.Println("bytes:", len(title))
    fmt.Println("runas:", utf8.RuneCountInString(title))
 
    for i, r := range title {
        fmt.Printf("índice de byte %d: %U\n", i, r)
    }
 
    b := []byte(title)
    b[0] = 'h' // muta la copia solo si reasignas la cadena desde b
    fmt.Println(string(b))
}

Lo que esto demuestra:

• strconv.ParseFloat para conversión de cadena a número con errores.
• len en cadenas mide bytes UTF-8, no runas.
• range sobre cadenas decodifica runas y produce índices de bytes.
• []byte(string) asigna una copia mutable de bytes.

Inmersión Profunda

Cómo Funciona

• Los tipos numéricos son enteros con signo/sin signo (int, int8..int64, uint, uint8..uint64), flotantes (float32, float64) y complex64/complex128.
• El tamaño de int y uint depende de la plataforma (32 o 64 bits); prefiere tipos con tamaño para la serialización.
• Las cadenas son de solo lectura; la conversión a []byte copia a menos que uses unsafe (evítalo).
• UTF-8 codifica runas en 1-4 bytes; UTF-8 inválido se reemplaza con U+FFFD al iterar.

Tipos Numéricos de un Vistazo

Cadena, Runa, Byte

Notas de Go

// strconv es el puente idiomático entre cadenas y números
i, err := strconv.ParseInt("ff", 16, 64)
f := strconv.FormatFloat(3.5, 'f', 2, 64)
 
// literal de runa vs byte
var letter rune = 'A'   // punto de código int32
var raw byte = 'A'      // uint8 ASCII

Trampas

• Usar len para contar caracteres - "é" tiene len 2 en UTF-8. Solución: utf8.RuneCountInString o range.
• Truncar con int32(x) silenciosamente - int64 grande a int32 se envuelve. Solución: verifica los límites antes de la conversión.
• Mutar []byte derivado de una cadena - Seguro para el segmento, pero reasignar string(b) crea una nueva cadena; la original no cambia. Solución: trata la conversión como una copia.
• fmt.Sscanf para análisis - Informes de error débiles en comparación con strconv. Solución: prefiere las funciones strconv.Parse*.
• Comparar flotantes con == - Problemas con 0.1+0.2. Solución: comparación con épsilon o enteros en centavos.
• Indexar cadena por byte - s[i] es un byte, no una runa; puede dividir secuencias multibyte. Solución: usa range o convierte a []rune para indexar.

Alternativas

Preguntas Frecuentes

strconv.Itoa(42)
strconv.FormatInt(42, 10)
fmt.Sprintf("%d", 42) // asigna más memoria; está bien para logs

Relacionado

• Arrays, Segmentos y Mapas de un Vistazo - Mecánica de segmentos detrás de []byte y []rune
• Valores Cero e Inicialización - Valores predeterminados de cadena vacía y numéricos
• Variables, Constantes y Ámbito - Constantes tipificadas vs. sin tipo
• Conceptos Básicos de Fundamentos de Go - Ejemplo de iteración de cadenas

Enlaces Externos Relacionados

• Especificación del Lenguaje Go - La referencia formal del lenguaje.
• Go by Example - Ejemplos prácticos de código anotados.
• Documentación de la Biblioteca Estándar de Go - Referencia completa de la biblioteca estándar.
• The Go Programming Language (ebook) - Donovan & Kernighan.
• Learning Go (2nd Edition, O'Reilly) - Jon Bodner en O'Reilly.

Versiones de Stack: Esta página fue escrita para Go 1.26.x (GC por defecto Green Tea, go fix modernizers - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación), y golangci-lint (última - verificar conjunto de linters en la compilación).