Noções Básicas de Tipos de Dados

10 exemplos para você começar com o sistema de tipos e o comportamento de memória do Go - 7 básicos e 3 intermediários.

Pré-requisitos

Instale o Go 1.26.x e execute os exemplos de qualquer diretório de módulo:

go version   # espere go1.26.x
mkdir -p /tmp/go-types-demo && cd /tmp/go-types-demo
go mod init example.com/types-demo

Salve cada trecho como main.go (ou combine em um único main com funções separadas) e execute go run ..

Exemplos Básicos

1. Valores Zero

Toda variável declarada sem um inicializador recebe o valor zero de seu tipo.

package main
 
import "fmt"
 
func main() {
	var i int
	var s string
	var p *int
	fmt.Printf("int=%d string=%q ptr=%v\n", i, s, p)
}

• 0, "", false, nil são os valores zero comuns para tipos numéricos, string, bool e tipos semelhantes a referência
• O valor zero não é "desmarcado" - é um estado válido para o qual você deve projetar (especialmente slices e mapas nil)
• Use var quando o valor zero for significativo; use := com um literal quando não for

Relacionado: Modelo de Memória do Go - por que a semântica de valor começa nos valores zero

2. Arrays vs Slices

Arrays têm tamanho fixo no tipo; slices são visualizações dinâmicas sobre um array de backup.

package main
 
import "fmt"
 
func main() {
	var arr [3]int = [3]int{1, 2, 3}
	sl := []int{10, 20, 30}
	fmt.Println(len(arr), len(sl), cap(sl))
}

• [3]int e [4]int são tipos diferentes - arrays raramente são parâmetros de função em APIs
• Slices são o tipo de sequência idiomático - cabeçalhos passados por valor, array de backup compartilhado
• len é o comprimento; cap é a capacidade do primeiro elemento do slice até o final do array de backup

Relacionado: Internos de Slice - layout de ponteiro, len, cap e append

3. Mapas e Comportamento Nil

Mapas associam chaves a valores. Um mapa nil é legível, mas não gravável.

package main
 
import "fmt"
 
func main() {
	var m map[string]int
	fmt.Println(m["missing"]) // 0, sem pânico
	m = make(map[string]int)
	m["go"] = 1
	fmt.Println(m["go"])
}

• Ler uma chave ausente retorna o valor zero do tipo de valor - use a forma de vírgula-ok para detectar a presença
• Escrever em um mapa nil causa pânico - sempre use make ou um literal antes de inserir
• Mapas não são seguros para escritas concorrentes sem um mutex ou sync.Map

Relacionado: Internos de Mapa - crescimento e ordem de iteração

4. Literais de Struct e Tags de Campo

Structs agrupam campos com semântica de valor, a menos que você armazene ponteiros.

package main
 
import (
	"encoding/json"
	"fmt"
)
 
type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}
 
func main() {
	u := User{ID: 1, Name: "Ada"}
	b, _ := json.Marshal(u)
	fmt.Println(string(b))
}

• Campos exportados começam com maiúscula - encoding/json só vê campos exportados
• A atribuição de struct copia todos os campos - incluindo campos de slice e mapa (cabeçalhos compartilham)
• Tags de campo são strings de metadados analisadas por reflect em tempo de execução

Relacionado: Alinhamento de Struct - preenchimento e unsafe.Sizeof

5. Ponteiros e Operadores de Endereço

& pega um endereço; * desreferencia. Go não tem aritmética de ponteiros em código seguro.

package main
 
import "fmt"
 
func bump(n *int) {
	*n++
}
 
func main() {
	x := 10
	bump(&x)
	fmt.Println(x)
}

• Você não pode pegar o endereço de um índice de mapa ou de temporários - o compilador impõe segurança de memória
• new(T) retorna *T inicializado com zero - equivalente a var v T; return &v quando escapa
• A desreferência de ponteiro nil causa pânico - verifique antes de usar em APIs defensivas

Relacionado: Ponteiros unsafe - quando unsafe.Pointer é justificado

6. Interfaces Vazias e Tipadas

interface{} (ou any) contém qualquer valor; outras interfaces contêm valores com métodos específicos.

package main
 
import "fmt"
 
type Greeter interface {
	Greet() string
}
 
type Person struct{ Name string }
 
func (p Person) Greet() string { return "hello, " + p.Name }
 
func describe(v any) {
	fmt.Printf("%T %v\n", v, v)
}
 
func main() {
	var g Greeter = Person{Name: "Ada"}
	describe(g)
	fmt.Println(g.Greet())
}

• Interfaces são satisfeitas implicitamente - sem palavra-chave implements
• %T imprime o tipo dinâmico - essencial ao depurar parâmetros any
• Uma interface nil (var i any) difere de uma interface que contém um ponteiro nil tipado

Relacionado: Internos de Interface - itables e tipo dinâmico

7. Canais para Sinalização

Canais transferem valores entre goroutines com semântica de bloqueio.

package main
 
import "fmt"
 
func main() {
	ch := make(chan int, 1)
	ch <- 42
	v := <-ch
	fmt.Println(v)
}

• make(chan T) não é bufferizado - rendezvous de envio e recebimento
• Capacidade make(chan T, n) armazena n envios sem um receptor correspondente
• Fechar um canal sinaliza a conclusão - receptores recebem o valor zero e ok == false

Relacionado: Internos de Canal - regras de bloqueio em detalhes

Exemplos Intermediários

8. Asserções de Tipo e Switches de Tipo

Extraia tipos concretos de interfaces com segurança.

package main
 
import "fmt"
 
func parse(v any) {
	switch x := v.(type) {
	case int:
		fmt.Println("int", x*2)
	case string:
		fmt.Println("string", len(x))
	default:
		fmt.Printf("other %T\n", x)
	}
}
 
func main() {
	parse(21)
	parse("go")
}

• A asserção de dois valores x, ok := v.(int) evita pânico em asserções falhas
• Switches de tipo despacham por tipo dinâmico - comum em decodificadores JSON e APIs de plugin
• A asserção para o tipo concreto errado causa pânico na forma de valor único

Relacionado: Interface Nil vs Ponteiro Nil - armadilhas de asserção com nil tipado

9. Compartilhamento de Slice e copy

Sub-slicing compartilha um array de backup; copy duplica elementos em um slice existente.

package main
 
import "fmt"
 
func main() {
	src := []int{1, 2, 3, 4}
	dst := make([]int, 2)
	n := copy(dst, src[1:])
	fmt.Println(dst, n, src)
}

• copy retorna o número de elementos copiados - mínimo entre len(dst) e len(src)
• Sub-slicing não copia dados - mutar dst pode afetar src se eles se sobrepuserem
• Use append para um novo slice com capacidade suficiente quando precisar de uma cópia independente

Relacionado: Internos de Slice - quando append realoca

10. make vs new

make inicializa slices, mapas e canais; new aloca um único valor e retorna um ponteiro.

package main
 
import "fmt"
 
func main() {
	s := make([]byte, 0, 64)
	m := make(map[string]struct{})
	c := make(chan struct{})
	p := new(int)
	fmt.Printf("slice cap=%d map=%v chan=%v *p=%d\n", cap(s), m != nil, c != nil, *p)
}

• make retorna um valor inicializado (não nil) pronto para uso
• new(T) raramente é necessário - var v T; &v ou literais são mais claros para structs
• Capacidade em make([]T, 0, n) evita crescimento repetido de append em loops críticos

Relacionado: Tipos de Dados e Melhores Práticas de Memória - escolhendo layouts para desempenho

Links Relacionados Externos

• A Tour of Go - Introdução interativa oficial ao Go.
• Go by Example - Exemplos de código práticos anotados.
• Documentação da Biblioteca Padrão do Go - Referência completa para a biblioteca padrão.
• Get Programming with Go (Manning) - Nathan Youngman & Roger Peppé.
• The Go Programming Language (ebook) - Donovan & Kernighan.

Versões de Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizadores - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).