Tipos de dados em Golang: int, float64, string, bool, byte, rune

Os tipos básicos do Go são números, booleanos e strings. Toda variável tem exatamente um tipo, fixado em tempo de compilação, e o Go nunca converte entre tipos por você. %T imprime o tipo de qualquer 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)
}

Repare que 'G' é impresso como 71, com tipo int32: um caractere entre aspas simples é uma rune, que é um número (o code point Unicode). rune é um alias de int32 (o mesmo tipo com um segundo nome), então %T mostra int32. Do mesmo jeito, byte aparece como uint8.

Inteiros

Use int por padrão. len() devolve int, índices de slice são int e contadores de laço são int. Em toda plataforma de 64 bits, int tem 64 bits. Recorra aos tipos com tamanho quando o tamanho fizer parte de um contrato: int32 em um formato de arquivo binário, uint8 para bytes brutos, int64 para um timestamp Unix em nanossegundos.

Evite tipos sem sinal para quantidades que "não podem ser negativas", como contagens. Subtrair além de zero dá a volta para um número enorme, em vez de gerar um negativo que você conseguiria detectar.

Limites e overflow

O pacote math tem uma constante para cada limite. Em tempo de execução, uma conta inteira que estoura dá a volta em silêncio:

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)
}

Sem panic, sem erro: 127 + 1 vira -128. Só expressões constantes são verificadas em tempo de compilação (var b int8 = 128 não compila). Se overflow for possível com os seus dados, verifique antes da operação ou use math/big.

Literais inteiros

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 ponto flutuante

Um literal com ponto decimal ou expoente (2.5, 1e6) é float64 por padrão, e o pacote math recebe e devolve float64. Use esse tipo, a menos que a memória de um array grande importe.

Floats são binários, então a maioria das frações decimais é uma aproximação:

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())
}

Daí saem duas regras. Nunca compare floats com == depois de fazer contas. E nunca guarde dinheiro em float: use um número inteiro de centavos ou uma biblioteca decimal.

Dividir um float por zero dá +Inf, -Inf ou NaN em vez de panic. Dividir um inteiro por zero causa panic em tempo de execução (runtime error: integer divide by zero), e um divisor zero constante é erro de compilação.

Booleanos

bool guarda true ou false, e o valor zero é false. Go não trata números, strings vazias ou nil como booleanos. if count {} é erro de compilação; escreva if count > 0 {}. Os operadores são &&, || e !, e && e || fazem avaliação de curto-circuito.

Strings

Uma string é uma sequência imutável de bytes, normalmente texto UTF-8. len(s) conta bytes, não 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 dois bytes em UTF-8, então len mostra 6 para cinco caracteres. Strings entre aspas duplas processam escapes como \n; raw strings entre crases não processam, e podem ocupar várias linhas. A página de strings cobre o pacote strings, e a de runes e bytes aprofunda o UTF-8.

byte e rune

São aliases, não tipos novos: um byte e um uint8 são intercambiáveis sem conversão. Os nomes dizem o que o número significa.

Números complexos

Go tem tipos complexos embutidos, complex64 e complex128, com real, imag e o pacote 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))
}

Poucos programas precisam deles, mas processamento de sinais e parte do código numérico precisam.

Tipos compostos e de referência

Os tipos básicos se combinam em tipos compostos. Cada um tem a sua página:

any é um alias de interface{} (desde o Go 1.18) e pode guardar um valor de qualquer tipo.

Tipos nomeados

Você pode definir um tipo novo a partir de um existente. Ele tem a mesma representação, mas é um tipo distinto, e pode ter 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

Essa rigidez é proposital: um UserID não pode ser passado por acidente onde se espera um OrderID. Converta explicitamente quando for essa a intenção: float64(t). Veja conversão de tipos para as regras e as funções de strconv para ir de números para strings e vice-versa.

Valores zero

Todo tipo tem um valor zero, que é o que a variável guarda antes de você atribuir algo: 0 para números, false para bool, "" para strings e nil para ponteiros, slices, maps, channels, funções e interfaces. Não existem variáveis não inicializadas em Go.