Noções Básicas da Biblioteca Padrão

10 exemplos para você começar com a Biblioteca Padrão - 7 básicos e 3 intermediários.

Pré-requisitos

• Instale o Go 1.26.x ou posterior em go.dev/dl.
• Crie um módulo: mkdir stdlib && cd stdlib && go mod init example.com/stdlib.
• Salve cada trecho como main.go (ou um arquivo de teste onde indicado) e execute com go run . ou go test.
• Pacotes da biblioteca padrão não precisam de go get; caminhos de importação como "fmt" são resolvidos a partir da toolchain.

Exemplos Básicos

1. Saída formatada com fmt

Imprima valores com formatação padrão.

package main
 
import "fmt"
 
func main() {
    name, count := "widgets", 3
    fmt.Printf("shipped %d %s\n", count, name)
}

• Printf usa tokens de verbo (%d, %s, %v) como formatação estilo C.
• Println adiciona espaços entre os operandos e uma nova linha final.
• Prefira fmt.Errorf com %w ao encapsular erros em código real.

Relacionado: A Biblioteca Padrão do Go: Baterias Incluídas - filosofia da biblioteca padrão

2. Auxiliares de String

Transforme e inspecione strings sem loops manuais.

package main
 
import (
    "fmt"
    "strings"
)
 
func main() {
    s := "  hello, Go  "
    fmt.Println(strings.TrimSpace(s))
    fmt.Println(strings.Contains(s, "Go"))
    fmt.Println(strings.Split("a,b,c", ","))
}

• strings opera em strings de bytes UTF-8; não é consciente de runes para todas as funções.
• TrimSpace remove espaços em branco Unicode, não apenas espaços ASCII.
• Para construção pesada, use strings.Builder em vez de += em loops.

3. Analisar e formatar números

Converta entre strings e tipos numéricos com segurança.

package main
 
import (
    "fmt"
    "strconv"
)
 
func main() {
    n, err := strconv.Atoi("42")
    if err != nil {
        panic(err)
    }
    fmt.Println(n * 2)
 
    s := strconv.FormatFloat(3.14, 'f', 2, 64)
    fmt.Println(s)
}

• Atoi é um atalho para ParseInt(s, 10, 0).
• Sempre trate erros de funções Parse*; entrada inválida é comum em limites de API.
• FormatBool, FormatInt e Itoa cobrem a serialização de saída.

4. Codificar e decodificar JSON

Serializar structs para JSON e vice-versa.

package main
 
import (
    "encoding/json"
    "fmt"
)
 
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}
 
func main() {
    u := User{ID: 1, Name: "Ada"}
    b, _ := json.Marshal(u)
    fmt.Println(string(b))
 
    var decoded User
    _ = json.Unmarshal(b, &decoded)
    fmt.Println(decoded.Name)
}

• Tags de struct controlam nomes de campos JSON e omitempty.
• json.NewEncoder e json.NewDecoder transmitem para io.Writer e io.Reader.
• json.Marshal retorna []byte; não presuma uma ordem de chave particular em comparações.

Relacionado: os, io, bufio & path/filepath - I/O de streaming por trás do JSON

5. Ler um arquivo com os e io

Abra um caminho e leia seu conteúdo.

package main
 
import (
    "fmt"
    "os"
)
 
func main() {
    data, err := os.ReadFile("notes.txt")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(data))
}

• os.ReadFile lê o arquivo inteiro; use streaming para entradas grandes.
• Verifique os.IsNotExist(err) para distinguir arquivos ausentes de erros de permissão.
• Sempre feche recursos abertos com os.Open quando não estiver usando ReadFile.

6. Copiar streams com io

Mova bytes entre leitores e escritores.

package main
 
import (
    "bytes"
    "fmt"
    "io"
    "strings"
)
 
func main() {
    src := strings.NewReader("hello stream")
    var dst bytes.Buffer
    n, err := io.Copy(&dst, src)
    if err != nil {
        panic(err)
    }
    fmt.Println(n, dst.String())
}

• io.Copy faz buffer internamente; raramente você precisa de slices de bytes manuais para trabalho estilo pipe.
• io.ReadAll drena um leitor para a memória; combine com limites de tamanho em servidores.
• Muitos tipos da biblioteca padrão implementam io.Reader ou io.Writer.

7. Escanear linha por linha um arquivo com bufio

Leia entrada linha por linha com memória mínima.

package main
 
import (
    "bufio"
    "fmt"
    "strings"
)
 
func main() {
    s := "line1\nline2\nline3\n"
    sc := bufio.NewScanner(strings.NewReader(s))
    for sc.Scan() {
        fmt.Println(sc.Text())
    }
    if err := sc.Err(); err != nil {
        panic(err)
    }
}

• Scanner divide por padrão em novas linhas; ScanLines é a função de divisão padrão.
• Verifique sc.Err() após o loop; Scan retorna false em EOF e em erros.
• Para análise delimitada por tokens (campos CSV), use sc.Split com uma função personalizada.

Relacionado: log, regexp & text/template - pacotes de processamento de texto

Exemplos Intermediários

8. Timers e relógio monotônico

Meça o tempo decorrido sem distorção do relógio de parede.

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    start := time.Now()
    time.Sleep(50 * time.Millisecond)
    fmt.Println(time.Since(start))
}

• time.Since usa uma leitura monotônica quando disponível, então saltos de horário de verão não distorcem durações.
• time.ParseDuration aceita strings como "300ms" e "5m".
• Armazene instantes como time.Time, não inteiros Unix, a menos que esteja serializando entre sistemas.

Relacionado: Integração de time, timezones & context - locais e prazos

9. Timeout de contexto

Cancele o trabalho quando um prazo expirar.

package main
 
import (
    "context"
    "fmt"
    "time"
)
 
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()
 
    select {
    case <-time.After(200 * time.Millisecond):
        fmt.Println("finished")
    case <-ctx.Done():
        fmt.Println("canceled:", ctx.Err())
    }
}

• Sempre chame cancel() para liberar recursos do timer, geralmente com defer.
• Passe ctx como o primeiro parâmetro para funções que podem bloquear.
• context.WithCancel é apropriado quando um evento externo (desconexão do cliente) deve parar o trabalho.

10. Servidor HTTP mínimo

Sirva HTTP com os padrões de net/http.

package main
 
import (
    "fmt"
    "net/http"
)
 
func main() {
    http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "hello")
    })
    fmt.Println("listening :8080")
    http.ListenAndServe(":8080", nil)
}

• http.HandleFunc registra no http.DefaultServeMux; código de produção frequentemente usa http.NewServeMux.
• ListenAndServe bloqueia; configure timeouts em http.Server antes de implantações de produção.
• Funções de handler recebem ResponseWriter e *Request; verifique o método e o caminho internamente.

Relacionado: Visão Geral da Família de Pacotes database/sql & net - família de pacotes net | net/http: A Pilha HTTP de Baterias Incluídas do Go - modelo HTTP completo

Versões da 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).