os, io, bufio & path/filepath

A E/S de arquivos e streams em Go organiza pequenas interfaces em pipelines compostos.

os fala com o sistema de arquivos, io define o movimento de bytes, bufio reduz a sobrecarga de chamadas de sistema, e path/filepath constrói caminhos portáteis.

Resumo

A maioria dos programas Go lê configurações, serve uploads ou canaliza dados entre processos.

A biblioteca padrão modela tudo isso como implementações de io.Reader e io.Writer.

os.Open retorna um *os.File que você pode passar para io.Copy, bufio.NewScanner ou json.NewDecoder.

Ferramentas multiplataforma nunca devem codificar / ou \ em hardcode; filepath.Join escolhe o separador correto.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

path := filepath.Join("data", "input.txt")
f, err := os.Open(path)
if err != nil {
    return err
}
defer f.Close()
 
var out bytes.Buffer
if _, err := io.Copy(&out, f); err != nil {
    return err
}

Quando usar isso:

• Lendo ou escrevendo arquivos e diretórios no disco.
• Transmitindo dados entre corpos HTTP, compressores e hashers sem carregar tudo na RAM.
• Analisando logs ou texto estilo CSV linha por linha com bufio.Scanner.
• Construindo caminhos de arquivo que funcionam em Linux, macOS e Windows.

Exemplo de Trabalho

package main
 
import (
    "bufio"
    "fmt"
    "io"
    "os"
    "path/filepath"
    "strings"
)
 
func copyFiltered(srcPath, dstPath, prefix string) (int, error) {
    srcPath = filepath.Clean(srcPath)
    dstPath = filepath.Clean(dstPath)
 
    src, err := os.Open(srcPath)
    if err != nil {
        return 0, fmt.Errorf("abrir src: %w", err)
    }
    defer src.Close()
 
    if err := os.MkdirAll(filepath.Dir(dstPath), 0o755); err != nil {
        return 0, fmt.Errorf("mkdir: %w", err)
    }
 
    dst, err := os.Create(dstPath)
    if err != nil {
        return 0, fmt.Errorf("criar dst: %w", err)
    }
    defer func() {
        if cerr := dst.Close(); cerr != nil && err == nil {
            err = cerr
        }
    }()
 
    scanner := bufio.NewScanner(src)
    writer := bufio.NewWriter(dst)
    defer writer.Flush()
 
    lines := 0
    for scanner.Scan() {
        line := scanner.Text()
        if strings.HasPrefix(line, prefix) {
            if _, err := writer.WriteString(line + "\n"); err != nil {
                return lines, err
            }
            lines++
        }
    }
    if err := scanner.Err(); err != nil {
        return lines, err
    }
    return lines, nil
}
 
func main() {
    n, err := copyFiltered("input.log", filepath.Join("out", "filtered.log"), "ERR")
    if err != nil {
        panic(err)
    }
    fmt.Println("linhas escritas:", n)
}

O que isso demonstra:

• filepath.Clean e filepath.Join para montagem segura de caminhos.
• os.MkdirAll antes de criar arquivos de saída aninhados.
• bufio.Scanner para iteração de linha e bufio.Writer para escritas em lote.
• Fechamento adiado com captura de erro no arquivo de destino.

Mergulho Profundo

Como Funciona

• io.Copy lê de qualquer Reader e escreve em qualquer Writer usando um pool de buffers interno.
• Leituras e escritas de *os.File mapeiam para descritores de arquivo do SO; os deslocamentos são rastreados por manipulador.
• bufio.Reader e bufio.Writer envolvem streams para agrupar chamadas de sistema.
• filepath opera em caminhos como strings; ele não acessa o sistema de arquivos (use os para isso).

Papéis dos Pacotes

Notas Go

// Prefira io.Copy a loops Read manuais para canalização.
// Limite uploads para evitar exaustão de memória:
limited := io.LimitReader(r.Body, 1<<20) // Limite de 1 MiB
 
// Percorre árvores de diretórios de forma portátil:
filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
    if err != nil {
        return err
    }
    if d.IsDir() {
        return nil
    }
    // processa o arquivo
    return nil
})

Armadilhas

• Esquecer de fechar arquivos - Vazamentos de descritores esgotam os limites do processo sob carga. Correção: defer f.Close() e propague erros de fechamento em escritores.
• Usar path em vez de path/filepath - path é para caminhos com barras normais semelhantes a URLs, não para caminhos do sistema de arquivos Windows. Correção: importe path/filepath para caminhos do SO.
• Ignorar Scanner.Err() - O loop termina silenciosamente em erros de E/S. Correção: verifique sc.Err() após for sc.Scan().
• Linhas enormes com buffer Scanner padrão - Erros de token muito longo em linhas muito longas. Correção: sc.Buffer(make([]byte, 0, 64*1024), maxToken).
• Assumir que Read preenche o buffer - Read pode retornar n < len(buf) com erro nil. Correção: repita até io.EOF ou use io.ReadFull.
• TOCTOU com os.Stat e depois os.Open - O arquivo pode mudar entre as verificações. Correção: abra primeiro e depois valide o conteúdo ou use bloqueios de arquivo quando necessário.

Alternativas

FAQs

Relacionados

• Noções Básicas da Biblioteca Padrão - Exemplos introdutórios para E/S e JSON
• A Biblioteca Padrão Go: Baterias Incluídas - Filosofia de composição
• log, regexp & text/template - Processamento de texto após ler arquivos
• crypto/*, compress & math/rand/v2 - Streams de hash e compressão
• net/http: A Pilha HTTP de Baterias Incluídas do Go - Corpos HTTP como io.Reader

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