Folha de Consulta Go
Última atualização
Hello World e estrutura do programa
Todo programa Go fica em um pacote; o ponto de entrada é func main no pacote main.
| Operação | Sintaxe |
|---|---|
| Declaração de pacote | package main |
| Importar um pacote | import "fmt" |
| Importar vários pacotes | import (\n "fmt"\n "os"\n) |
| Ponto de entrada | func main() { ... } |
| Exibir uma linha | fmt.Println("Hello, World!") |
| Impressão formatada | fmt.Printf("%d items\n", n) |
| Executar um arquivo | go run main.go |
| Compilar um binário | go build |
Variáveis e tipos
Go é tipado estaticamente, mas pode inferir tipos com :=.
| Operação | Sintaxe |
|---|---|
| Declarar com tipo | var age int = 30 |
| Declarar com inferência | var name = "Ada" |
| Declaração curta | count := 0 |
| Vários de uma vez | x, y := 1, 2 |
| Constante | const Pi = 3.14 |
| Valores zero | 0, "", false, nil |
| Tipos básicos | int, float64, string, bool, byte, rune |
| Conversão de tipo | f := float64(i) |
Controle de fluxo
Go tem uma única palavra-chave de laço - for - e não usa parênteses ao redor das condições.
| Operação | Sintaxe |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If com instrução de inicialização | if v, ok := m[k]; ok { ... } |
| Laço for (estilo C) | for i := 0; i < 10; i++ { ... } |
| Laço estilo while | for x < 100 { ... } |
| Laço infinito | for { ... } |
| Range sobre um slice | for i, v := range items { ... } |
| Switch | switch day { case 1: ...; default: ... } |
| Switch sem expressão | switch { case x > 0: ... } |
| Break / continue | break, continue |
Funções
Funções são valores de primeira classe e podem retornar múltiplos resultados.
| Operação | Sintaxe |
|---|---|
| Função básica | func add(a int, b int) int { return a + b } |
| Tipo de parâmetro compartilhado | func add(a, b int) int { ... } |
| Múltiplos valores de retorno | func divmod(a, b int) (int, int) { return a / b, a % b } |
| Valores de retorno nomeados | func split(sum int) (x, y int) { x = sum / 2; return } |
| Função variádica | func sum(nums ...int) int { ... } |
| Função anônima | f := func() { ... } |
| Closure | func counter() func() int { ... } |
| Defer (executa no return) | defer file.Close() |
Slices e arrays
Arrays têm tamanho fixo; slices são visões dinâmicas sobre arrays.
| Operação | Sintaxe |
|---|---|
| Array de tamanho fixo | var a [3]int |
| Literal de slice | nums := []int{1, 2, 3} |
| Criar um slice | s := make([]int, 0, 10) |
| Append | s = append(s, 4) |
| Comprimento / capacidade | len(s), cap(s) |
| Fatiar um slice | s[1:3] |
| Copiar | copy(dst, src) |
| Iterar | for i, v := range s { ... } |
Maps
Maps são as tabelas hash embutidas de Go.
| Operação | Sintaxe |
|---|---|
| Criar um map | m := make(map[string]int) |
| Literal de map | m := map[string]int{"a": 1, "b": 2} |
| Definir um valor | m["c"] = 3 |
| Obter um valor | v := m["a"] |
| Verificar existência | v, ok := m["x"] |
| Excluir uma chave | delete(m, "a") |
| Comprimento | len(m) |
| Iterar | for k, v := range m { ... } |
Structs e métodos
Structs agrupam campos; métodos anexam comportamento por meio de um receptor.
| Operação | Sintaxe |
|---|---|
| Definir uma struct | type Point struct { X, Y int } |
| Criar uma instância | p := Point{X: 1, Y: 2} |
| Acessar um campo | p.X |
| Ponteiro para uma struct | p := &Point{1, 2} |
| Método com receptor por valor | func (p Point) Dist() float64 { ... } |
| Método com receptor por ponteiro | func (p *Point) Move(dx int) { p.X += dx } |
| Struct embutida | type Circle struct { Point; R int } |
| Tags de struct | Name string com uma tag json:"name" entre crases |
Interfaces
Interfaces são satisfeitas implicitamente - qualquer tipo com os métodos certos se qualifica.
| Operação | Sintaxe |
|---|---|
| Definir uma interface | type Shape interface { Area() float64 } |
| Implementar (implícito) | func (c Circle) Area() float64 { ... } |
| Interface vazia (any) | var x interface{} ou var x any |
| Asserção de tipo | s, ok := x.(string) |
| Switch de tipo | switch v := x.(type) { case int: ... } |
| Interface Stringer | func (p Point) String() string { ... } |
Goroutines e channels
Goroutines são threads leves; channels passam valores entre elas.
| Operação | Sintaxe |
|---|---|
| Iniciar uma goroutine | go doWork() |
| Criar um channel | ch := make(chan int) |
| Channel com buffer | ch := make(chan int, 5) |
| Enviar para um channel | ch <- 42 |
| Receber de um channel | v := <-ch |
| Fechar um channel | close(ch) |
| Range sobre um channel | for v := range ch { ... } |
| Select em channels | select { case v := <-ch: ...; default: ... } |
| Wait group | var wg sync.WaitGroup; wg.Add(1); wg.Wait() |
| Mutex | var mu sync.Mutex; mu.Lock(); mu.Unlock() |
Tratamento de erros
Go retorna erros como valores - não há exceções.
| Operação | Sintaxe |
|---|---|
| Retornar um erro | func read() (string, error) { return "", err } |
| Verificar um erro | if err != nil { return err } |
| Criar um erro | errors.New("not found") |
| Erro formatado | fmt.Errorf("bad id %d", id) |
| Envolver um erro | fmt.Errorf("load: %w", err) |
| Desembrulhar / comparar | errors.Is(err, os.ErrNotExist) |
| Comparar por tipo | errors.As(err, &target) |
| Panic / recover | defer func() { recover() }() |
A sintaxe de Go que você mais usa, em uma única página. Esta folha de consulta Go é uma referência rápida para o núcleo da linguagem - variáveis e tipos, slices e maps, structs e interfaces, além das goroutines e channels que fazem o Golang brilhar em concorrência.
Tudo aqui é Go padrão e compila com a toolchain oficial. Copie o que precisar ou teste cada trecho ao vivo no playground de Go - sem necessidade de instalação.
Perguntas frequentes sobre a folha de consulta Go
Esta folha de consulta Go é gratuita?
Sim. Esta folha de consulta Go é totalmente gratuita, sem necessidade de cadastro. Salve nos favoritos e volte sempre que precisar consultar uma operação de slice, um padrão de channel ou um método de struct.
Qual é a diferença entre := e var em Go?
var x = 0 declara uma variável e funciona em qualquer lugar, inclusive no nível do pacote. x := 0 é a declaração curta de variável: ela declara e atribui, infere o tipo, e só pode ser usada dentro de uma função. Use var quando precisar de um tipo explícito ou de uma variável de nível de pacote, e := para declarações locais concisas.O que são goroutines e channels?
Uma goroutine é uma thread leve gerenciada pelo runtime do Go - você inicia uma escrevendo
go someFunc(). Channels são pipes tipados que permitem que goroutines se comuniquem com segurança: uma goroutine envia com ch <- v e outra recebe com <-ch. Juntos, eles formam o modelo de concorrência central do Go, resumido pelo lema "compartilhe memória comunicando-se".Posso praticar Go online?
Sim. Abra o playground de Go para executar qualquer trecho desta folha de consulta no seu navegador - sem toolchain do Go para instalar. Quando quiser estrutura, o curso interativo e gratuito de Go da Coddy leva você passo a passo de variáveis e slices a goroutines e channels.
Esta folha de consulta é boa para iniciantes?
Sim. Ela está organizada dos tópicos mais comuns (variáveis, controle de fluxo, funções) até os avançados (goroutines, channels, tratamento de erros), de modo que você pode usar as seções de cima já no primeiro dia e ir avançando para o resto.
Recursos relacionados
Mais folhas de consulta
