Paquete archive en Go: Guía Completa para Manejo de Archivos Comprimidos

El paquete archive en Go proporciona funciones para trabajar con archivos comprimidos. Este documento explora en detalle los subpaquetes archive/tar y archive/zip, incluyendo ejemplos prácticos de uso y mejores prácticas.

1. Subpaquete archive/tar

1.1 Conceptos Básicos

El formato TAR (Tape Archive) es ampliamente utilizado en sistemas Unix para almacenar múltiples archivos en un solo archivo.

1.2 Funciones Principales

NewReader

Propósito: Crear un lector para archivos TAR.

reader := tar.NewReader(file)

Ejemplo Completo de Lectura:

func readTarFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    tr := tar.NewReader(file)
    for {
        header, err := tr.Next()
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }
        
        fmt.Printf("Contenido del archivo: %s\n", header.Name)
        if _, err := io.Copy(os.Stdout, tr); err != nil {
            return err
        }
    }
    return nil
}

NewWriter

Propósito: Crear un escritor para archivos TAR.

Ejemplo Completo de Creación:

func createTarArchive(files []string, output string) error {
    outFile, err := os.Create(output)
    if err != nil {
        return err
    }
    defer outFile.Close()

    tw := tar.NewWriter(outFile)
    defer tw.Close()

    for _, file := range files {
        err := addToTar(tw, file)
        if err != nil {
            return err
        }
    }
    return nil
}

func addToTar(tw *tar.Writer, filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    info, err := file.Stat()
    if err != nil {
        return err
    }

    header, err := tar.FileInfoHeader(info, info.Name())
    if err != nil {
        return err
    }

    if err := tw.WriteHeader(header); err != nil {
        return err
    }

    _, err = io.Copy(tw, file)
    return err
}

2. Subpaquete archive/zip

2.1 Conceptos Básicos

El formato ZIP es uno de los formatos de compresión más populares, especialmente en entornos Windows.

2.2 Ejemplos Detallados

2.2.1 Crear un Archivo ZIP

Propósito: Crear un nuevo archivo ZIP con múltiples archivos.

func createZip(files []string, zipName string) error {
    zipfile, err := os.Create(zipName)
    if err != nil {
        return err
    }
    defer zipfile.Close()

    archive := zip.NewWriter(zipfile)
    defer archive.Close()

    for _, file := range files {
        if err := addFileToZip(archive, file); err != nil {
            return err
        }
    }
    return nil
}

func addFileToZip(archive *zip.Writer, filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    info, err := file.Stat()
    if err != nil {
        return err
    }

    header, err := zip.FileInfoHeader(info)
    if err != nil {
        return err
    }
    header.Method = zip.Deflate

    writer, err := archive.CreateHeader(header)
    if err != nil {
        return err
    }

    _, err = io.Copy(writer, file)
    return err
}

2.2.2 Leer un Archivo ZIP

Propósito: Extraer y leer el contenido de un archivo ZIP.

func readZip(filename string) error {
    reader, err := zip.OpenReader(filename)
    if err != nil {
        return err
    }
    defer reader.Close()

    for _, file := range reader.File {
        fmt.Printf("Archivo: %s\n", file.Name)
        
        rc, err := file.Open()
        if err != nil {
            return err
        }
        defer rc.Close()

        content, err := io.ReadAll(rc)
        if err != nil {
            return err
        }
        fmt.Printf("Contenido: %s\n", content)
    }
    return nil
}

2.3 Características Avanzadas

2.3.1 Compresión con Contraseña

Propósito: Crear archivos ZIP protegidos con contraseña.

func createPasswordProtectedZip(files []string, zipName, password string) error {
    zipfile, err := os.Create(zipName)
    if err != nil {
        return err
    }
    defer zipfile.Close()

    archive := zip.NewWriter(zipfile)
    defer archive.Close()

    for _, file := range files {
        header := &zip.FileHeader{
            Name:   file,
            Method: zip.Deflate,
        }
        
        // Establecer el bit de encriptación
        header.SetPassword(password)
        
        writer, err := archive.CreateHeader(header)
        if err != nil {
            return err
        }

        content, err := os.ReadFile(file)
        if err != nil {
            return err
        }

        _, err = writer.Write(content)
        if err != nil {
            return err
        }
    }
    return nil
}

3. Mejores Prácticas

3.1 Manejo de Errores

• Verificar siempre los errores retornados
• Usar defer para cerrar recursos
• Implementar recuperación de errores

3.2 Cierre de Recursos

• Usar defer para cerrar archivos y writers
• Manejar correctamente los recursos en caso de error

3.3 Compresión Eficiente

• Elegir el método de compresión adecuado
• Considerar el tamaño de los archivos
• Implementar compresión progresiva para archivos grandes

3.4 Consideraciones de Memoria

• Usar io.Copy para archivos grandes
• Implementar buffers para control de memoria
• Considerar el uso de goroutines para procesamiento paralelo

4. Tips y Trucos

1. Procesamiento de Archivos Grandes:
   • Usar io.Copy en lugar de io.ReadAll
   • Implementar barras de progreso
   • Considerar procesamiento en chunks
2. Optimización de Rendimiento:
   • Usar goroutines para procesamiento paralelo
   • Implementar buffers de tamaño adecuado
   • Evitar operaciones innecesarias en memoria
3. Verificación de Integridad:
   • Verificar checksums después de la compresión
   • Implementar validación de archivos
   • Manejar casos de corrupción

5. Ejemplo Integrado: Sistema de Backup

type BackupSystem struct {
    sourceDir  string
    backupDir  string
    compression string  // "zip" o "tar"
}

func (bs *BackupSystem) CreateBackup() error {
    timestamp := time.Now().Format("20060102_150405")
    filename := fmt.Sprintf("backup_%s.%s", timestamp, bs.compression)
    outputPath := filepath.Join(bs.backupDir, filename)

    switch bs.compression {
    case "zip":
        return bs.createZipBackup(outputPath)
    case "tar":
        return bs.createTarBackup(outputPath)
    default:
        return fmt.Errorf("formato de compresión no soportado: %s", bs.compression)
    }
}

Este documento proporciona una visión completa del paquete archive en Go. Para casos específicos o necesidades particulares, consulta la documentación oficial o pregunta para más detalles.