Go Cheatsheet

Referência rápida de sintaxe Go. Copie e cole.

Hello World

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Variáveis

// Declaração explícita
var nome string = "João"
var idade int = 30

// Declaração curta (dentro de funções)
nome := "João"
idade := 30

// Múltiplas variáveis
var a, b, c int = 1, 2, 3
x, y := 10, 20

// Constantes
const Pi = 3.14159

Tipos Básicos

// Números
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
complex64, complex128

// Texto
string
byte  // alias para uint8
rune  // alias para int32 (Unicode)

// Booleano
bool  // true, false

Funções

// Função simples
func soma(a, b int) int {
    return a + b
}

// Múltiplos retornos
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("divisão por zero")
    }
    return a / b, nil
}

// Retornos nomeados
func minMax(nums []int) (min, max int) {
    min, max = nums[0], nums[0]
    // ...
    return // retorna min e max
}

Arrays e Slices

// Array (tamanho fixo)
var arr [5]int
arr := [3]string{"a", "b", "c"}

// Slice (tamanho dinâmico)
slice := []int{1, 2, 3}
slice = append(slice, 4, 5)

// Make (pré-aloca capacidade)
s := make([]int, 0, 10)

// Operações
len(slice)      // tamanho
cap(slice)      // capacidade
slice[1:3]      // sub-slice
copy(dst, src)  // copia

Maps

// Criar map
m := make(map[string]int)
m := map[string]int{"a": 1, "b": 2}

// Operações
m["key"] = 42           // set
value := m["key"]       // get
value, ok := m["key"]   // get + check
delete(m, "key")        // delete

// Iterar
for key, value := range m {
    fmt.Println(key, value)
}

Structs

// Definir struct
type Pessoa struct {
    Nome  string
    Idade int
}

// Criar instância
p := Pessoa{Nome: "Ana", Idade: 25}
p := Pessoa{"Ana", 25}

// Acessar campos
fmt.Println(p.Nome)
p.Idade = 26

// Ponteiro para struct
pp := &Pessoa{Nome: "Bob"}
pp.Nome = "Roberto"  // Go desreferencia

Métodos

type Retangulo struct {
    Largura, Altura float64
}

// Método com receiver por valor
func (r Retangulo) Area() float64 {
    return r.Largura * r.Altura
}

// Método com receiver por ponteiro
func (r *Retangulo) Escalar(fator float64) {
    r.Largura *= fator
    r.Altura *= fator
}

Interfaces

// Definir interface
type Forma interface {
    Area() float64
    Perimetro() float64
}

// Implementação implícita
// (basta ter os métodos)
type Circulo struct {
    Raio float64
}

func (c Circulo) Area() float64 {
    return math.Pi * c.Raio * c.Raio
}

func (c Circulo) Perimetro() float64 {
    return 2 * math.Pi * c.Raio
}

// Interface vazia (qualquer tipo)
var x interface{} = 42

Controle de Fluxo

// If/else
if x > 0 {
    // ...
} else if x < 0 {
    // ...
} else {
    // ...
}

// If com inicialização
if err := doSomething(); err != nil {
    return err
}

// Switch
switch day {
case "seg", "ter":
    // ...
case "sab", "dom":
    // ...
default:
    // ...
}

// Switch sem expressão
switch {
case x < 0:
    // ...
case x > 0:
    // ...
}

Loops

// For clássico
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// While (não existe, usa for)
for condition {
    // ...
}

// Infinito
for {
    // break para sair
}

// Range (arrays, slices, maps)
for i, v := range slice {
    fmt.Println(i, v)
}

// Só valores
for _, v := range slice {}

// Só índices
for i := range slice {}

Goroutines

// Iniciar goroutine
go minhaFuncao()

go func() {
    // goroutine anônima
}()

// Esperar goroutines (WaitGroup)
var wg sync.WaitGroup

for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(n int) {
        defer wg.Done()
        // trabalho
    }(i)
}

wg.Wait()

Channels

// Criar channel
ch := make(chan int)      // sem buffer
ch := make(chan int, 10)  // com buffer

// Enviar e receber
ch <- 42       // envia
valor := <-ch  // recebe

// Channel só leitura/escrita
func produtor(ch chan<- int) {}
func consumidor(ch <-chan int) {}

// Fechar channel
close(ch)

// Select (múltiplos channels)
select {
case v := <-ch1:
    // ...
case ch2 <- x:
    // ...
default:
    // não bloqueia
}

Erros

// Retornar erro
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("divisão por zero")
    }
    return a / b, nil
}

// Checar erro
result, err := divide(10, 0)
if err != nil {
    log.Fatal(err)
}

// Erro customizado
type MeuErro struct {
    Msg string
}

func (e MeuErro) Error() string {
    return e.Msg
}

// Wrap errors (Go 1.13+)
fmt.Errorf("falha: %w", err)

Defer, Panic, Recover

// Defer (executa no fim da função)
func exemplo() {
    defer fmt.Println("fim")
    fmt.Println("início")
}
// Saída: início, fim

// Panic (erro fatal)
panic("algo deu muito errado")

// Recover (captura panic)
func seguro() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recuperado:", r)
        }
    }()
    panic("boom")
}

HTTP Server

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Olá, %s!", r.URL.Path[1:])
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

JSON

import "encoding/json"

type Pessoa struct {
    Nome  string `json:"nome"`
    Idade int    `json:"idade,omitempty"`
}

// Encode (struct -> JSON)
p := Pessoa{Nome: "Ana", Idade: 25}
data, _ := json.Marshal(p)
// {"nome":"Ana","idade":25}

// Decode (JSON -> struct)
var p2 Pessoa
json.Unmarshal(data, &p2)

Testes

// arquivo: soma_test.go
package main

import "testing"

func TestSoma(t *testing.T) {
    resultado := Soma(2, 3)
    esperado := 5
    
    if resultado != esperado {
        t.Errorf("Soma(2,3) = %d; esperado %d", 
            resultado, esperado)
    }
}

// Rodar testes
// go test
// go test -v
// go test -cover

Módulos

# Iniciar módulo
go mod init github.com/user/projeto

# Adicionar dependência
go get github.com/pkg/errors

# Atualizar dependências
go mod tidy

# Listar dependências
go list -m all

# Arquivos
go.mod   # define módulo e deps
go.sum   # checksums

Comandos Úteis

# Compilar e rodar
go run main.go

# Compilar binário
go build -o app main.go

# Formatar código
go fmt ./...
gofmt -w .

# Verificar problemas
go vet ./...

# Documentação local
go doc fmt.Println

# Benchmark
go test -bench=.

Quer mais?

Veja também:

Language Spec Standard Library Recursos de Aprendizado