Folha de consulta de Go
Uma referência de Go pesquisável e imprimível: structs, slices, maps, interfaces, encapsulamento de erros, goroutines, canais, genéricos e a CLI go. Grátis.
Basics
10package main
Executable entry package
import ("fmt"; "os")
Import standard packages
x := 42
Short declare (inside funcs only)
var s string
Zero value: "" (0, nil, false)
const MaxRetries = 3
Typed or untyped constant
const (A = iota; B; C)
Auto-incrementing enum values
a, b = b, a
Multiple assignment / swap
_, err := doWork()
Blank identifier discards values
fmt.Println("hi"); fmt.Printf("%v\n", x)
Print values (%v = default)
fmt.Sprintf("%s-%d", name, id)
Format into a string
Types, structs & methods
10type User struct { Name string; Age int }
Struct definition
u := User{Name: "Sam", Age: 30}
Struct literal (named fields)
u.Name = "Alex"
Field access / mutation
func (u User) Label() string
Value receiver (reads only)
func (u *User) Rename(n string)
Pointer receiver (mutates)
func NewUser(n string) *User
Constructor function idiom
type Admin struct { User; Level int }
Embedding: fields promoted
type UserID int
Named type (own method set)
Name string `json:"name,omitempty"`
Struct tag for encoding
p := &User{}; p.Name = "x"
Auto-deref through pointers
Slices & maps
13s := []int{1, 2, 3}
Slice literal
s = make([]int, 0, 10)
Empty slice with capacity 10
s = append(s, 4, 5)
Append (reassign the result)
n := copy(dst, src)
Copy elements between slices
s[1:3]
Sub-slice (shares the array)
len(s), cap(s)
Length and capacity
var s []int; s = append(s, 1)
Appending to nil is fine
m := map[string]int{"a": 1}
Map literal
v, ok := m["key"]
Lookup with existence check
delete(m, "key")
Remove a key
for k, v := range m { ... }
Iterate (order is random)
slices.Contains(s, 3)
Search helper (Go 1.21+)
slices.Sort(s); maps.Keys(m)
slices / maps packages
Control flow
10for i := 0; i < n; i++ { ... }
Classic for (the only loop)
for i, v := range items { ... }
Index + value iteration
for cond { ... }
While-style loop
for { ... }
Infinite loop (break to exit)
for i := range 10 { ... }
Range over int (Go 1.22+)
if err := load(); err != nil { ... }
If with init statement
switch status { case "on": ... default: ... }
No fallthrough by default
switch { case n > 10: ... }
Condition-less switch chain
switch v := x.(type) { case int: ... }
Type switch
outer: for { break outer }
Labeled break / continue
Functions & defer
9func add(a, b int) int { return a + b }
Basic function
func load() ([]byte, error)
Multiple return values
func div(a, b int) (q int, err error)
Named return values
func sum(ns ...int) int
Variadic; call sum(s...)
defer f.Close()
Run at function exit
defer mu.Unlock() // LIFO order
Multiple defers run in reverse
counter := func() int { n++; return n }
Closure captures variables
type Handler func(w, r)
Function type declaration
apply(items, strings.ToUpper)
Functions are first-class values
Interfaces & type assertions
10type Stringer interface { String() string }
Interface: a method set
// no "implements" keyword
Satisfaction is implicit
io.Reader / io.Writer
The ubiquitous stream duo
var x any = 42
any = interface{} (anything)
s, ok := x.(string)
Type assertion (safe form)
switch v := x.(type) { case string: ... }
Branch by dynamic type
type ReadCloser interface { Reader; Closer }
Interface embedding
func Save(w io.Writer, u User) error
Accept interfaces...
func NewStore() *Store
...return concrete structs
var _ Stringer = (*User)(nil)
Compile-time conformance check
Error handling
10if err != nil { return err }
The fundamental pattern
errors.New("not found")
Simple error value
fmt.Errorf("load %s: %w", path, err)
Wrap with context (%w)
errors.Is(err, os.ErrNotExist)
Match a sentinel in the chain
var pe *fs.PathError; errors.As(err, &pe)
Extract a typed error
var ErrNotFound = errors.New("not found")
Exported sentinel error
func (e *ValidationError) Error() string
Custom error type
errors.Join(err1, err2)
Combine multiple errors
defer func() { recover() }()
Recover from a panic
panic("unreachable")
Only for programmer errors
Goroutines & channels
12go work()
Start a goroutine
ch := make(chan int)
Unbuffered (synchronous) channel
ch := make(chan int, 10)
Buffered channel
ch <- v / v := <-ch
Send / receive
close(ch); for v := range ch { ... }
Drain until closed
select { case v := <-a: ... case b <- x: ... }
Wait on multiple channels
var wg sync.WaitGroup; wg.Add(1); wg.Wait()
Wait for goroutines
defer wg.Done()
Signal completion
for job := range jobs { results <- run(job) }
Worker pool body
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
Deadline for downstream work
select { case <-ctx.Done(): return ctx.Err() }
Abort on cancellation
var mu sync.Mutex; mu.Lock(); defer mu.Unlock()
Guard shared state
Generics
9func Map[T, U any](s []T, f func(T) U) []U
Generic function
func Keys[K comparable, V any](m map[K]V) []K
comparable: map-key types
type Number interface { ~int | ~float64 }
Union constraint (~ = derived)
func Sum[T Number](ns []T) T
Use a custom constraint
type Stack[T any] struct { items []T }
Generic type
s := Stack[int]{}
Explicit instantiation
doubled := Map(nums, double)
Type args usually inferred
func Min[T cmp.Ordered](a, b T) T
cmp.Ordered: < > comparable
min(a, b), max(a, b)
Builtins since Go 1.21
Standard library gems
14strings.Split(s, ","); strings.Join(parts, "-")
Split and join
strings.Contains, HasPrefix, TrimSpace
Everyday string helpers
n, err := strconv.Atoi("42")
String → int (Itoa reverses)
time.Now(); time.Since(start)
Current time and elapsed
t.Format("2006-01-02 15:04")
Reference-date layout
time.Sleep(200 * time.Millisecond)
Pause the goroutine
data, err := os.ReadFile("cfg.json")
Read a whole file
os.WriteFile(path, data, 0o644)
Write a file with perms
os.Getenv("HOME"); filepath.Join(dir, f)
Env vars and safe paths
json.Marshal(v); json.Unmarshal(b, &v)
JSON encode / decode
resp, err := http.Get(url); defer resp.Body.Close()
HTTP client call
http.HandleFunc("/", h); http.ListenAndServe(":8080", nil)
Minimal HTTP server
slog.Info("started", "port", 8080)
Structured logging (1.21+)
sc := bufio.NewScanner(f); for sc.Scan()
Read input line by line
Testing & benchmarks
11func TestAdd(t *testing.T) { ... }
Test in *_test.go
t.Errorf("got %d, want %d", got, want)
Fail but keep running
t.Fatalf("setup failed: %v", err)
Fail and stop this test
tests := []struct{ in, want int }{...}
Table-driven test data
t.Run(tc.name, func(t *testing.T) {...})
Named subtests
t.Helper()
Blame the caller in failures
t.Parallel()
Run this test concurrently
func BenchmarkAdd(b *testing.B) { for range b.N { add(1, 2) } }
Benchmark loop
go test -bench=. -benchmem
Run benchmarks + allocations
go test -run TestAdd ./...
Run tests matching a pattern
go test -cover ./...
Coverage summary
Go CLI
11go mod init example.com/app
Start a new module
go mod tidy
Sync go.mod with imports
go get github.com/pkg/x@latest
Add / upgrade a dependency
go run .
Compile and run in one step
go build ./...
Build all packages
go test ./...
Test the whole module
go vet ./...
Static analysis for bugs
gofmt -w .
Format all source files
go install golang.org/x/tools/...@latest
Install a tool binary
GOOS=linux GOARCH=amd64 go build
Cross-compile
go doc strings.Split
Read docs in the terminal
Nenhuma entrada corresponde a “:q”.
Sobre Folha de consulta de Go
Esta folha de referência de Go condensa o Go idiomático numa única página pesquisável: básico, tipos, structs e methods, slices e maps, controlo de fluxo, funções e defer, interfaces e type assertions, tratamento de erros, goroutines e channels, generics, joias da biblioteca padrão, testes e benchmarks, e a linha de comandos go.
Foca-se no que os programadores de Go procuram em vez de memorizar: o truque exato com slices para eliminar um elemento, a diferença entre errors.Is e errors.As, a instrução select com um timeout, um teste table-driven, ou qual comando go faz o quê, com uma breve explicação em cada linha.
A folha é gratuita e executada no lado do cliente: filtre linhas em tempo real com a caixa de pesquisa, salte entre secções com o índice fixo, copie qualquer excerto com um clique e imprima a página para consultar enquanto programa.
Como usar Folha de consulta de Go
- Percorra as secções, desde Básico e Slices & maps até Goroutines & channels e a CLI do Go.
- Pesquise por uma palavra-chave como channel, defer ou errors.Is para filtrar todas as linhas em tempo real.
- Salte para Interfaces ou Generics quando precisar da sintaxe de tipos em vez de um comando.
- Clique num excerto ou no respetivo ícone de cópia para copiar o código Go para a área de transferência.
- Imprima a folha para uma referência de Go offline.
Perguntas frequentes
Doze secções: básico, tipos e structs, slices e maps, controlo de fluxo, funções e defer, interfaces e type assertions, tratamento de erros, goroutines e channels, generics, destaques da biblioteca padrão, testes e benchmarks, e a CLI go.
Sim. Uma secção dedicada cobre goroutines, channels com e sem buffer, select com timeouts, WaitGroup, Mutex e cancelamento por context.
Inclui: parâmetros de tipo, constraints, as constraints comparable e any, e funções e tipos genéricos têm cada um as suas próprias linhas.
Sim. Clique em qualquer excerto ou no seu ícone de cópia ao passar o rato e cai na sua área de transferência com uma breve confirmação.
Sim, completamente gratuita: pesquisável, imprimível e apresentada no seu navegador sem registo.
Pesquisas populares
cheat sheet go
cheat sheet golang
referência de sintaxe go
slices e maps em go
goroutines e channels
tratamento de erros em go
comandos cli go
Precisa de ajuda?
Encontrou um problema com esta ferramenta? Avise a nossa equipa.