Rust में फ़ाइल सिस्टम के साथ काम करना: शुरुआती लोगों के लिए पूर्ण गाइड

Rust में फ़ाइल सिस्टम के साथ काम करने का परिचय

Rust एक आधुनिक सिस्टम प्रोग्रामिंग भाषा है जो सुरक्षा, प्रदर्शन और मेमोरी नियंत्रण पर बहुत अधिक ध्यान देती है। फ़ाइल सिस्टम के साथ काम करना एक मौलिक कार्य है जिसका सामना हर डेवलपर को करना पड़ता है। इस लेख में, हम विस्तार से समझेंगे कि फ़ाइलों को कैसे पढ़ें और लिखें, निर्देशिकाएँ कैसे बनाएँ, त्रुटियों को कैसे संभालें और फ़ाइल सिस्टम के साथ कुशलतापूर्वक बातचीत करने के लिए मानक लाइब्रेरी std::fs का उपयोग कैसे करें।

हम बुनियादी बातों से शुरू करेंगे और धीरे-धीरे अधिक जटिल परिदृश्यों की ओर बढ़ेंगे। सभी कोड उदाहरण Rust में लिखे गए हैं और चलाने के लिए तैयार हैं। यदि आप अभी Rust सीखना शुरू कर रहे हैं, तो यह लेख इस भाषा में इनपुट-आउटपुट (I/O) में महारत हासिल करने के लिए एक उत्कृष्ट शुरुआती बिंदु होगा।

फ़ाइल सिस्टम के साथ काम करने के लिए मुख्य मॉड्यूल और प्रकार

Rust में, फ़ाइलों और निर्देशिकाओं के साथ काम करने की सभी कार्यक्षमता मॉड्यूल std::fs में केंद्रित है। इसके अलावा, std::path मॉड्यूल से Path और PathBuf प्रकार महत्वपूर्ण भूमिका निभाते हैं, जो फ़ाइलों और निर्देशिकाओं के पथों का प्रतिनिधित्व करते हैं।

Path और PathBuf प्रकार

Path डेटा के स्वामित्व के बिना पथों के साथ काम करने के लिए एक स्लाइस है। PathBuf एक स्वामित्व वाला संस्करण है जिसे संशोधित किया जा सकता है। वे पथों में हेरफेर करने के लिए सुविधाजनक विधियाँ प्रदान करते हैं।

use std::path::Path;\nuse std::path::PathBuf;\n\nfn main() {\n    // PathBuf बनाना\n    let mut path = PathBuf::from("/tmp");\n    path.push("example.txt");\n    println!("पथ: {}", path.display());\n\n    // Path में रूपांतरण\n    let path_ref: &Path = path.as_path();\n    println!("मूल निर्देशिका: {:?}", path_ref.parent());\n}

मॉड्यूल std::fs

मॉड्यूल std::fs में फ़ाइल सिस्टम के साथ काम करने के लिए मुख्य फ़ंक्शन शामिल हैं। यहाँ सबसे अधिक उपयोग किए जाने वाले फ़ंक्शन हैं:

\n
• read_to_string — फ़ाइल को स्ट्रिंग में पढ़ना
\n
• write — फ़ाइल में डेटा लिखना
\n
• create_dir और create_dir_all — निर्देशिकाएँ बनाना
\n
• remove_file और remove_dir — फ़ाइलों और निर्देशिकाओं को हटाना
\n
• metadata — फ़ाइल के बारे में जानकारी प्राप्त करना
\n
• copy और rename — कॉपी करना और नाम बदलना
\n

Rust में फ़ाइलें पढ़ना और लिखना

फ़ाइल को पढ़ने या लिखने का सबसे सरल तरीका रैपर फ़ंक्शन का उपयोग करना है जो एक ही कॉल में सारा काम करते हैं। वे छोटी फ़ाइलों के लिए उपयुक्त हैं जो पूरी तरह से मेमोरी में समा जाती हैं।

पूरी फ़ाइल पढ़ना

use std::fs;\n\nfn main() -> Result<(), std::io::Error> {\n    let content = fs::read_to_string("hello.txt")?;\n    println!("फ़ाइल की सामग्री:\\n{}", content);\n    Ok(())\n}

फ़ंक्शन read_to_string एक Result<String> लौटाता है। यदि फ़ाइल मौजूद नहीं है या पढ़ने की अनुमति नहीं है, तो एक त्रुटि वापस आएगी। ऑपरेटर ? पर ध्यान दें — यह स्वचालित रूप से त्रुटि को ऊपर भेज देता है।

फ़ाइल में लिखना

use std::fs;\n\nfn main() -> Result<(), std::io::Error> {\n    let data = "नमस्ते, Rust!";\n    fs::write("output.txt", data)?;\n    println!("फ़ाइल सफलतापूर्वक लिखी गई");\n    Ok(())\n}

फ़ंक्शन write फ़ाइल को ओवरराइट करता है यदि वह मौजूद है, या एक नई फ़ाइल बनाता है। फ़ाइल के अंत में डेटा जोड़ने के लिए OpenOptions का उपयोग करें।

बाइनरी फ़ाइलों के साथ काम करना

बाइनरी डेटा को पढ़ने और लिखने के लिए बाइट्स के वेक्टर के साथ read और write का उपयोग करें:

use std::fs;\n\nfn main() -> Result<(), std::io::Error> {\n    // बाइनरी डेटा लिखना\n    let bytes: Vec<u8> = vec![0, 1, 2, 3, 255];\n    fs::write("binary.dat", &bytes)?;\n\n    // बाइट्स के रूप में पढ़ना\n    let read_bytes = fs::read("binary.dat")?;\n    println!("पढ़ा गया