Rust में ZIP आर्काइव के साथ काम: zip लाइब्रेरी पूरी गाइड

Rust में zip लाइब्रेरी के साथ ZIP आर्काइव का उपयोग

Rust में डेवलपमेंट करते समय अक्सर फ़ाइलों को ZIP आर्काइव में पैक करने या उनसे डेटा निकालने की ज़रूरत होती है। यह सॉफ़्टवेयर वितरण, बैकअप बनाने, उपयोगकर्ता द्वारा अपलोड किए गए आर्काइव को प्रोसेस करने या पैकेज बनाने के लिए आवश्यक हो सकता है। Rust की मानक लाइब्रेरी में ZIP के लिए कोई अंतर्निहित सुविधा नहीं है, लेकिन इसका इकोसिस्टम एक शक्तिशाली और उपयोगी लाइब्रेरी zip प्रदान करता है।

इस लेख में हम विस्तार से जानेंगे कि zip लाइब्रेरी का उपयोग करके ZIP आर्काइव कैसे बनाएं, पढ़ें और निकालें। आप सीखेंगे कि लाइब्रेरी कैसे इंस्टॉल करें, फ़ाइलों और डायरेक्टरी के साथ काम करें, त्रुटियों को संभालें और कंप्रेशन को मैनेज करें।

zip लाइब्रेरी इंस्टॉल करना

शुरू करने के लिए, अपने प्रोजेक्ट के Cargo.toml फ़ाइल में डिपेंडेंसी जोड़ें:

[dependencies]
zip = "2.2"

यह लाइब्रेरी सक्रिय रूप से मेंटेन की जाती है और Rust की आधुनिक सुविधाओं का उपयोग करती है। डिपेंडेंसी जोड़ने के बाद, आप इसे अपने कोड में इम्पोर्ट कर सकते हैं:

use zip::ZipWriter;
use zip::read::ZipArchive;
use std::io::{Read, Write, BufWriter, BufReader};
use std::fs::{self, File};

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

आर्काइव बनाने में कई चरण शामिल हैं: लिखने के लिए फ़ाइल खोलना, ZipWriter को इनिशियलाइज़ करना, फ़ाइलें जोड़ना और लिखना पूरा करना। आइए एक उदाहरण देखें जो एक टेक्स्ट फ़ाइल को पैक करता है:

use std::fs::File;
use zip::ZipWriter;
use zip::write::FileOptions;
use std::io::Write;

fn create_archive() -> zip::result::ZipResult<()> {
    let file = File::create("example.zip")?;
    let mut zip = ZipWriter::new(file);

    let options = FileOptions::default()
        .compression_method(zip::CompressionMethod::Deflated)
        .unix_permissions(0o755);

    zip.start_file("hello.txt", options)?;
    zip.write_all(b"Hello, Rust ZIP!")?;

    zip.finish()?;
    Ok(())
}

यहाँ हम:

• वर्तमान डायरेक्टरी में example.zip फ़ाइल बनाते हैं।
• ZipWriter को इनिशियलाइज़ करते हैं।
• फ़ाइल के पैरामीटर सेट करते हैं: कंप्रेशन विधि Deflated (मानक कंप्रेशन) और एक्सेस अनुमतियाँ।
• hello.txt फ़ाइल जोड़ते हैं और उसमें कंटेंट लिखते हैं।
• finish() कॉल करके लिखना पूरा करते हैं।

एक से अधिक फ़ाइलें या पूरी डायरेक्टरी जोड़ने के लिए, फ़ोल्डर में फ़ाइलों पर लूप का उपयोग करें:

fn add_directory(zip: &mut ZipWriter<File>, dir_path: &str) -> zip::result::ZipResult<()> {
    for entry in walkdir::WalkDir::new(dir_path) {
        let entry = entry?;
        let path = entry.path();
        if path.is_file() {
            let name = path.strip_prefix(dir_path).unwrap().to_str().unwrap();
            zip.start_file(name, FileOptions::default())?;
            let mut f = File::open(path)?;
            std::io::copy(&mut f, zip)?;
        }
    }
    Ok(())
}

ध्यान दें: डायरेक्टरी को रिकर्सिवली ट्रैवर्स करने के लिए walkdir क्रेट उपयोगी है, लेकिन इसे अलग से जोड़ना होगा।

ZIP आर्काइव पढ़ना और निकालना

आर्काइव पढ़ने के लिए ZipArchive का उपयोग किया जाता है। नीचे एक उदाहरण दिया गया है जो आर्काइव में फ़ाइलों की सूची दिखाता है और उन्हें निर्दिष्ट फ़ोल्डर में निकालता है:

use zip::ZipArchive;
use std::io::Read;

fn extract_archive(archive_path: &str, output_dir: &str) -> zip::result::ZipResult<()> {
    let file = File::open(archive_path)?;
    let mut archive = ZipArchive::new(file)?;

    for i in 0..archive.len() {
        let mut entry = archive.by_index(i)?;
        let entry_name = entry.name().to_string();
        println!("निकाला जा रहा है: {}", entry_name);

        // फ़ाइल का पूरा पथ बनाएँ
        let output_path = format!("{}/{}", output_dir, entry_name);
        if entry_name.ends_with('/') {
            fs::create_dir_all(&output_path)?