Rust फ़ाइल सिस्टम: शुरुआत से विशेषज्ञ तक पूरी गाइड

Rust में फ़ाइलों के साथ काम करना: दर्द नहीं, बल्कि आनंद क्यों है?

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

तैयार हैं? चलिए शुरू करते हैं!

मूल बातें: खोलना, पढ़ना, बंद करना

Rust में Python की तरह कोई बिल्ट-इन open() फ़ंक्शन नहीं है। इसके बजाय, हम शक्तिशाली मॉड्यूल std::fs का उपयोग करते हैं। आइए सबसे सरल चीज़ से शुरू करें — पूरी फ़ाइल को पढ़ना।

पूरी फ़ाइल को स्ट्रिंग में पढ़ना

फ़ाइल पढ़ने का सबसे आसान तरीका std::fs::read_to_string का उपयोग करना है। यह Python में file.read() के समान है, लेकिन सुरक्षा की गारंटी के साथ।

use std::fs;\n\nfn main() {\n    let content = fs::read_to_string("hello.txt")\n        .expect("फ़ाइल पढ़ने में विफल");\n    println!("फ़ाइल की सामग्री:\\n{}", content);\n}

.expect() पर ध्यान दें। Rust में एक्सेप्शन नहीं हैं — Result है। अगर फ़ाइल मौजूद नहीं है, तो प्रोग्राम स्पष्ट संदेश के साथ "क्रैश" हो जाएगा। प्रोडक्शन कोड के लिए match या unwrap_or_else का उपयोग करना बेहतर है, लेकिन सीखने के लिए expect आदर्श है।

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

लिखना भी उतना ही सहज है:

use std::fs;\n\nfn main() {\n    let data = "Hello, Rust!\\nयह एक परीक्षण लेखन है।";\n    fs::write("output.txt", data)\n        .expect("फ़ाइल लिखने में विफल");\n    println!("फ़ाइल सफलतापूर्वक लिखी गई!");\n}

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

पथों के साथ काम करना: Path और PathBuf

Rust में पथों के साथ काम करने के लिए दो मुख्य प्रकार हैं: Path (उधार लिया गया, अपरिवर्तनीय) और PathBuf (स्वामित्व वाला, परिवर्तनीय)। इनके बीच अंतर को समझना फ़ाइल सिस्टम के साथ कुशलतापूर्वक काम करने की कुंजी है।

पथ बनाना और हेरफेर करना

use std::path::{Path, PathBuf};\n\nfn main() {\n    // पथ बनाएं\n    let path = Path::new("data/subdir/file.txt");\n    \n    // पथ के घटक प्राप्त करें\n    println!("पैरेंट डायरेक्टरी: {:?}", path.parent());\n    println!("फ़ाइल का नाम: {:?}", path.file_name());\n    println!("एक्सटेंशन: {:?}", path.extension());\n    \n    // नया पथ बनाएं\n    let mut new_path = PathBuf::from("backup");\n    new_path.push("data");\n    new_path.push("file.txt");\n    println!("नया पथ: {}", new_path.display());\n}

यदि आप टर्मिनल में पथ प्रिंट करना चाहते हैं तो .display() मेथड अनिवार्य है। Rust आपको सीधे स्ट्रिंग में पथ डालने की अनुमति नहीं देता — यह एन्कोडिंग समस्याओं से सुरक्षा है।

पढ़ना और लिखना: उन्नत स्तर

जब आपको अधिक नियंत्रण की आवश्यकता हो, तो File और BufReader/BufWriter का उपयोग करें।

फ़ाइल को लाइन दर लाइन पढ़ना

बड़ी फ़ाइलों के लिए, सब कुछ मेमोरी में पढ़ना अकुशल है। बफ़र किए गए रीडिंग का उपयोग करें:

use std::fs::File;\nuse std::io::{BufRead, BufReader};\n\nfn main() {\n    let file = File::open("large_file.txt")\n        .expect("फ़ाइल नहीं मिली");\n    let reader = BufReader::new(file);\n    \n    for (index, line) in reader.lines().enumerate() {\n        let line = line.expect("लाइन पढ़ने में त्रुटि");\n        println!("लाइन {}: {}", index + 1, line);\n    }\n}

यह दृष्टिकोण आपको किसी भी आकार की फ़ाइलों को प्रोसेस करने की अनुमति देता है, बिना उन्हें पूरी तरह से RAM में लोड किए।

फ़ाइल के अंत में डेटा जोड़ना