Tipos integrados de Go

Go cuenta con un amplio conjunto de tipos integrados organizados en categorías:

• Booleano: bool
• Entero: int, int8, int16, int32, int64 y sus variantes sin signo
• Coma flotante: float32, float64
• Cadena: string
• Complejo: complex64, complex128

Go proporciona tipos enteros dependientes de la plataforma y de tamaño fijo:

• int / uint: tamaño de la plataforma (32 o 64 bits)
• int8…int64: anchos de bits fijos
• byte: alias de uint8
• rune: alias de int32 que representa un punto de código Unicode

Use int para enteros de propósito general, a menos que necesite un ancho específico.

Los tipos de coma flotante siguen IEEE 754:

Las cadenas de Go son secuencias inmutables de bytes codificadas en UTF-8:

• Entre comillas dobles: "Hello"; admiten secuencias de escape
• Entre comillas invertidas: `raw string`; no procesan escapes y pueden abarcar varias líneas
• len(s) devuelve el número de bytes, no de caracteres
• Recorra los caracteres con range para obtener runas

El tipo bool tiene dos valores: true y false.

• El valor cero es false
• Operadores lógicos: &&, ||, !
• Los operadores de comparación devuelven bool: ==, !=, <, >
• Go no convierte implícitamente enteros a bool (a diferencia de C)

Cada tipo tiene un valor cero bien definido:

• int, todos los tipos numéricos → 0
• float64 → 0.0
• string → ""
• bool → false
• *T, slice, map, chan, func → nil

Los valores cero hacen que el código Go sea seguro: nunca se lee memoria basura.

Go admite varios formatos de literales numéricos:

Conocer los tamaños de los tipos evita errores de desbordamiento:

• int8: -128 a 127
• uint8: 0 a 255
• int16: -32768 a 32767
• int32: aproximadamente ±2,1 mil millones
• int64: aproximadamente ±9,2 trillones

Use math.MaxInt64 y constantes similares del paquete math para obtener límites exactos.

rune y byte son alias de tipos con significado semántico:

• byte = uint8: se usa para datos binarios sin procesar o datos ASCII
• rune = int32: se usa para puntos de código Unicode

Cuando recorre una cadena con range, Go le proporciona valores rune, perfectos para trabajar con caracteres UTF-8 de varios bytes, como los emojis.

Directrices para elegir tipos numéricos:

• Use int de forma predeterminada para contadores e índices
• Use float64 para cálculos generales con coma flotante
• Use int64 / uint64 para identificadores, marcas de tiempo y recuentos grandes
• Use int32 solo al trabajar con API que lo requieran
• Evite float32 a menos que trabaje con gráficos o datos cuyo espacio sea limitado

Los tipos integrados de Go le proporcionan una base sólida:

• Familia de enteros: int, int64, byte, rune
• Coma flotante: prefiera float64
• string son bytes UTF-8 inmutables
• bool con true/false
• Cada tipo tiene un valor cero: no hay sorpresas

Siguiente: las constantes y el potente enumerador iota.

Experimente: declare una variable rune que contenga la letra 'A' y una variable byte que contenga 65. Imprima ambas; deberían producir el mismo valor numérico. Después, intente recorrer una cadena corta de emojis para observar los valores rune en acción.