Fundamentos Básicos de Go

10 exemplos para você começar com os Fundamentos de Go - 7 básicos e 3 intermediários.

Pré-requisitos

• Instale Go 1.26.x ou posterior em go.dev/dl.
• Crie um módulo: mkdir hello && cd hello && go mod init example.com/hello.
• Execute qualquer trecho com go run . após salvá-lo como main.go nesse diretório.

Exemplos Básicos

1. Olá, main

O menor executável: um pacote main com func main().

package main
 
import "fmt"
 
func main() {
    fmt.Println("olá, Go")
}

• package main marca um executável, não uma biblioteca.
• import "fmt" traz o pacote de E/S formatada da biblioteca padrão.
• go run . compila e executa sem deixar um binário no diretório.

Relacionado: Como Programas Go São Estruturados - pacotes, linking e a toolchain

2. Variáveis e declaração curta

Declare com var ou use := dentro de funções.

package main
 
import "fmt"
 
func main() {
    var name string = "Go"
    year := 2009
    fmt.Println(name, year)
}

• := infere o tipo e só pode aparecer dentro de funções.
• var funciona no nível do pacote; := não.
• Variáveis não utilizadas são erros de compilação - Go impõe locais limpos.

Relacionado: Variáveis, Constantes e Escopo - estilos de declaração e regras de escopo

3. Valores zero

Variáveis recebem um padrão sem inicialização explícita.

package main
 
import "fmt"
 
func main() {
    var count int
    var ready bool
    var label string
    fmt.Printf("int=%d bool=%t string=%q\n", count, ready, label)
}

• Tipos numéricos padrão para 0, bool para false, strings para "".
• Ponteiros, slices, maps, channels e interfaces padrão para nil.
• Confie em valores zero para estados sentinela "vazios" quando for idiomático.

Relacionado: Valores Zero e Inicialização - padrões por tipo e padrões de inicialização

4. Constantes e iota

Nomes const são valores em tempo de compilação; iota constrói constantes enumeradas.

package main
 
import "fmt"
 
const (
    Sunday = iota
    Monday
    Tuesday
)
 
func main() {
    fmt.Println(Sunday, Monday, Tuesday) // 0 1 2
}

• iota reinicia para 0 em cada bloco const e incrementa por linha.
• Constantes devem ser expressáveis em tempo de compilação (sem chamadas de tempo de execução).
• Use constantes tipadas quando precisar de um tipo distinto, não apenas um número não tipado.

Relacionado: Variáveis, Constantes e Escopo - padrões iota e escopo

5. Tipos básicos e iteração de string

Strings são sequências de bytes UTF-8; itere por rune com range.

package main
 
import "fmt"
 
func main() {
    s := "café"
    for i, r := range s {
        fmt.Printf("%d: %U\n", i, r)
    }
}

• range sobre uma string retorna o índice de byte e o rune (int32), não o offset de byte para caracteres multibyte.
• len(s) conta bytes, não runes.
• Use []rune(s) quando precisar de acesso aleatório por índice de caractere.

Relacionado: Tipos Numéricos, Strings, Runes e Slices de Bytes - UTF-8, runes e conversões

6. Slices

Slices são visualizações dinâmicas sobre um array subjacente.

package main
 
import "fmt"
 
func main() {
    nums := []int{1, 2, 3}
    nums = append(nums, 4)
    fmt.Println(nums, len(nums), cap(nums))
}

• append pode alocar um novo array subjacente quando a capacidade é excedida.
• len é a contagem de elementos; cap é o tamanho do array subjacente a partir do cabeçalho do slice.
• Um slice nil é válido e funciona com append e range.

Relacionado: Arrays, Slices e Maps em Resumo - len/cap e compartilhamento

7. Maps

Maps são tabelas hash com chaves de tipos comparáveis.

package main
 
import "fmt"
 
func main() {
    ages := map[string]int{"ada": 36}
    ages["linus"] = 55
    if v, ok := ages["grace"]; ok {
        fmt.Println(v)
    } else {
        fmt.Println("grace: desconhecido")
    }
}

• A forma de dois valores v, ok := m[key] distingue chaves ausentes de valores zero.
• Maps devem ser inicializados com make ou um literal antes da atribuição.
• A ordem de iteração é aleatória - não dependa da ordem das chaves.

Relacionado: Arrays, Slices e Maps em Resumo - iteração de map e armadilhas

Exemplos Intermediários

8. Structs e embedding

Agrupe campos em uma struct; use embedding para promover métodos e campos.

package main
 
import "fmt"
 
type Person struct{ Name string }
type Employee struct {
    Person
    ID int
}
 
func main() {
    e := Employee{Person: Person{Name: "Grace"}, ID: 1}
    fmt.Println(e.Name, e.ID) // campo promovido
}

• Campos embutidos são promovidos para o namespace do tipo externo.
• Embedding é composição, não herança clássica.
• Use nomes de campo explícitos quando a promoção for ambígua.

Relacionado: Structs, Embedding e Promoção de Campos - modelagem e regras de promoção

9. Ponteiros

& obtém um endereço; * desreferencia. Métodos podem usar receptores de ponteiro para mutar.

package main
 
import "fmt"
 
type Counter struct{ n int }
 
func (c *Counter) Inc() { c.n++ }
 
func main() {
    c := &Counter{}
    c.Inc()
    fmt.Println(c.n)
}

• Go passa structs por valor, a menos que você passe um ponteiro.
• Receptores de ponteiro evitam copiar structs grandes e permitem mutação.
• Ponteiros nil causam pânico na desreferenciação - verifique antes de usar.

Relacionado: Ponteiros e o Operador de Endereço - quando ponteiros ajudam vs. atrapalham

10. Esboço de layout de pacote

Separe main de código reutilizável em pacotes dentro do mesmo módulo.

// main.go
package main
 
import "example.com/hello/greet"
 
func main() {
    greet.Hello("world")
}

// greet/greet.go
package greet
 
import "fmt"
 
func Hello(name string) {
    fmt.Printf("olá, %s\n", name)
}

• Apenas pacotes main criam executáveis; greet é um pacote de biblioteca.
• Nomes exportados começam com maiúscula (Hello); minúsculas permanecem privadas.
• Execute a partir da raiz do módulo: go run . com ambos os arquivos no lugar.

Relacionado: Como Programas Go São Estruturados - módulos, imports e internal/

Links Externos Relacionados

• A Tour of Go - Introdução interativa oficial ao Go.
• Tutoriais Go (Oficial) - Tutoriais oficiais em várias partes.
• Go Playground - Editor e executor online oficial.
• Get Programming with Go (Manning) - Nathan Youngman & Roger Peppé.
• The Go Programming Language (ebook) - Donovan & Kernighan.

Versões de Stack: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação). NzA2MjAyfDI3NG9pZ2N8b2kuc2VkaXVnZWRvYw==