Go (Golang) में ZIP आर्काइव के साथ काम करना

Go में आधुनिक डेवलपमेंट के दौरान अक्सर आर्काइव के साथ काम करने की ज़रूरत पड़ती है — लॉग पैक करने, कॉन्फ़िगरेशन वितरित करने, बैकअप बनाने या माइक्रोसर्विसेज़ के बीच डेटा ट्रांसफर करने के लिए। Go की स्टैंडर्ड लाइब्रेरी में शक्तिशाली और लचीला पैकेज archive/zip शामिल है, जो बिना किसी तीसरे पक्ष की डिपेंडेंसी के ZIP आर्काइव बनाने, पढ़ने और संशोधित करने की सुविधा देता है। इस लेख में हम Go में ZIP आर्काइव के सभी पहलुओं को विस्तार से समझेंगे।

archive/zip पैकेज का परिचय

archive/zip पैकेज Go की स्टैंडर्ड लाइब्रेरी का हिस्सा है और यह निम्नलिखित सुविधाएँ प्रदान करता है:

ZIP आर्काइव (PKWARE फ़ॉर्मेट) पढ़ना और लिखना
Deflate और Stored (बिना कंप्रेशन) कंप्रेशन विधि
आर्काइव के अंदर फ़ाइलों और डायरेक्टरीज़ के साथ काम करना
आर्काइव और अलग-अलग फ़ाइलों के लिए कमेंट सपोर्ट
फ़ाइल एट्रीब्यूट (दिनांक, एक्सेस परमिशन) सेट करना
स्ट्रीमिंग प्रोसेसिंग (आर्काइव गीगाबाइट्स आकार के भी हो सकते हैं)

मुख्य टाइप: आर्काइव बनाने के लिए zip.Writer और पढ़ने के लिए zip.Reader।

ZIP आर्काइव बनाना

आर्काइव बनाने के लिए zip.NewWriter का उपयोग किया जाता है, जो io.Writer को स्वीकार करता है। प्रत्येक फ़ाइल Create या CreateHeader के माध्यम से जोड़ी जाती है।

package main

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

func main() {
    // आर्काइव के लिए बफ़र बनाएँ
    buf := new(bytes.Buffer)
    writer := zip.NewWriter(buf)

    // टेक्स्ट फ़ाइल जोड़ें
    file1, err := writer.Create("hello.txt")
    if err != nil {
        log.Fatal(err)
    }
    _, err = file1.Write([]byte("Hello, Go ZIP!"))
    if err != nil {
        log.Fatal(err)
    }

    // सबडायरेक्टरी के साथ फ़ाइल जोड़ें
    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 को बंद करना अनिवार्य है
    err = writer.Close()
    if err != nil {
        log.Fatal(err)
    }

    // आर्काइव को डिस्क पर सेव करें
    err = os.WriteFile("example.zip", buf.Bytes(), 0644)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("आर्काइव बन गया: example.zip")
}

आर्काइव से फ़ाइलें पढ़ना और निकालना

आर्काइव पढ़ने के लिए zip.NewReader का उपयोग किया जाता है, जिसे io.ReaderAt और आर्काइव का आकार दिया जाता है। इसे मेमोरी में या स्ट्रीमिंग मोड में पढ़ा जा सकता है।

func readArchive() {
    // आर्काइव फ़ाइल खोलें
    reader, err := zip.OpenReader("example.zip")
    if err != nil {
        log.Fatal(err)
    }
    defer reader.Close()

    // आर्काइव की सभी फ़ाइलों पर लूप करें
    for _, file := range reader.File {
        fmt.Printf("फ़ाइल: %s (आकार: %d बाइट)\n", file.Name, file.UncompressedSize64)

        // आर्काइव के अंदर फ़ाइल खोलें
        rc, err := file.Open()
        if err != nil {
            log.Fatal(err)
        }

        // सामग्री पढ़ें
        content, err := io.ReadAll(rc)
        if err != nil {
            log.Fatal(err)
        }
        rc.Close()

        fmt.Printf("सामग्री: %s\n\n", content)
    }
}

मेटाडेटा के साथ फ़ाइलें जोड़ना

zip.FileHeader की मदद से दिनांक, एक्सेस परमिशन और कंप्रेशन विधि सेट की जा सकती है:

func addFileWithMetadata(w *zip.Writer, name, content string) error {
    header := &zip.FileHeader{
        Name:   name,
        Method: zip.Deflate, // Deflate (कंप्रेशन) का उपयोग करें
    }
    // मॉडिफिकेशन टाइम सेट करें
    header.SetModTime(time.Now())
    // एक्सेस परमिशन सेट करें (Unix rw-r--r--)
    header.SetMode(0644)

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