os, io, bufio y path/filepath

La E/S de archivos y flujos en Go organiza pequeñas interfaces en canalizaciones componibles.

os habla con el sistema de archivos, io define el movimiento de bytes, bufio reduce la sobrecarga de llamadas al sistema y path/filepath construye rutas portátiles.

Resumen

La mayoría de los programas de Go leen configuraciones, sirven cargas o canalizan datos entre procesos.

La biblioteca estándar modela todo eso como implementaciones de io.Reader y io.Writer.

os.Open devuelve un *os.File que puedes pasar a io.Copy, bufio.NewScanner o json.NewDecoder.

Las herramientas multiplataforma nunca deben codificar / o \ de forma rígida; filepath.Join elige el separador correcto.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

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
}

Cuándo usar esto:

• Leer o escribir archivos y directorios en disco.
• Transmitir datos entre cuerpos HTTP, compresores y hashers sin cargar todo en RAM.
• Escanear registros o texto estilo CSV línea por línea con bufio.Scanner.
• Construir rutas de archivos que funcionen en Linux, macOS y Windows.

Ejemplo de Trabajo

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("crear 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("líneas escritas:", n)
}

Lo que esto demuestra:

• filepath.Clean y filepath.Join para ensamblar rutas de forma segura.
• os.MkdirAll antes de crear archivos de salida anidados.
• bufio.Scanner para iteración de línea y bufio.Writer para escrituras por lotes.
• Cierre diferido con captura de errores en el archivo de destino.

Inmersión Profunda

Cómo Funciona

• io.Copy lee de cualquier Reader y escribe en cualquier Writer utilizando un grupo de búferes interno.
• Las lecturas y escrituras de *os.File se mapean a descriptores de archivo del sistema operativo; los desplazamientos se rastrean por identificador.
• bufio.Reader y bufio.Writer envuelven flujos para agrupar llamadas al sistema.
• filepath opera sobre rutas como cadenas; no accede al sistema de archivos (usa os para eso).

Roles de los Paquetes

Notas de Go

// Prefiere io.Copy sobre bucles Read manuales para canalizar.
// Limita las cargas para evitar el agotamiento de memoria:
limited := io.LimitReader(r.Body, 1<<20) // Límite de 1 MiB
 
// Recorre árboles de directorios 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
    }
    // procesar archivo
    return nil
})

Trampas Comunes

• Olvidar cerrar archivos - Las fugas de descriptores agotan los límites del proceso bajo carga. Solución: defer f.Close() y propagar errores de cierre en los escritores.
• Usar path en lugar de path/filepath - path es para rutas con barras inclinadas hacia adelante, similares a las URL, no para rutas del sistema de archivos de Windows. Solución: importar path/filepath para rutas del SO.
• Ignorar Scanner.Err() - El bucle termina silenciosamente en errores de E/S. Solución: verificar sc.Err() después de for sc.Scan().
• Líneas enormes con el búfer predeterminado de Scanner - Errores de token demasiado largo en líneas muy largas. Solución: sc.Buffer(make([]byte, 0, 64*1024), maxToken).
• Asumir que Read llena el búfer - Read puede devolver n < len(buf) con un error nil. Solución: bucle hasta io.EOF o usar io.ReadFull.
• TOCTOU con os.Stat y luego os.Open - El archivo puede cambiar entre verificaciones. Solución: abrir primero, luego validar el contenido o usar bloqueos de archivos cuando sea necesario.

Alternativas

Preguntas Frecuentes

Relacionados

• Conceptos Básicos de la Biblioteca Estándar - Ejemplos introductorios de E/S y JSON
• La Biblioteca Estándar de Go: Baterías Incluidas - Filosofía de composición
• log, regexp y text/template - Procesamiento de texto después de leer archivos
• crypto/*, compress y math/rand/v2 - Flujos de hash y compresión
• net/http: La Pila HTTP de Go con Baterías Incluidas - Cuerpos HTTP como io.Reader

Versiones de Stack: Esta página fue escrita para Go 1.26.x (GC predeterminado de Green Tea, go fix modernizers - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación) y golangci-lint (última - verificar conjunto de linters en la compilación).