Tipos de datos en Golang: int, float64, string, bool, byte, rune

Los tipos básicos de Go son números, booleanos y strings. Cada variable tiene exactamente un tipo, fijado en tiempo de compilación, y Go nunca convierte entre tipos por ti. %T imprime el tipo de cualquier valor:

package main

import "fmt"

func main() {
	count := 42
	price := 19.99
	name := "gopher"
	ok := true
	initial := 'G'
	raw := byte('G')
	z := 3 + 4i

	fmt.Printf("%-8v %T\n", count, count)
	fmt.Printf("%-8v %T\n", price, price)
	fmt.Printf("%-8v %T\n", name, name)
	fmt.Printf("%-8v %T\n", ok, ok)
	fmt.Printf("%-8v %T\n", initial, initial)
	fmt.Printf("%-8v %T\n", raw, raw)
	fmt.Printf("%v %T\n", z, z)
}

Fíjate en que 'G' se imprime como 71 con tipo int32: un carácter entre comillas simples es un rune, que es un número (el code point Unicode). rune es un alias de int32 (el mismo tipo con otro nombre), así que %T muestra int32. Del mismo modo, byte muestra uint8.

Enteros

Usa int por defecto. len() devuelve int, los índices de los slices son int y los contadores de bucle son int. En todas las plataformas de 64 bits int tiene 64 bits. Recurre a los tipos con tamaño cuando el tamaño forma parte de un contrato: int32 en un formato de archivo binario, uint8 para bytes en bruto, int64 para una marca de tiempo Unix en nanosegundos.

Evita los tipos sin signo para cantidades que "no pueden ser negativas", como los recuentos. Restar por debajo de cero da la vuelta a un número enorme en lugar de producir uno negativo que podrías detectar.

Límites y desbordamiento

El paquete math tiene una constante para cada límite. En tiempo de ejecución, la aritmética entera que se desborda da la vuelta en silencio:

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt:  ", math.MaxInt)
	fmt.Println("MaxInt32:", math.MaxInt32)
	fmt.Println("MaxUint8:", math.MaxUint8)

	var small int8 = 127
	small++
	fmt.Println("127 + 1 as int8:", small)

	var u uint = 0
	u--
	fmt.Println("0 - 1 as uint:", u)

	var n int32 = math.MaxInt32
	fmt.Println("MaxInt32 * 2:", n*2)
}

Ni panic ni error: 127 + 1 se convierte en -128. Solo las expresiones constantes se comprueban en tiempo de compilación (var b int8 = 128 no compila). Si en tus datos es posible un desbordamiento, compruébalo antes de la operación o usa math/big.

Literales enteros

million := 1_000_000   // underscores for readability (Go 1.13+)
mask := 0xFF           // hexadecimal
perm := 0o755          // octal (also the older form 0755)
flags := 0b1010        // binary

Números de punto flotante

Un literal con punto decimal o exponente (2.5, 1e6) es float64 por defecto, y el paquete math recibe y devuelve float64. Úsalo salvo que importe la memoria de un array grande.

Los flotantes son binarios, así que la mayoría de las fracciones decimales son aproximaciones:

package main

import (
	"fmt"
	"math"
)

func main() {
	a := 0.1
	b := 0.2
	fmt.Println(a+b, a+b == 0.3)

	// compare with a tolerance instead
	fmt.Println(math.Abs((a+b)-0.3) < 1e-9)

	// integer division vs float division
	fmt.Println(7/2, 7.0/2, float64(7)/2)

	// special values
	zero := 0.0
	fmt.Println(1/zero, -1/zero, math.NaN())
}

De ahí salen dos reglas. Nunca compares flotantes con == después de hacer aritmética. Y nunca guardes dinero en un flotante: usa un número entero de céntimos o una librería decimal.

Dividir un flotante entre cero da +Inf, -Inf o NaN en lugar de provocar un panic. Dividir un entero entre cero provoca un panic en tiempo de ejecución (runtime error: integer divide by zero), y un divisor cero constante es un error de compilación.

Booleanos

bool contiene true o false, y su valor cero es false. Go no trata los números, los strings vacíos ni nil como booleanos. if count {} es un error de compilación; escribe if count > 0 {}. Los operadores son &&, || y !, y && y || hacen cortocircuito.

Strings

Un string es una secuencia inmutable de bytes, normalmente texto UTF-8. len(s) cuenta bytes, no caracteres:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo"
	fmt.Println(len(s))                    // bytes
	fmt.Println(utf8.RuneCountInString(s)) // characters
	fmt.Println(s[0], string(s[0]))        // indexing gives a byte

	multiline := `raw string:
backslashes \n stay as written`
	fmt.Println(multiline)
}

é ocupa dos bytes en UTF-8, así que len devuelve 6 para cinco caracteres. Los strings entre comillas dobles procesan escapes como \n; los raw strings entre comillas invertidas no, y pueden ocupar varias líneas. La página de strings cubre el paquete strings, y la de runes y bytes trata UTF-8 a fondo.

byte y rune

Son alias, no tipos nuevos: un byte y un uint8 son intercambiables sin conversión. Los nombres dicen qué significa el número.

Números complejos

Go tiene tipos complejos integrados, complex64 y complex128, con real, imag y el paquete math/cmplx:

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	c := complex(3, 4) // complex128
	fmt.Println(c, real(c), imag(c))
	fmt.Println(cmplx.Abs(c))
	fmt.Println(cmplx.Sqrt(-1))
}

Pocos programas los necesitan, pero el procesamiento de señales y algo de código numérico sí.

Tipos compuestos y de referencia

Los tipos básicos se combinan en tipos compuestos. Cada uno tiene su propia página:

any es un alias de interface{} (desde Go 1.18) y puede contener un valor de cualquier tipo.

Tipos con nombre

Puedes definir un tipo nuevo a partir de uno existente. Tiene la misma representación pero es un tipo distinto, y puede tener métodos:

type Celsius float64
type UserID int64

var t Celsius = 21.5
var f float64 = t // compile error: cannot use t (variable of float64 type Celsius) as float64 value in variable declaration

Esa rigidez es precisamente la idea: un UserID no se puede pasar por accidente donde se espera un OrderID. Convierte de forma explícita cuando sea lo que quieres: float64(t). Consulta la conversión de tipos para las reglas y las funciones de strconv para pasar entre números y strings.

Valores cero

Cada tipo tiene un valor cero, que es lo que contiene una variable antes de que le asignes nada: 0 para los números, false para bool, "" para los strings y nil para punteros, slices, maps, channels, funciones e interfaces. En Go no hay variables sin inicializar.