रस्ट मानक पुस्तकालय: पूर्ण समीक्षा

रस्ट मानक पुस्तकालय: पूर्ण समीक्षा

रस्ट मानक पुस्तकालय (std) भाषा के पारिस्थितिकी तंत्र का मूल है, जो डेवलपर्स को उच्च-प्रदर्शन अनुप्रयोग बनाने के लिए शक्तिशाली और सुरक्षित उपकरण प्रदान करता है। कई अन्य भाषाओं के विपरीत, रस्ट मेमोरी सुरक्षा और शून्य-लागत अमूर्तता पर विशेष ध्यान देता है, जो std को केवल उपयोगिताओं का एक सेट नहीं, बल्कि विश्वसनीय कोड लिखने की नींव बनाता है। इस लेख में, हम मानक पुस्तकालय के मुख्य मॉड्यूल, उनकी क्षमताओं का विस्तार से विश्लेषण करेंगे और व्यावहारिक उदाहरण प्रस्तुत करेंगे।

मानक पुस्तकालय के मुख्य मॉड्यूल

रस्ट मानक पुस्तकालय में कई मॉड्यूल शामिल हैं जो विकास के लगभग सभी पहलुओं को कवर करते हैं। आइए उनमें से प्रमुख पर नज़र डालें:

• std::collections — डेटा संरचनाएँ (HashMap, Vec, BTreeMap, HashSet और अन्य)
• std::io — इनपुट-आउटपुट (फ़ाइल पढ़ना/लिखना, कंसोल के साथ काम करना)
• std::fs — फ़ाइल सिस्टम के साथ काम करना
• std::thread — मल्टीथ्रेडिंग
• std::sync — थ्रेड सिंक्रोनाइज़ेशन (Mutex, Arc, Barrier)
• std::net — नेटवर्क प्रोग्रामिंग (TCP, UDP)
• std::path — फ़ाइल सिस्टम पथों के साथ काम करना
• std::error — त्रुटि प्रबंधन

संग्रहों के साथ काम करना (std::collections)

मॉड्यूल std::collections कुशल डेटा संरचनाएँ प्रदान करता है। सबसे लोकप्रिय है Vec<T> (डायनामिक ऐरे)। इसके अलावा, कुंजी-मान जोड़े संग्रहीत करने के लिए HashMap<K, V> और अद्वितीय तत्वों के लिए HashSet<T> का अक्सर उपयोग किया जाता है।

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Blue"), 10);    scores.insert(String::from("Yellow"), 50);

    // कुंजी द्वारा पहुँच    match scores.get(&"Blue".to_string()) {        Some(score) => println!("Score: {}", score),        None => println!("No score found"),    }}

इनपुट-आउटपुट और फ़ाइलों के साथ काम करना (std::io और std::fs)

मॉड्यूल std::io और std::fs फ़ाइलों को पढ़ने और लिखने, कंसोल इनपुट/आउटपुट के साथ काम करने की अनुमति देते हैं। रस्ट स्वामित्व प्रणाली के कारण फ़ाइलों के साथ सुरक्षित कार्य की गारंटी देता है।

use std::fs::File;use std::io::{BufRead, BufReader, Write};

fn main() -> std::io::Result<()> {    // फ़ाइल में लिखना    let mut file = File::create("example.txt")?;    file.write_all(b"Hello, Rust!")?;

    // फ़ाइल को पंक्ति दर पंक्ति पढ़ना    let file = File::open("example.txt")?;    let reader = BufReader::new(file);    for line in reader.lines() {        println!("{}", line?);    }    Ok(())}

मल्टीथ्रेडिंग (std::thread)

रस्ट मॉड्यूल std::thread के माध्यम से एक सुरक्षित मल्टीथ्रेडिंग मॉडल प्रदान करता है। कंपाइलर स्वामित्व और उधार लेने के नियमों के कारण संकलन चरण में डेटा रेस को रोकता है।

use std::thread;use std::time::Duration;

fn main() {    let handle = thread::spawn(|| {        for i in 1..5 {            println!("थ्रेड: {}", i);            thread::sleep(Duration::from_millis(100));        }    });

    for i in 1..3 {        println!("मुख्य थ्रेड: {}", i);        thread::sleep(Duration::from_millis(50));    }

    handle.join().unwrap();}

सिंक्रोनाइज़ेशन (std::sync)

थ्रेड्स के बीच सुरक्षित डेटा साझा करने के लिए std::sync से प्रिमिटिव का उपयोग किया जाता है: Mutex (पारस्परिक बहिष्करण), Arc (परमाणु संदर्भ काउंटर) और Barrier (सिंक्रोनाइज़ेशन बैरियर)।

use std::sync::{Arc, Mutex};use std::thread;

fn main() {    let counter = Arc::new(Mutex::new(0));    let mut handles = vec![];

    for _ in 0..10 {\