Cheatsheet Go: Sintaxe Básica
Este cheatsheet é a cola rápida da sintaxe Go em português: variáveis, tipos, operadores, if/for, funções, ponteiros e defer, com exemplos prontos para copiar. Use a tabela abaixo para achar a forma e os programas completos de cada seção para testar. Para um tutorial passo a passo, veja Go para Iniciantes ou Primeiros Passos com Go.
Cola rápida de sintaxe Go
Os fragmentos desta tabela pressupõem que as variáveis e funções usadas já existem; os exemplos completos aparecem nas seções correspondentes.
| Quero… | Sintaxe para consultar | Referência |
|---|---|---|
| Declarar uma variável dentro de uma função | nome := "Ana" | Variáveis |
| Declarar com tipo e valor zero | var total int | Variáveis |
| Definir uma constante | const porta = 8080 | Constantes |
| Converter um número explicitamente | float64(total) | Conversões |
| Comparar e combinar condições | total > 0 && ativo | Operadores |
| Tratar um erro | if err != nil { return err } | Controle de fluxo |
| Repetir com contador | for i := 0; i < 3; i++ { fmt.Println(i) } | For |
| Percorrer um slice | for i, v := range valores { fmt.Println(i, v) } | For |
| Declarar uma função | func soma(a, b int) int { return a + b } | Funções |
| Acessar um valor por ponteiro | p := &total; *p = 10 | Ponteiros |
| Adiar o fechamento de um arquivo | defer f.Close() | Defer |
Para estruturas de dados e concorrência, consulte os cheatsheets de slices, maps e structs e goroutines e channels.
Variáveis
| Forma | Sintaxe | Onde funciona |
|---|---|---|
| Declaração explícita | var nome string = "Ana" | Qualquer escopo |
| Tipo inferido | var idade = 30 | Qualquer escopo |
| Declaração curta | nome := "Ana" | Apenas dentro de funções |
| Múltiplas | var a, b int = 1, 2 | Qualquer escopo |
| Bloco var | var ( ... ) | Qualquer escopo |
| Zero value | var x int → 0 | Qualquer escopo |
package main
import "fmt"
func main() {
// Declaração curta (mais comum)
nome := "Go"
versao := 1.26
// Declaração explícita
var ativo bool = true
// Bloco de variáveis
var (
host string = "localhost"
porta int = 8080
)
fmt.Println(nome, versao, ativo, host, porta)
}
O zero value é o valor padrão de cada tipo: 0 para numéricos, "" para strings, false para bool e nil para ponteiros, slices, maps, channels e interfaces. Veja a regra de inicialização na especificação.
Constantes
package main
import "fmt"
const Pi = 3.14159
const (
StatusOK = 200
StatusNotFound = 404
)
// iota: enumerador auto-incrementado
const (
Domingo = iota // 0
Segunda // 1
Terca // 2
Quarta // 3
)
func main() {
fmt.Println(Pi, StatusOK, Domingo, Segunda)
}
Constantes em Go são avaliadas em tempo de compilação. Veja constantes na especificação para mais detalhes.
Tipos de Dados
Tipos Numéricos
| Tipo | Tamanho | Faixa |
|---|---|---|
int8 | 8 bits | -128 a 127 |
int16 | 16 bits | -32.768 a 32.767 |
int32 | 32 bits | -2³¹ a 2³¹-1 |
int64 | 64 bits | -2⁶³ a 2⁶³-1 |
int | 32 ou 64 bits | Depende da plataforma |
uint8 (byte) | 8 bits | 0 a 255 |
uint16 | 16 bits | 0 a 65.535 |
uint32 | 32 bits | 0 a 2³²-1 |
uint64 | 64 bits | 0 a 2⁶⁴-1 |
float32 | 32 bits | IEEE-754 |
float64 | 64 bits | IEEE-754 |
complex64 | 64 bits | float32 + float32 |
complex128 | 128 bits | float64 + float64 |
Outros Tipos Básicos
| Tipo | Descrição |
|---|---|
bool | true ou false |
string | Sequência imutável de bytes; não necessariamente UTF-8 válido |
byte | Alias para uint8 |
rune | Alias para int32, representa um code point Unicode |
Veja mais sobre runes e tipos numéricos e strings na especificação. As faixas numéricas e a definição de string seguem a especificação oficial de tipos Go.
Conversões explícitas
Go não converte automaticamente uma variável int em float64. Use T(valor) para uma conversão permitida entre tipos. Para obter uma divisão fracionária de dois inteiros, converta antes de dividir:
package main
import "fmt"
func main() {
a, b := 10, 3
fmt.Println(a / b) // 3: divisão inteira
fmt.Println(float64(a) / float64(b)) // 3.3333333333333335
fmt.Println(float64(a / b)) // 3: a parte fracionária já foi perdida
}
Converter um número para string não é o mesmo que formatá-lo em decimal: para isso, use strconv.Itoa ou fmt.Sprintf, como no cheatsheet de strings e formatação. Referências: conversões e operadores aritméticos.
Operadores
Aritméticos
| Operador | Descrição | Exemplo |
|---|---|---|
+ | Soma | 5 + 3 → 8 |
- | Subtração | 5 - 3 → 2 |
* | Multiplicação | 5 * 3 → 15 |
/ | Divisão | 10 / 3 → 3 (inteiros) |
% | Módulo | 10 % 3 → 1 |
Comparação
| Operador | Descrição |
|---|---|
== | Igual |
!= | Diferente |
<, > | Menor / Maior |
<=, >= | Menor ou igual / Maior ou igual |
Lógicos
| Operador | Descrição |
|---|---|
&& | E (AND) |
|| | OU (OR) |
! | NÃO (NOT) |
Bitwise
| Operador | Descrição |
|---|---|
& | AND |
| | OR |
^ | XOR |
<< | Shift left |
>> | Shift right |
&^ | AND NOT (bit clear) |
Controle de Fluxo
if / else
package main
import "fmt"
func main() {
x := 42
if x > 0 {
fmt.Println("positivo")
} else if x < 0 {
fmt.Println("negativo")
} else {
fmt.Println("zero")
}
// if com inicialização (idiomático em Go)
if v := calcular(); v > 100 {
fmt.Println("acima de 100:", v)
}
}
func calcular() int { return 150 }
O padrão if err != nil é a base do tratamento de erros em Go. Veja também os erros comuns para referência.
switch
package main
import "fmt"
func main() {
dia := "terça"
switch dia {
case "segunda", "terça", "quarta", "quinta", "sexta":
fmt.Println("dia útil")
case "sábado", "domingo":
fmt.Println("fim de semana")
default:
fmt.Println("dia inválido")
}
// Switch sem expressão (substitui if/else if)
nota := 85
switch {
case nota >= 90:
fmt.Println("A")
case nota >= 80:
fmt.Println("B")
case nota >= 70:
fmt.Println("C")
default:
fmt.Println("F")
}
}
Em Go, cada case tem break implícito. Use fallthrough se precisar continuar para o próximo case.
for (o único loop)
package main
import "fmt"
func main() {
// for clássico
for i := 0; i < 5; i++ {
fmt.Print(i, " ")
}
// estilo "while"
n := 1
for n < 100 {
n *= 2
}
// loop infinito
// for { break }
// range sobre slice
frutas := []string{"maçã", "banana", "uva"}
for i, fruta := range frutas {
fmt.Printf("%d: %s\n", i, fruta)
}
// range ignorando índice
for _, fruta := range frutas {
fmt.Println(fruta)
}
}
Para iterar sobre maps e channels, veja o cheatsheet de slices, maps e structs e o cheatsheet de concorrência.
Funções
package main
import (
"errors"
"fmt"
)
// Função simples
func soma(a, b int) int {
return a + b
}
// Múltiplos retornos (idiomático para erros)
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 limites(nums []int) (min, max int) {
min, max = nums[0], nums[0]
for _, n := range nums {
if n < min {
min = n
}
if n > max {
max = n
}
}
return
}
// Variadic (número variável de argumentos)
func somaAll(nums ...int) int {
total := 0
for _, n := range nums {
total += n
}
return total
}
// Função como valor
var dobro = func(x int) int { return x * 2 }
func main() {
fmt.Println(soma(3, 4))
fmt.Println(divide(10, 3))
fmt.Println(limites([]int{3, 1, 4, 1, 5}))
fmt.Println(somaAll(1, 2, 3, 4, 5))
fmt.Println(dobro(21))
}
Funções em Go são cidadãs de primeira classe — podem ser atribuídas a variáveis, passadas como argumentos e retornadas de outras funções. Veja tipos de função na especificação.
Ponteiros
package main
import "fmt"
func main() {
x := 42
p := &x // p é um ponteiro para x
fmt.Println(*p) // 42 — desreferencia o ponteiro
*p = 100
fmt.Println(x) // 100 — x foi alterado via ponteiro
}
func incrementar(val *int) {
*val++
}
| Operação | Sintaxe | Descrição |
|---|---|---|
| Endereço | &x | Obtém ponteiro para x |
| Desreferência | *p | Acessa valor apontado |
| Tipo ponteiro | *int | Ponteiro para int |
| Zero value | nil | Ponteiro não inicializado |
Cuidado com o nil pointer dereference — um dos erros mais comuns em Go. Veja também tipos de ponteiro na especificação.
Defer
package main
import (
"fmt"
"os"
)
func main() {
f, err := os.Open("arquivo.txt")
if err != nil {
fmt.Println(err)
return
}
defer f.Close() // executa quando main() retorna
// usar f normalmente...
}
defer empilha chamadas (LIFO) e é essencial para liberar recursos. Veja defer na especificação e panic/recover para tratamento avançado.
Pacotes e Imports
package main
import (
"fmt"
"math"
"strings"
)
func main() {
fmt.Println(math.Sqrt(16))
fmt.Println(strings.ToUpper("hello"))
}
| Sintaxe | Descrição |
|---|---|
import "fmt" | Import simples |
import ( ... ) | Import agrupado |
import . "fmt" | Importa tudo para o escopo atual |
import _ "pkg" | Importa apenas pelo side effect (init) |
import alias "pkg" | Importa com alias |
Variáveis locais e imports não usados causam erro de compilação; funções e variáveis no nível do pacote podem existir sem ser usadas. Veja declared and not used e undefined variable.
Para gerenciar dependências, veja o guia de Go Modules e Go Modules na prática. Se quiser comparar a sintaxe de Go com outras linguagens de sistemas, confira os guias de Rust e Zig.
Armadilhas comuns da sintaxe
| Situação | Regra prática | Fonte oficial |
|---|---|---|
x := 1 seguido de x := 2 no mesmo bloco | Use x = 2: := exige pelo menos uma variável nova que não seja _; um bloco interno pode declarar outro x e ocultar o externo. | Declaração curta |
Somar variáveis int e int64 | Faça uma conversão explícita, como int64(x) + y; considere a faixa do tipo de destino. | Operadores |
Chamar limites com slice vazio | O exemplo acima exige ao menos um elemento: nums[0] causa panic se len(nums) == 0. Valide a entrada antes da chamada. | Indexação |
Desreferenciar um ponteiro nil | Verifique o ponteiro antes de acessar *p; a desreferência de nil causa panic. | Operadores de endereço |
Esperar que defer execute ao sair de um if | A chamada ocorre quando a função retorna, não quando o bloco termina; seus argumentos são avaliados no momento do defer. | Defer |
Fontes oficiais para conferir a sintaxe
- Especificação da linguagem Go — tipos, declarações, operadores e regras de compilação.
- A Tour of Go: variáveis e funções — exercícios interativos dos fundamentos.
- A Tour of Go: controle de fluxo —
for,if,switchedefer. - Documentação do comando gofmt — formatação do código Go.
Veja Também
- Cheatsheet: Concorrência — Goroutines, channels e sync
- Cheatsheet: Slices, Maps e Structs — Estruturas de dados
- Cheatsheet: Strings e Formatação — fmt, strconv e strings
- Cheatsheet: Testes e Debug — Testing e profiling
- Como Aprender Go — Guia completo de estudo
- Roadmap Go 2026 — Caminho de aprendizagem