Arbeiten mit ZIP-Archiven in Go: Vollständige Anleitung zum Paket archive/zip

Arbeiten mit ZIP-Archiven in Go (Golang)

In der modernen Entwicklung mit Go besteht häufig die Notwendigkeit, mit Archiven zu arbeiten – zum Verpacken von Logs, Verteilen von Konfigurationen, für Backups oder zur Datenübertragung zwischen Microservices. Die Standardbibliothek von Go bietet ein leistungsstarkes und flexibles Paket archive/zip, mit dem Sie ZIP-Archive ohne externe Abhängigkeiten erstellen, lesen und ändern können. In diesem Artikel werden wir alle Aspekte der Arbeit mit ZIP-Archiven in Go im Detail behandeln.

Überblick über das Paket archive/zip

Das Paket archive/zip ist Teil der Go-Standardbibliothek und unterstützt:

• Lesen und Schreiben von ZIP-Archiven (PKWARE-Format)
• Komprimierung mit Deflate und Stored (ohne Komprimierung)
• Arbeiten mit Dateien und Verzeichnissen innerhalb des Archivs
• Unterstützung von Kommentaren für das Archiv und einzelne Dateien
• Festlegen von Dateiattributen (Datum, Zugriffsrechte)
• Streaming-Verarbeitung (Archive können Gigabyte groß sein)

Wichtige Typen: zip.Writer zum Erstellen von Archiven und zip.Reader zum Lesen.

Erstellen eines ZIP-Archivs

Zum Erstellen eines Archivs wird zip.NewWriter verwendet, das einen io.Writer akzeptiert. Jede Datei wird über Create oder CreateHeader hinzugefügt.

package main

import (    "archive/zip"    "bytes"    "fmt"    "io"    "log"    "os")

func main() {    // Puffer für das Archiv erstellen    buf := new(bytes.Buffer)    writer := zip.NewWriter(buf)

    // Textdatei hinzufügen    file1, err := writer.Create("hello.txt")    if err != nil {        log.Fatal(err)    }    _, err = file1.Write([]byte("Hallo, Go ZIP!"))    if err != nil {        log.Fatal(err)    }

    // Datei mit Unterverzeichnis hinzufügen    file2, err := writer.Create("config/settings.json")    if err != nil {        log.Fatal(err)    }    _, err = file2.Write([]byte(`{"version": 1, "debug": true}`))    if err != nil {        log.Fatal(err)    }

    // Writer unbedingt schließen    err = writer.Close()    if err != nil {        log.Fatal(err)    }

    // Archiv auf die Festplatte speichern    err = os.WriteFile("example.zip", buf.Bytes(), 0644)    if err != nil {        log.Fatal(err)    }    fmt.Println("Archiv erstellt: example.zip")}

Lesen und Extrahieren von Dateien aus dem Archiv

Zum Lesen eines Archivs wird zip.NewReader verwendet, dem ein io.ReaderAt und die Archivgröße übergeben werden. Es kann sowohl in den Speicher als auch per Streaming gelesen werden.

func readArchive() {    // Archivdatei öffnen    reader, err := zip.OpenReader("example.zip")    if err != nil {        log.Fatal(err)    }    defer reader.Close()

    // Alle Dateien im Archiv durchlaufen    for _, file := range reader.File {        fmt.Printf("Datei: %s (Größe: %d Bytes)", file.Name, file.UncompressedSize64)

        // Datei im Archiv öffnen        rc, err := file.Open()        if err != nil {            log.Fatal(err)        }

        // Inhalt lesen        content, err := io.ReadAll(rc)        if err != nil {            log.Fatal(err)        }        rc.Close()

        fmt.Printf("Inhalt: %s

", content)    }}

Hinzufügen von Dateien mit Metadaten

Mit zip.FileHeader können Datum, Zugriffsrechte und Komprimierungsmethode festgelegt werden:

func addFileWithMetadata(w *zip.Writer, name, content string) error {    header := &zip.FileHeader{        Name:   name,        Method: zip.Deflate, // Deflate verwenden (Komprimierung)    }    // Änderungszeit festlegen    header.SetModTime(time.Now())    // Zugriffsrechte festlegen (Unix rw-r--r--)    header.SetMode(0644)

    f, err := w.CreateHeader(header)    if err != nil {        return err    }    _, err = f.Write([]byte(content))    return