Rust में फ़ाइल सिस्टम के साथ काम करना: पूर्ण गाइड

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

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

यह सामग्री उन शुरुआती लोगों के लिए उपयोगी होगी जो अभी Rust से परिचित हो रहे हैं, साथ ही अनुभवी डेवलपर्स के लिए भी जो अपने ज्ञान को ताज़ा करना चाहते हैं। सभी कोड उदाहरण चलाने के लिए तैयार हैं और टिप्पणियों के साथ दिए गए हैं।

मुख्य मॉड्यूल और इम्पोर्ट

Rust में फ़ाइल सिस्टम के साथ काम करने के लिए दो प्रमुख मॉड्यूल का उपयोग किया जाता है:

• std::fs — फ़ाइलों और फ़ोल्डरों के संचालन (पढ़ना, लिखना, हटाना, कॉपी करना आदि) के लिए फ़ंक्शन प्रदान करता है।
• std::path — पथों के साथ काम करने के लिए Path और PathBuf प्रकार शामिल हैं।

अधिकांश कार्यों के लिए, निम्नलिखित इम्पोर्ट जोड़ना पर्याप्त है:

use std::fs;use std::path::Path;use std::io::prelude::*; // स्ट्रीम के साथ काम करने के लिए

फ़ाइलों के साथ काम करना: पढ़ना और लिखना

फ़ाइल की सामग्री पढ़ना

पूरी फ़ाइल को एक स्ट्रिंग में पढ़ने का सबसे सरल तरीका fs::read_to_string फ़ंक्शन का उपयोग करना है। यह Result<String> लौटाता है, इसलिए संभावित त्रुटि को संभालना आवश्यक है।

use std::fs;

fn read_file(path: &str) -> Result<String, std::io::Error> {    let content = fs::read_to_string(path)?;    Ok(content)}

fn main() {    match read_file("example.txt") {        Ok(text) => println!("फ़ाइल की सामग्री:{}", text),        Err(e) => eprintln!("पढ़ने में त्रुटि: {}", e),    }}

यदि आपको फ़ाइल को बाइनरी डेटा के रूप में पढ़ने की आवश्यकता है, तो fs::read का उपयोग करें, जो Vec<u8> लौटाता है।

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

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

use std::fs;

fn write_file(path: &str, content: &str) -> Result<(), std::io::Error> {    fs::write(path, content)?;    println!("फ़ाइल सफलतापूर्वक लिखी गई");    Ok(())}

fn main() {    let data = "Hello, Rust!दूसरी पंक्ति।";    if let Err(e) = write_file("output.txt", data) {        eprintln!("लिखने में त्रुटि: {}", e);    }}

फ़ाइल के अंत में जोड़ने या अधिक सूक्ष्म नियंत्रण के लिए OpenOptions का उपयोग करें:

use std::fs::OpenOptions;use std::io::Write;

fn append_to_file(path: &str, line: &str) -> Result<(), std::io::Error> {    let mut file = OpenOptions::new()        .append(true)        .create(true)        .open(path)?;    writeln!(file, "{}", line)?;    Ok(())}

निर्देशिकाओं के साथ काम करना

फ़ोल्डर बनाना और हटाना

निर्देशिका बनाने के लिए fs::create_dir (एक फ़ोल्डर) या fs::create_dir_all (पुनरावर्ती रूप से, जैसे mkdir -p) का उपयोग करें।

use std::fs;

fn main() -> Result<(), std::io::Error> {    // एक फ़ोल्डर बनाना    fs::create_dir("my_folder")?;

    // नेस्टेड फ़ोल्डर पुनरावर्ती रूप से बनाना    fs::create_dir_all("data/subdir/logs")?;

    // खाली फ़ोल्डर हटाना    fs::remove_dir("my_folder")?;

    // फ़ोल्डर को उसकी सभी सामग्री सहित पुनरावर्ती रूप से हटाना    fs::remove_dir_all("data")?;

    Ok(())}

निर्देशिका की सामग्री पढ़ना

fs::read_dir फ़ंक्शन निर्देशिका प्रविष्टियों पर एक इटरेटर लौटाता है। प्रत्येक प्रविष्टि एक DirEntry है, जिससे आप नाम, प्रकार और मेटाडेटा प्राप्त कर सकते हैं।

use std::fs;

fn list_directory(path:
```