Sintaxe Básica do Go — Referência Rápida
Esta página é uma referência rápida da sintaxe fundamental do Go. Use como cola para consultas do dia a dia. Para um tutorial passo a passo, veja Go para Iniciantes ou Primeiros Passos com Go.
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 mais em variáveis no glossário.
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 no glossário 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 (padrão) |
complex64 | 64 bits | float32 + float32 |
complex128 | 128 bits | float64 + float64 |
Outros Tipos Básicos
| Tipo | Descrição |
|---|---|
bool | true ou false |
string | Sequência de bytes UTF-8, imutável |
byte | Alias para uint8 |
rune | Alias para int32, representa um code point Unicode |
Veja mais sobre runes e strings no glossário.
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 func no glossário.
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 ponteiros no glossário.
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 no glossário 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 e funções declaradas e não usadas causam erro de compilação — 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.
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